feat: resolve ref params if present when describing

fixes #2276

Author: jquense

src/index.ts

@@ -21,6 +21,7 @@ import defaultLocale from './locale';
 import Schema, {
   AnySchema,
   CastOptions as BaseCastOptions,
+  SchemaSpec,
   SchemaRefDescription,
   SchemaInnerTypeDescription,
   SchemaObjectDescription,
@@ -77,6 +78,7 @@ export type {
   AnySchema,
   MixedOptions,
   TypeGuard as MixedTypeGuard,
+  SchemaSpec,
   SchemaRefDescription,
   SchemaInnerTypeDescription,
   SchemaObjectDescription,

src/schema.ts

@@ -11,6 +11,7 @@ import createValidation, {
   NextCallback,
   PanicCallback,
   TestOptions,
+  resolveParams,
 } from './util/createValidation';
 import printValue from './util/printValue';
 import Ref from './Reference';
@@ -943,10 +944,21 @@ export default abstract class Schema<
       oneOf: next._whitelist.describe(),
       notOneOf: next._blacklist.describe(),
       tests: next.tests
-        .map((fn) => ({ name: fn.OPTIONS!.name, params: fn.OPTIONS!.params }))
         .filter(
-          (n, idx, list) => list.findIndex((c) => c.name === n.name) === idx,
-        ),
+          (n, idx, list) =>
+            list.findIndex((c) => c.OPTIONS!.name === n.OPTIONS!.name) === idx,
+        )
+        .map((fn) => {
+          const params =
+            fn.OPTIONS!.params && options
+              ? resolveParams({ ...fn.OPTIONS!.params }, options)
+              : fn.OPTIONS!.params;
+
+          return {
+            name: fn.OPTIONS!.name,
+            params,
+          };
+        }),
     };
 
     return description;

src/util/createValidation.ts

@@ -10,6 +10,7 @@ import {
 import Reference from '../Reference';
 import type { AnySchema } from '../schema';
 import isAbsent from './isAbsent';
+import { ResolveOptions } from '../Condition';
 
 export type PanicCallback = (err: Error) => void;
 
@@ -86,26 +87,21 @@ export default function createValidation(config: {
       abortEarly = schema.spec.abortEarly,
       disableStackTrace = schema.spec.disableStackTrace,
     } = options;
-
-    function resolve<T>(item: T | Reference<T>) {
-      return Ref.isRef(item) ? item.getValue(value, parent, context) : item;
-    }
-
+    const resolveOptions = { value, parent, context };
     function createError(overrides: CreateErrorOptions = {}) {
-      const nextParams = {
-        value,
-        originalValue,
-        label: schema.spec.label,
-        path: overrides.path || path,
-        spec: schema.spec,
-        disableStackTrace: overrides.disableStackTrace || disableStackTrace,
-        ...params,
-        ...overrides.params,
-      };
-
-      type Keys = (keyof typeof nextParams)[];
-      for (const key of Object.keys(nextParams) as Keys)
-        nextParams[key] = resolve(nextParams[key]);
+      const nextParams = resolveParams(
+        {
+          value,
+          originalValue,
+          label: schema.spec.label,
+          path: overrides.path || path,
+          spec: schema.spec,
+          disableStackTrace: overrides.disableStackTrace || disableStackTrace,
+          ...params,
+          ...overrides.params,
+        },
+        resolveOptions,
+      );
 
       const error = new ValidationError(
         ValidationError.formatError(overrides.message || message, nextParams),
@@ -126,7 +122,9 @@ export default function createValidation(config: {
       type: name,
       from: options.from,
       createError,
-      resolve,
+      resolve<T>(item: T | Reference<T>) {
+        return resolveMaybeRef(item, resolveOptions);
+      },
       options,
       originalValue,
       schema,
@@ -173,3 +171,24 @@ export default function createValidation(config: {
 
   return validate;
 }
+
+// Warning: mutates the input
+export function resolveParams<T extends ExtraParams>(
+  params: T,
+  options: ResolveOptions,
+) {
+  if (!params) return params;
+
+  type Keys = (keyof typeof params)[];
+  for (const key of Object.keys(params) as Keys) {
+    params[key] = resolveMaybeRef(params[key], options);
+  }
+
+  return params;
+}
+
+function resolveMaybeRef<T>(item: T | Reference<T>, options: ResolveOptions) {
+  return Ref.isRef(item)
+    ? item.getValue(options.value, options.parent, options.context)
+    : item;
+}

test/number.ts

@@ -1,6 +1,6 @@
 import * as TestHelpers from './helpers';
 
-import { number, NumberSchema } from '../src';
+import { number, NumberSchema, object, ref } from '../src';
 
 describe('Number types', function () {
   it('is extensible', () => {
@@ -198,4 +198,39 @@ describe('Number types', function () {
       ),
     ]);
   });
+
+  it('should resolve param refs when describing', () => {
+    let schema = number().min(ref('$foo'));
+
+    expect(schema.describe({ value: 10, context: { foo: 5 } })).toEqual(
+      expect.objectContaining({
+        tests: [
+          expect.objectContaining({
+            params: {
+              min: 5,
+            },
+          }),
+        ],
+      }),
+    );
+
+    let schema2 = object({
+      x: number().min(0),
+      y: number().min(ref('x')),
+    }).required();
+
+    expect(
+      schema2.describe({ value: { x: 10 }, context: { foo: 5 } }).fields.y,
+    ).toEqual(
+      expect.objectContaining({
+        tests: [
+          expect.objectContaining({
+            params: {
+              min: 10,
+            },
+          }),
+        ],
+      }),
+    );
+  });
 });