feat: implement Standard Schema

package.json

@@ -43,6 +43,7 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "@samchon/openapi": "^2.4.2",
+    "@standard-schema/spec": "^1.0.0",
     "commander": "^10.0.0",
     "comment-json": "^4.2.3",
     "inquirer": "^8.2.5",

src/internal/_createStandardSchema.ts

@@ -0,0 +1,134 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+import { IValidation } from "../IValidation";
+
+export const _createStandardSchema = <T>(
+  fn: (input: unknown) => IValidation<T>,
+) =>
+  Object.assign(fn, {
+    "~standard": {
+      version: 1,
+      vendor: "typia",
+      validate: (input: unknown): StandardSchemaV1.Result<T> => {
+        const result = fn(input);
+        if (result.success) {
+          return {
+            value: result.data,
+          } satisfies StandardSchemaV1.SuccessResult<T>;
+        } else {
+          return {
+            issues: result.errors.map((error) => ({
+              message: `expected ${error.expected}, got ${error.value}`,
+              path: typiaPathToStandardSchemaPath(error.path),
+            })),
+          } satisfies StandardSchemaV1.FailureResult;
+        }
+      },
+    },
+  } satisfies StandardSchemaV1<unknown, T>);
+
+enum PathParserState {
+  // Start of a new segment
+  // When the parser is in this state,
+  // the pointer must point `.` or `[` or equal to length of the path
+  Start,
+  // Parsing a property key (`.hoge`)
+  Property,
+  // Parsing a string key (`["fuga"]`)
+  StringKey,
+  // Parsing a number key (`[42]`)
+  NumberKey,
+}
+
+const typiaPathToStandardSchemaPath = (
+  path: string,
+): ReadonlyArray<StandardSchemaV1.PathSegment> => {
+  if (!path.startsWith("$input")) {
+    throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+  }
+
+  const segments: StandardSchemaV1.PathSegment[] = [];
+  let currentSegment = "";
+  let state: PathParserState = PathParserState.Start;
+  let index = "$input".length - 1;
+  while (index < path.length - 1) {
+    index++;
+    const char = path[index];
+
+    if (state === PathParserState.Property) {
+      if (char === "." || char === "[") {
+        // End of property
+        segments.push({
+          key: currentSegment,
+        });
+        state = PathParserState.Start;
+      } else if (index === path.length - 1) {
+        // End of path
+        currentSegment += char;
+        segments.push({
+          key: currentSegment,
+        });
+        index++;
+        state = PathParserState.Start;
+      } else {
+        currentSegment += char;
+      }
+    } else if (state === PathParserState.StringKey) {
+      if (char === '"') {
+        // End of string key
+        segments.push({
+          key: JSON.parse(currentSegment + char),
+        });
+        // Skip `"` and `]`
+        index += 2;
+        state = PathParserState.Start;
+      } else if (char === "\\") {
+        // Skip the next character from parsing
+        currentSegment += path[index];
+        index++;
+        currentSegment += path[index];
+      } else {
+        currentSegment += char;
+      }
+    } else if (state === PathParserState.NumberKey) {
+      if (char === "]") {
+        // End of number key
+        segments.push({
+          key: Number.parseInt(currentSegment),
+        });
+        index++;
+        state = PathParserState.Start;
+      } else {
+        currentSegment += char;
+      }
+    }
+
+    if (state === PathParserState.Start && index < path.length - 1) {
+      const newChar = path[index];
+      currentSegment = "";
+      if (newChar === "[") {
+        if (path[index + 1] === '"') {
+          // Start of string key
+          // NOTE: Typia uses JSON.stringify for this kind of keys, so `'` will not used as a string delimiter
+          state = PathParserState.StringKey;
+          index++;
+          currentSegment = '"';
+        } else {
+          // Start of number key
+          state = PathParserState.NumberKey;
+        }
+      } else if (newChar === ".") {
+        // Start of property
+        state = PathParserState.Property;
+      } else {
+        throw new Error("Unreachable: pointer points invalid character");
+      }
+    }
+  }
+
+  if (state !== PathParserState.Start) {
+    throw new Error(`Failed to parse path: ${JSON.stringify(path)}`);
+  }
+
+  return segments;
+};

src/module.ts

@@ -1,3 +1,5 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
 import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
