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,19 @@ describe('any', () => {
     const output = parse(any([toCustom(transformInput)]), 123);
     expect(output).toBe(transformInput());
   });
+
+  test(`should expose a pipe of transforms and validations`, () => {
+    const schema1 = any([toCustom(String), maxLength(5)]);
+    expect(schema1.pipe).toStrictEqual([
+      expect.objectContaining({ kind: 'to_custom' }),
+      expect.objectContaining({
+        kind: 'max_length',
+        requirement: 5,
+        message: 'Invalid length',
+      }),
+    ]);
+
+    const schema2 = any();
+    expect(schema2.pipe).toStrictEqual([]);
+  });
 });

library/src/schemas/any/any.ts

@@ -5,7 +5,11 @@ import { executePipe } from '../../utils/index.ts';
  * Any schema type.
  */
 export type AnySchema<TOutput = any> = BaseSchema<any, TOutput> & {
-  schema: 'any';
+  kind: 'any';
+  /**
+   * Validation and transformation pipe.
+   */
+  pipe: Pipe<any>;
 };
 
 /**
@@ -17,24 +21,10 @@ export type AnySchema<TOutput = any> = BaseSchema<any, TOutput> & {
  */
 export function any(pipe: Pipe<any> = []): AnySchema {
   return {
-    /**
-     * The schema type.
-     */
-    schema: 'any',
-
-    /**
-     * Whether it's async.
-     */
+    kind: 'any',
     async: false,
+    pipe,
 
-    /**
-     * Parses unknown input based on its schema.
-     *
-     * @param input The input to be parsed.
-     * @param info The parse info.
-     *
-     * @returns The parsed output.
-     */
     _parse(input, info) {
       return executePipe(input, pipe, info, 'any');
     },

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,19 @@ describe('anyAsync', () => {
     const output = await parseAsync(anyAsync([toCustom(transformInput)]), 123);
     expect(output).toBe(transformInput());
   });
+
+  test(`should expose a pipe of transforms and validations`, () => {
+    const schema1 = anyAsync([toCustom(String), maxLength(5)]);
+    expect(schema1.pipe).toStrictEqual([
+      expect.objectContaining({ kind: 'to_custom' }),
+      expect.objectContaining({
+        kind: 'max_length',
+        requirement: 5,
+        message: 'Invalid length',
+      }),
+    ]);
+
+    const schema2 = anyAsync();
+    expect(schema2.pipe).toStrictEqual([]);
+  });
 });

library/src/schemas/any/anyAsync.ts

@@ -5,7 +5,11 @@ import { executePipeAsync } from '../../utils/index.ts';
  * Any schema type.
  */
 export type AnySchemaAsync<TOutput = any> = BaseSchemaAsync<any, TOutput> & {
-  schema: 'any';
+  kind: 'any';
+  /**
+   * Validation and transformation pipe.
+   */
+  pipe: PipeAsync<any>;
 };
 
 /**
@@ -17,24 +21,9 @@ export type AnySchemaAsync<TOutput = any> = BaseSchemaAsync<any, TOutput> & {
  */
 export function anyAsync(pipe: PipeAsync<any> = []): AnySchemaAsync {
   return {
-    /**
-     * The schema type.
-     */
-    schema: 'any',
-
-    /**
-     * Whether it's async.
-     */
+    kind: 'any',
     async: true,
-
-    /**
-     * Parses unknown input based on its schema.
-     *
-     * @param input The input to be parsed.
-     * @param info The parse info.
-     *
-     * @returns The parsed output.
-     */
+    pipe,
     async _parse(input, info) {
       return executePipeAsync(input, pipe, info, 'any');
     },

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

@@ -112,4 +112,18 @@ describe('array', () => {
     expect(() => parse(schema2, [1, 2])).toThrowError(lengthError);
     expect(() => parse(schema2, [1])).toThrowError(contentError);
   });
+
+  test(`should expose a pipe of transforms and validations`, () => {
+    const schema1 = array(string(), [maxLength(5)]);
+    expect(schema1.pipe).toStrictEqual([
+      expect.objectContaining({
+        kind: 'max_length',
+        requirement: 5,
+        message: 'Invalid length',
+      }),
+    ]);
+
+    const schema2 = array(string());
+    expect(schema2.pipe).toStrictEqual([]);
+  });
 });

library/src/schemas/array/array.ts

@@ -21,8 +21,16 @@ export type ArraySchema<
   TArrayItem extends BaseSchema,
   TOutput = Output<TArrayItem>[]
 > = BaseSchema<Input<TArrayItem>[], TOutput> & {
-  schema: 'array';
+  kind: 'array';
+  /**
+   * The array item schema.
+   */
   array: { item: TArrayItem };
+  /**
+   * Validation checks that will be run against
+   * the input value.
+   */
+  pipe: Pipe<Output<TArrayItem>[]>;
 };
 
 /**
@@ -59,33 +67,14 @@ export function array<TArrayItem extends BaseSchema>(
   arg3?: Pipe<Output<TArrayItem>[]>
 ): ArraySchema<TArrayItem> {
   // Get error and pipe argument
-  const [error, pipe] = getDefaultArgs(arg2, arg3);
+  const [error, pipe = []] = getDefaultArgs(arg2, arg3);
 
   // Create and return array schema
   return {
-    /**
-     * The schema type.
-     */
-    schema: 'array',
-
-    /**
-     * The array item schema.
-     */
-    array: { item },
-
-    /**
-     * Whether it's async.
-     */
+    kind: 'array',
     async: false,
