Add Schema Reflection API

library/src/schemas/any/any.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import { parse } from '../../methods/index.ts';
 import { toCustom } from '../../transformations/index.ts';
+import { maxLength } from '../../validations/index.ts';
 import { any } from './any.ts';
 
 describe('any', () => {
@@ -22,4 +23,14 @@ describe('any', () => {
     const output = parse(any([toCustom(transformInput)]), 123);
     expect(output).toBe(transformInput());
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = any([toCustom(String), maxLength(5)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_length', requirement: 5, message: 'Invalid length' },
+    ]);
+
+    const schema2 = any();
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/any/any.ts

@@ -1,11 +1,12 @@
-import type { BaseSchema, Pipe } from '../../types.ts';
-import { executePipe } from '../../utils/index.ts';
+import type { BaseSchema, Pipe, PipeMeta } from '../../types.ts';
+import { executePipe, getChecks } from '../../utils/index.ts';
 
 /**
  * Any schema type.
  */
 export type AnySchema<TOutput = any> = BaseSchema<any, TOutput> & {
   schema: 'any';
+  checks: PipeMeta[];
 };
 
 /**
@@ -27,6 +28,12 @@ export function any(pipe: Pipe<any> = []): AnySchema {
      */
     async: false,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/any/anyAsync.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import { parseAsync } from '../../methods/index.ts';
 import { toCustom } from '../../transformations/index.ts';
+import { maxLength } from '../../validations/index.ts';
 import { anyAsync } from './anyAsync.ts';
 
 describe('anyAsync', () => {
@@ -22,4 +23,14 @@ describe('anyAsync', () => {
     const output = await parseAsync(anyAsync([toCustom(transformInput)]), 123);
     expect(output).toBe(transformInput());
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = anyAsync([toCustom(String), maxLength(5)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_length', requirement: 5, message: 'Invalid length' },
+    ]);
+
+    const schema2 = anyAsync();
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/any/anyAsync.ts

@@ -1,11 +1,12 @@
-import type { BaseSchemaAsync, PipeAsync } from '../../types.ts';
-import { executePipeAsync } from '../../utils/index.ts';
+import type { BaseSchemaAsync, PipeAsync, PipeMeta } from '../../types.ts';
+import { executePipeAsync, getChecks } from '../../utils/index.ts';
 
 /**
  * Any schema type.
  */
 export type AnySchemaAsync<TOutput = any> = BaseSchemaAsync<any, TOutput> & {
   schema: 'any';
+  checks: PipeMeta[];
 };
 
 /**
@@ -27,6 +28,12 @@ export function anyAsync(pipe: PipeAsync<any> = []): AnySchemaAsync {
      */
     async: true,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/array/array.test.ts

@@ -112,4 +112,14 @@ describe('array', () => {
     expect(() => parse(schema2, [1, 2])).toThrowError(lengthError);
     expect(() => parse(schema2, [1])).toThrowError(contentError);
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = array(string(), [maxLength(5)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_length', requirement: 5, message: 'Invalid length' },
+    ]);
+
+    const schema2 = array(string());
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/array/array.ts

@@ -5,7 +5,9 @@ import type {
   Issues,
   Output,
   Pipe,
+  PipeMeta,
 } from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipe,
   getDefaultArgs,
@@ -23,6 +25,7 @@ export type ArraySchema<
 > = BaseSchema<Input<TArrayItem>[], TOutput> & {
   schema: 'array';
   array: { item: TArrayItem };
+  checks: PipeMeta[];
 };
 
 /**
@@ -78,6 +81,12 @@ export function array<TArrayItem extends BaseSchema>(
      */
     async: false,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe ?? []),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/array/arrayAsync.test.ts

@@ -114,4 +114,14 @@ describe('array', () => {
     await expect(parseAsync(schema2, [1, 2])).rejects.toThrowError(lengthError);
     await expect(parseAsync(schema2, [1])).rejects.toThrowError(contentError);
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = arrayAsync(string(), [maxLength(5)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_length', requirement: 5, message: 'Invalid length' },
+    ]);
+
+    const schema2 = arrayAsync(string());
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/array/arrayAsync.ts

@@ -6,9 +6,11 @@ import type {
   Issues,
   Output,
   PipeAsync,
+  PipeMeta,
 } from '../../types.ts';
 import {
   executePipeAsync,
+  getChecks,
   getDefaultArgs,
   getIssues,
   getSchemaIssues,
@@ -24,6 +26,7 @@ export type ArraySchemaAsync<
 > = BaseSchemaAsync<Input<TArrayItem>[], TOutput> & {
   schema: 'array';
   array: { item: TArrayItem };
+  checks: PipeMeta[];
 };
 
 /**
@@ -79,6 +82,12 @@ export function arrayAsync<TArrayItem extends BaseSchema | BaseSchemaAsync>(
      */
     async: true,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe ?? []),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/bigint/bigint.test.ts

@@ -35,4 +35,14 @@ describe('bigint', () => {
     expect(output2).toEqual(input2);
     expect(() => parse(schema2, 12346789n)).toThrowError(valueError);
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = bigint([maxValue(500n)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_value', requirement: 500n, message: 'Invalid value' },
+    ]);
+
+    const schema2 = bigint();
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/bigint/bigint.ts

@@ -1,4 +1,5 @@
-import type { BaseSchema, ErrorMessage, Pipe } from '../../types.ts';
+import type { BaseSchema, ErrorMessage, Pipe, PipeMeta } from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipe,
   getDefaultArgs,
@@ -10,6 +11,7 @@ import {
  */
 export type BigintSchema<TOutput = bigint> = BaseSchema<bigint, TOutput> & {
   schema: 'bigint';
+  checks: PipeMeta[];
 };
 
 /**
@@ -50,6 +52,12 @@ export function bigint(
      */
     async: false,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe ?? []),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/bigint/bigintAsync.test.ts

@@ -39,4 +39,14 @@ describe('bigintAsync', () => {
       valueError
     );
   });
+
+  test(`should expose an array of applied validation checks`, () => {
+    const schema1 = bigintAsync([maxValue(500n)]);
+    expect(schema1.checks).toStrictEqual([
+      { kind: 'max_value', requirement: 500n, message: 'Invalid value' },
+    ]);
+
+    const schema2 = bigintAsync();
+    expect(schema2.checks).toStrictEqual([]);
+  });
 });

library/src/schemas/bigint/bigintAsync.ts

@@ -1,4 +1,10 @@
-import type { BaseSchemaAsync, ErrorMessage, PipeAsync } from '../../types.ts';
+import type {
+  BaseSchemaAsync,
+  ErrorMessage,
+  PipeAsync,
+  PipeMeta,
+} from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipeAsync,
   getDefaultArgs,
@@ -13,6 +19,7 @@ export type BigintSchemaAsync<TOutput = bigint> = BaseSchemaAsync<
   TOutput
 > & {
   schema: 'bigint';
+  checks: PipeMeta[];
 };
 
 /**
@@ -56,6 +63,12 @@ export function bigintAsync(
      */
     async: true,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe ?? []),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/blob/blob.ts

@@ -1,4 +1,5 @@
-import type { BaseSchema, ErrorMessage, Pipe } from '../../types.ts';
+import type { BaseSchema, ErrorMessage, Pipe, PipeMeta } from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipe,
   getDefaultArgs,
@@ -10,6 +11,7 @@ import {
  */
 export type BlobSchema<TOutput = Blob> = BaseSchema<Blob, TOutput> & {
   schema: 'blob';
+  checks: PipeMeta[];
 };
 
 /**
@@ -50,6 +52,12 @@ export function blob(
      */
     async: false,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/blob/blobAsync.ts

@@ -1,4 +1,10 @@
-import type { BaseSchemaAsync, ErrorMessage, PipeAsync } from '../../types.ts';
+import type {
+  BaseSchemaAsync,
+  ErrorMessage,
+  PipeAsync,
+  PipeMeta,
+} from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipeAsync,
   getDefaultArgs,
@@ -10,6 +16,7 @@ import {
  */
 export type BlobSchemaAsync<TOutput = Blob> = BaseSchemaAsync<Blob, TOutput> & {
   schema: 'blob';
+  checks: PipeMeta[];
 };
 
 /**
@@ -53,6 +60,12 @@ export function blobAsync(
      */
     async: true,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe),
+
     /**
      * Parses unknown input based on its schema.
      *

library/src/schemas/boolean/boolean.ts

@@ -1,4 +1,5 @@
-import type { BaseSchema, ErrorMessage, Pipe } from '../../types.ts';
+import type { BaseSchema, ErrorMessage, Pipe, PipeMeta } from '../../types.ts';
+import { getChecks } from '../../utils/getChecks/getChecks.ts';
 import {
   executePipe,
   getDefaultArgs,
@@ -10,6 +11,7 @@ import {
  */
 export type BooleanSchema<TOutput = boolean> = BaseSchema<boolean, TOutput> & {
   schema: 'boolean';
+  checks: PipeMeta[];
 };
 
 /**
@@ -53,6 +55,12 @@ export function boolean(
      */
     async: false,
 
+    /**
+     * Validation checks that will be run against
+     * the input value.
+     */
+    checks: getChecks(pipe),
+
     /**
      * Parses unknown input based on its schema.
      *