@@ -730,12 +732,14 @@ export function createValidate(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidate<T>(): (input: unknown) => IValidation<T>;
+export function createValidate<T>(): ((input: unknown) => IValidation<T>) &
+  StandardSchemaV1<unknown, T>;
 
 /**
  * @internal
  */
-export function createValidate(): (input: unknown) => IValidation {
+export function createValidate(): ((input: unknown) => IValidation) &
+  StandardSchemaV1<unknown, unknown> {
   halt("createValidate");
 }
 
@@ -886,12 +890,16 @@ export function createValidateEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
+export function createValidateEquals<T>(): ((
+  input: unknown,
+) => IValidation<T>) &
+  StandardSchemaV1<unknown, T>;
 
 /**
  * @internal
  */
-export function createValidateEquals(): (input: unknown) => IValidation {
+export function createValidateEquals(): ((input: unknown) => IValidation) &
+  StandardSchemaV1<unknown, unknown> {
   halt("createValidateEquals");
 }
 

src/programmers/FeatureProgrammer.ts

@@ -297,6 +297,7 @@ export namespace FeatureProgrammer {
     modulo: ts.LeftHandSideExpression;
     functor: FunctionProgrammer;
     result: IDecomposed;
+    returnWrapper?: (arrow: ts.ArrowFunction) => ts.Expression;
   }): ts.CallExpression =>
     ts.factory.createCallExpression(
       ts.factory.createArrowFunction(
@@ -311,7 +312,11 @@ export namespace FeatureProgrammer {
             .filter(([k]) => props.functor.hasLocal(k))
             .map(([_k, v]) => v),
           ...props.result.statements,
-          ts.factory.createReturnStatement(props.result.arrow),
+          ts.factory.createReturnStatement(
+            props.returnWrapper
+              ? props.returnWrapper(props.result.arrow)
+              : props.result.arrow,
+          ),
         ]),
       ),
       undefined,

src/programmers/ValidateProgrammer.ts

@@ -20,6 +20,7 @@ import { check_object } from "./internal/check_object";
 export namespace ValidateProgrammer {
   export interface IConfig {
     equals: boolean;
+    standardSchema?: boolean;
   }
   export interface IProps extends IProgrammerProps {
     config: IConfig;
@@ -241,6 +242,14 @@ export namespace ValidateProgrammer {
       modulo: props.modulo,
       functor,
       result,
+      returnWrapper: props.config.standardSchema
+        ? (arrow) =>
+            ts.factory.createCallExpression(
+              props.context.importer.internal("createStandardSchema"),
+              undefined,
+              [arrow],
+            )
+        : undefined,
     });
   };
 }

src/transformers/CallExpressionTransformer.ts

@@ -195,14 +195,20 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
       CreateAssertTransformer.transform({ equals: false, guard: false }),
     createIs: () => CreateIsTransformer.transform({ equals: false }),
     createValidate: () =>
-      CreateValidateTransformer.transform({ equals: false }),
+      CreateValidateTransformer.transform({
+        equals: false,
+        standardSchema: true,
+      }),
     createAssertEquals: () =>
       CreateAssertTransformer.transform({ equals: true, guard: false }),
     createAssertGuardEquals: () =>
       CreateAssertTransformer.transform({ equals: true, guard: true }),
     createEquals: () => CreateIsTransformer.transform({ equals: true }),
     createValidateEquals: () =>
-      CreateValidateTransformer.transform({ equals: true }),
+      CreateValidateTransformer.transform({
+        equals: true,
+        standardSchema: true,
+      }),
     createRandom: () => CreateRandomTransformer.transform,
   },
   functional: {

test/build/internal/TestFeature.ts

@@ -7,8 +7,10 @@ import { write_random } from "../writers/write_random";
 
 export interface TestFeature {
   module: string | null;
+  prefix?: string;
   method: string;
   creatable: boolean;
+  createOnly?: boolean;
   spoilable: boolean;
   formData?: boolean;
   custom?: true;
@@ -53,6 +55,14 @@ export namespace TestFeature {
       creatable: true,
       spoilable: true,
     },
+    {
+      module: null,
+      prefix: "standardSchema",
+      method: "validate",
+      creatable: false,
+      createOnly: true,
+      spoilable: true,
+    },
 
     // STRICT VALIDATORS
     {

test/build/template.ts

@@ -49,8 +49,10 @@ async function generate(
     "src",
     "features",
     [
-      feat.module ? `${feat.module}.${method}` : method,
-      ...(feat.custom === true ? ["Custom"] : ""),
+      feat.prefix ? `${feat.prefix}.` : "",
+      feat.module ? `${feat.module}.` : "",
+      method,
+      feat.custom === true ? "Custom" : "",
     ].join(""),
   ].join("/");
 
@@ -73,6 +75,8 @@ async function generate(
     else if (feat.dynamic === false && s.name.startsWith("Dynamic")) continue;
 
     const location: string = `${path}/test_${
+      feat.prefix ? `${feat.prefix}_` : ""
+    }${
       feat.module ? `${feat.module}_` : ""
     }${method}${feat.custom === true ? "Custom" : ""}_${s.name}.ts`;
     await fs.promises.writeFile(
@@ -93,6 +97,7 @@ function script(
     ? feat.programmer(create)(struct.name)
     : write_common({
         module: feat.module,
+        prefix: feat.prefix,
         method,
       })(create)(struct.name);
   if (false === method.toLowerCase().includes("assert")) return content;
@@ -155,8 +160,12 @@ async function main(): Promise<void> {
     })),
   ];
   for (const feature of featureList) {
-    await generate(feature, structures, false);
-    if (feature.creatable) await generate(feature, structures, true);
+    if (feature.createOnly) {
+      await generate(feature, structures, true);
+    } else {
+      await generate(feature, structures, false);
+      if (feature.creatable) await generate(feature, structures, true);
+    }
   }
 
   // SCHEMAS

test/build/writers/write_common.ts

@@ -29,7 +29,8 @@ export const ${file(p)}_${structure} = _${file({
 )(${functor(p)(create)(structure)});
 `;
 
-const file = (p: IProps) => "test_" + method(p).replace(".", "_");
+const file = (p: IProps) =>
+  "test_" + (p.prefix ? `${p.prefix}_` : "") + method(p).replace(".", "_");
 const method = (p: IProps) =>
   [p.module, p.method].filter((str) => !!str).join(".");
 const functor = (p: IProps) => (create: boolean) => (structure: string) =>
@@ -39,5 +40,6 @@ const functor = (p: IProps) => (create: boolean) => (structure: string) =>
 
 interface IProps {
   module: string | null;
+  prefix?: string;
   method: string;
 }

test/src/features/standardSchema.createValidate/test_standardSchema_createValidate_ArrayAny.ts

@@ -0,0 +1,10 @@
+import typia from "typia";
+
+import { _test_standardSchema_validate } from "../../internal/_test_standardSchema_validate";
+import { ArrayAny } from "../../structures/ArrayAny";
+
+export const test_standardSchema_createValidate_ArrayAny = _test_standardSchema_validate(
+    "ArrayAny",
+)<ArrayAny>(
+    ArrayAny
+)(typia.createValidate<ArrayAny>());

test/src/features/standardSchema.createValidate/test_standardSchema_createValidate_ArrayAtomicAlias.ts

@@ -0,0 +1,10 @@
+import typia from "typia";
+
+import { _test_standardSchema_validate } from "../../internal/_test_standardSchema_validate";
+import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias";
+
+export const test_standardSchema_createValidate_ArrayAtomicAlias = _test_standardSchema_validate(
+    "ArrayAtomicAlias",
+)<ArrayAtomicAlias>(
+    ArrayAtomicAlias
+)(typia.createValidate<ArrayAtomicAlias>());

test/src/features/standardSchema.createValidate/test_standardSchema_createValidate_ArrayAtomicSimple.ts

@@ -0,0 +1,10 @@
+import typia from "typia";
+
+import { _test_standardSchema_validate } from "../../internal/_test_standardSchema_validate";
+import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple";
+
+export const test_standardSchema_createValidate_ArrayAtomicSimple = _test_standardSchema_validate(
+    "ArrayAtomicSimple",
+)<ArrayAtomicSimple>(
+    ArrayAtomicSimple
+)(typia.createValidate<ArrayAtomicSimple>());

test/src/features/standardSchema.createValidate/test_standardSchema_createValidate_ArrayHierarchical.ts

@@ -0,0 +1,10 @@
+import typia from "typia";
+
+import { _test_standardSchema_validate } from "../../internal/_test_standardSchema_validate";
+import { ArrayHierarchical } from "../../structures/ArrayHierarchical";
+
+export const test_standardSchema_createValidate_ArrayHierarchical = _test_standardSchema_validate(
+    "ArrayHierarchical",
+)<ArrayHierarchical>(
+    ArrayHierarchical
+)(typia.createValidate<ArrayHierarchical>());

test/src/features/standardSchema.createValidate/test_standardSchema_createValidate_ArrayHierarchicalPointer.ts

@@ -0,0 +1,10 @@
+import typia from "typia";
+
+import { _test_standardSchema_validate } from "../../internal/_test_standardSchema_validate";
+import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer";
+
+export const test_standardSchema_createValidate_ArrayHierarchicalPointer = _test_standardSchema_validate(
+    "ArrayHierarchicalPointer",
+)<ArrayHierarchicalPointer>(
+    ArrayHierarchicalPointer
+)(typia.createValidate<ArrayHierarchicalPointer>());