-
-    /**
-     * Parses unknown input based on its schema.
-     *
-     * @param input The input to be parsed.
-     * @param info The parse info.
-     *
-     * @returns The parsed output.
-     */
+    array: { item },
+    pipe,
     _parse(input, info) {
       // Check type of input
       if (!Array.isArray(input)) {

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

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

library/src/schemas/array/arrayAsync.ts

@@ -22,8 +22,16 @@ export type ArraySchemaAsync<
   TArrayItem extends BaseSchema | BaseSchemaAsync,
   TOutput = Output<TArrayItem>[]
 > = BaseSchemaAsync<Input<TArrayItem>[], TOutput> & {
-  schema: 'array';
+  kind: 'array';
+  /**
+   * The array item schema.
+   */
   array: { item: TArrayItem };
+  /**
+   * Validation checks that will be run against
+   * the input value.
+   */
+  pipe: PipeAsync<Output<TArrayItem>[]>;
 };
 
 /**
@@ -60,33 +68,14 @@ export function arrayAsync<TArrayItem extends BaseSchema | BaseSchemaAsync>(
   arg3?: PipeAsync<Output<TArrayItem>[]>
 ): ArraySchemaAsync<TArrayItem> {
   // Get error and pipe argument
-  const [error, pipe] = getDefaultArgs(arg2, arg3);
+  const [error, pipe = []] = getDefaultArgs(arg2, arg3);
 
   // Create and return async array schema
   return {
-    /**
-     * The schema type.
-     */
-    schema: 'array',
-
-    /**
-     * The array item schema.
-     */
-    array: { item },
-
-    /**
-     * Whether it's async.
-     */
+    kind: 'array',
     async: true,
-
-    /**
-     * Parses unknown input based on its schema.
-     *
-     * @param input The input to be parsed.
-     * @param info The parse info.
-     *
-     * @returns The parsed output.
-     */
+    array: { item },
+    pipe,
     async _parse(input, info) {
       // Check type of input
       if (!Array.isArray(input)) {

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

@@ -35,4 +35,18 @@ describe('bigint', () => {
     expect(output2).toEqual(input2);
     expect(() => parse(schema2, 12346789n)).toThrowError(valueError);
   });
+
+  test(`should expose a pipe of transforms and validations`, () => {
+    const schema1 = bigint([maxValue(500n)]);
+    expect(schema1.pipe).toStrictEqual([
+      expect.objectContaining({
+        kind: 'max_value',
+        requirement: 500n,
+        message: 'Invalid value',
+      }),
+    ]);
+
+    const schema2 = bigint();
+    expect(schema2.pipe).toStrictEqual([]);
+  });
 });

library/src/schemas/bigint/bigint.ts

@@ -9,7 +9,11 @@ import {
  * Bigint schema type.
  */
 export type BigintSchema<TOutput = bigint> = BaseSchema<bigint, TOutput> & {
-  schema: 'bigint';
+  kind: 'bigint';
+  /**
+   * Validation and transformation pipe.
+   */
+  pipe: Pipe<bigint>;
 };
 
 /**
@@ -36,28 +40,13 @@ export function bigint(
   arg2?: Pipe<bigint>
 ): BigintSchema {
   // Get error and pipe argument
-  const [error, pipe] = getDefaultArgs(arg1, arg2);
+  const [error, pipe = []] = getDefaultArgs(arg1, arg2);
 
   // Create and return bigint schema
   return {
-    /**
-     * The schema type.
-     */
-    schema: 'bigint',
-
-    /**
-     * Whether it's async.
-     */
+    kind: 'bigint',
     async: false,
-
-    /**
-     * Parses unknown input based on its schema.
-     *
-     * @param input The input to be parsed.
-     * @param info The parse info.
-     *
-     * @returns The parsed output.
-     */
+    pipe,
     _parse(input, info) {
       // Check type of input
       if (typeof input !== 'bigint') {

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

@@ -39,4 +39,18 @@ describe('bigintAsync', () => {
       valueError
     );
   });
+
+  test(`should expose a pipe of transforms and validations`, () => {
+    const schema1 = bigintAsync([maxValue(500n)]);
+    expect(schema1.pipe).toStrictEqual([
+      expect.objectContaining({
+        kind: 'max_value',
+        requirement: 500n,
+        message: 'Invalid value',
+      }),
+    ]);
+
+    const schema2 = bigintAsync();
+    expect(schema2.pipe).toStrictEqual([]);
+  });
 });