typia 9.7.1 → 10.0.0-dev.20251107

package/src/factories/MetadataFactory.ts

@@ -1,404 +1,402 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataAliasType } from "../schemas/metadata/MetadataAliasType";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
-import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
-import { MetadataFunction } from "../schemas/metadata/MetadataFunction";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
-import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
-import { explore_metadata } from "./internal/metadata/explore_metadata";
-import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
-import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
-
-import { ValidationPipe } from "../typings/ValidationPipe";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-import { MetadataCollection } from "./MetadataCollection";
-
-export namespace MetadataFactory {
-  export type Validator = (meta: Metadata, explore: IExplore) => string[];
-
-  export interface IProps {
-    checker: ts.TypeChecker;
-    transformer: ts.TransformationContext | undefined;
-    options: IOptions;
-    collection: MetadataCollection;
-    type: ts.Type | null;
-  }
-  export interface IOptions {
-    escape: boolean;
-    constant: boolean;
-    absorb: boolean;
-    functional?: boolean;
-    validate?: Validator;
-    onError?: (node: ts.Node | undefined, message: string) => void;
-  }
-  export interface IExplore {
-    top: boolean;
-    object: MetadataObjectType | null;
-    property: string | object | null;
-    nested: null | MetadataAliasType | MetadataArrayType | MetadataTupleType;
-    parameter: string | null;
-    output: boolean;
-    escaped: boolean;
-    aliased: boolean;
-  }
-
-  export interface IError {
-    name: string;
-    explore: IExplore;
-    messages: string[];
-  }
-
-  export const analyze = (props: IProps): ValidationPipe<Metadata, IError> => {
-    const errors: IError[] = [];
-    const metadata: Metadata = explore_metadata({
-      ...props,
-      errors,
-      explore: {
-        top: true,
-        object: null,
-        property: null,
-        parameter: null,
-        nested: null,
-        aliased: false,
-        escaped: false,
-        output: false,
-      },
-      intersected: false,
-    });
-    iterate_metadata_collection({
-      errors,
-      collection: props.collection,
-    });
-    iterate_metadata_sort({
-      collection: props.collection,
-      metadata: metadata,
-    });
-
-    if (props.options.validate)
-      errors.push(
-        ...validate({
-          transformer: props.transformer,
-          options: props.options,
-          functor: props.options.validate,
-          metadata,
-        }),
-      );
-    return errors.length
-      ? {
-          success: false,
-          errors,
-        }
-      : {
-          success: true,
-          data: metadata,
-        };
-  };
-
-  /**
-   * @internal
-   */
-  export const soleLiteral = (value: string): Metadata => {
-    const meta: Metadata = Metadata.initialize();
-    meta.constants.push(
-      MetadataConstant.from({
-        values: [
-          {
-            value,
-            tags: [],
-          },
-        ],
-        type: "string",
-      }),
-    );
-    return meta;
-  };
-
-  export const validate = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    functor: Validator;
-    metadata: Metadata;
-  }): IError[] => {
-    const visitor: IValidationVisitor = {
-      functor: props.functor,
-      errors: [],
-      objects: new Set(),
-      arrays: new Set(),
-      tuples: new Set(),
-      aliases: new Set(),
-      functions: new Set(),
-    };
-    validateMeta({
-      ...props,
-      visitor,
-      explore: {
-        object: null,
-        property: null,
-        parameter: null,
-        nested: null,
-        top: true,
-        aliased: false,
-        escaped: false,
-        output: false,
-      },
-    });
-    return visitor.errors;
-  };
-
-  const validateMeta = (props: {
-    options: IOptions;
-    visitor: IValidationVisitor;
-    metadata: Metadata;
-    explore: IExplore;
-  }) => {
-    const result: string[] = [];
-    for (const atomic of props.metadata.atomics)
-      for (const row of atomic.tags)
-        for (const tag of row.filter(
-          (t) => t.validate !== undefined && t.predicate === undefined,
-        ))
-          try {
-            tag.predicate = ExpressionFactory.transpile({
-              script: tag.validate!,
-            });
-          } catch {
-            result.push(
-              `Unable to transpile type tag script: ${JSON.stringify(
-                tag.validate,
-              )}`,
-            );
-            tag.predicate = () => ts.factory.createTrue();
-          }
-    result.push(...props.visitor.functor(props.metadata, props.explore));
-    if (result.length)
-      props.visitor.errors.push({
-        name: props.metadata.getName(),
-        explore: { ...props.explore },
-        messages: [...new Set(result)],
-      });
-
-    for (const alias of props.metadata.aliases)
-      validateAlias({
-        ...props,
-        alias: alias.type,
-      });
-    for (const array of props.metadata.arrays)
-      validateArray({
-        ...props,
-        array: array.type,
-      });
-    for (const tuple of props.metadata.tuples)
-      validateTuple({
-        ...props,
-        tuple: tuple.type,
-      });
-    for (const object of props.metadata.objects)
-      validateObject({
-        ...props,
-        object: object.type,
-      });
-    for (const func of props.metadata.functions)
-      validateFunction({
-        ...props,
-        function: func,
-      });
-    for (const set of props.metadata.sets)
-      validateMeta({
-        ...props,
-        metadata: set.value,
-      });
-    for (const map of props.metadata.maps) {
-      validateMeta({
-        ...props,
-        metadata: map.key,
-      });
-      validateMeta({
-        ...props,
-        metadata: map.value,
-      });
-    }
-
-    if (props.options.escape === true && props.metadata.escaped !== null)
-      validateMeta({
-        ...props,
-        metadata: props.metadata.escaped.returns,
-        explore: {
-          ...props.explore,
-          escaped: true,
-        },
-      });
-  };
-
-  const validateAlias = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    visitor: IValidationVisitor;
-    alias: MetadataAliasType;
-    explore: IExplore;
-  }) => {
-    if (props.visitor.aliases.has(props.alias)) return;
-    props.visitor.aliases.add(props.alias);
-
-    validateMeta({
-      ...props,
-      metadata: props.alias.value,
-      explore: {
-        ...props.explore,
-        nested: props.alias,
-        aliased: true,
-      },
-    });
-  };
-
-  const validateArray = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    visitor: IValidationVisitor;
-    array: MetadataArrayType;
-    explore: IExplore;
-  }) => {
-    if (props.visitor.arrays.has(props.array)) return;
-    props.visitor.arrays.add(props.array);
-
-    validateMeta({
-      ...props,
-      metadata: props.array.value,
-      explore: {
-        ...props.explore,
-        nested: props.array,
-        top: false,
-      },
-    });
-  };
-
-  const validateTuple = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    visitor: IValidationVisitor;
-    tuple: MetadataTupleType;
-    explore: IExplore;
-  }) => {
-    if (props.visitor.tuples.has(props.tuple)) return;
-    props.visitor.tuples.add(props.tuple);
-
-    for (const elem of props.tuple.elements)
-      validateMeta({
-        ...props,
-        metadata: elem,
-        explore: {
-          ...props.explore,
-          nested: props.tuple,
-          top: false,
-        },
-      });
-  };
-
-  const validateObject = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    visitor: IValidationVisitor;
-    object: MetadataObjectType;
-  }) => {
-    if (props.visitor.objects.has(props.object)) return;
-    props.visitor.objects.add(props.object);
-
-    if (props.options.validate) {
-      const explore: IExplore = {
-        object: props.object,
-        top: false,
-        property: null,
-        parameter: null,
-        nested: null,
-        aliased: false,
-        escaped: false,
-        output: false,
-      };
-      const errors: string[] = props.options.validate(
-        Metadata.create({
-          ...Metadata.initialize(),
-          objects: [
-            MetadataObject.create({
-              type: props.object,
-              tags: [],
-            }),
-          ],
-        }),
-        explore,
-      );
-      if (errors.length)
-        props.visitor.errors.push({
-          name: props.object.name,
-          explore,
-          messages: [...new Set(errors)],
-        });
-    }
-
-    for (const property of props.object.properties)
-      validateMeta({
-        ...props,
-        metadata: property.value,
-        explore: {
-          object: props.object,
-          property: property.key.isSoleLiteral()
-            ? property.key.getSoleLiteral()!
-            : {},
-          parameter: null,
-          nested: null,
-          top: false,
-          aliased: false,
-          escaped: false,
-          output: false,
-        },
-      });
-  };
-
-  const validateFunction = (props: {
-    transformer?: ts.TransformationContext;
-    options: IOptions;
-    visitor: IValidationVisitor;
-    function: MetadataFunction;
-    explore: IExplore;
-  }) => {
-    if (props.visitor.functions.has(props.function)) return;
-    props.visitor.functions.add(props.function);
-
-    for (const param of props.function.parameters)
-      validateMeta({
-        ...props,
-        metadata: param.type,
-        explore: {
-          ...props.explore,
-          parameter: param.name,
-          nested: null,
-          top: false,
-          output: false,
-        },
-      });
-    if (props.function.output)
-      validateMeta({
-        ...props,
-        metadata: props.function.output,
-        explore: {
-          ...props.explore,
-          parameter: null,
-          nested: null,
-          top: false,
-          output: true,
-        },
-      });
-  };
-
-  interface IValidationVisitor {
-    functor: Validator;
-    errors: IError[];
-    objects: Set<MetadataObjectType>;
-    arrays: Set<MetadataArrayType>;
-    tuples: Set<MetadataTupleType>;
-    aliases: Set<MetadataAliasType>;
-    functions: Set<MetadataFunction>;
-  }
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAliasType } from "../schemas/metadata/MetadataAliasType";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
+import { MetadataFunction } from "../schemas/metadata/MetadataFunction";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+import { explore_metadata } from "./internal/metadata/explore_metadata";
+import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
+import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
+
+import { ValidationPipe } from "../typings/ValidationPipe";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { MetadataCollection } from "./MetadataCollection";
+
+export namespace MetadataFactory {
+  export type Validator = (meta: Metadata, explore: IExplore) => string[];
+
+  export interface IProps {
+    checker: ts.TypeChecker;
+    transformer: ts.TransformationContext | undefined;
+    options: IOptions;
+    collection: MetadataCollection;
+    type: ts.Type | null;
+  }
+  export interface IOptions {
+    escape: boolean;
+    constant: boolean;
+    absorb: boolean;
+    functional?: boolean;
+    validate?: Validator;
+    onError?: (node: ts.Node | undefined, message: string) => void;
+  }
+  export interface IExplore {
+    top: boolean;
+    object: MetadataObjectType | null;
+    property: string | object | null;
+    nested: null | MetadataAliasType | MetadataArrayType | MetadataTupleType;
+    parameter: string | null;
+    output: boolean;
+    escaped: boolean;
+    aliased: boolean;
+  }
+
+  export interface IError {
+    name: string;
+    explore: IExplore;
+    messages: string[];
+  }
+
+  export const analyze = (props: IProps): ValidationPipe<Metadata, IError> => {
+    const errors: IError[] = [];
+    const metadata: Metadata = explore_metadata({
+      ...props,
+      errors,
+      explore: {
+        top: true,
+        object: null,
+        property: null,
+        parameter: null,
+        nested: null,
+        aliased: false,
+        escaped: false,
+        output: false,
+      },
+      intersected: false,
+    });
+    iterate_metadata_collection({
+      errors,
+      collection: props.collection,
+    });
+    iterate_metadata_sort({
+      collection: props.collection,
+      metadata: metadata,
+    });
+
+    if (props.options.validate)
+      errors.push(
+        ...validate({
+          transformer: props.transformer,
+          options: props.options,
+          functor: props.options.validate,
+          metadata,
+        }),
+      );
+    return errors.length
+      ? {
+          success: false,
+          errors,
+        }
+      : {
+          success: true,
+          data: metadata,
+        };
+  };
+
+  /** @internal */
+  export const soleLiteral = (value: string): Metadata => {
+    const meta: Metadata = Metadata.initialize();
+    meta.constants.push(
+      MetadataConstant.from({
+        values: [
+          {
+            value,
+            tags: [],
+          },
+        ],
+        type: "string",
+      }),
+    );
+    return meta;
+  };
+
+  export const validate = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    functor: Validator;
+    metadata: Metadata;
+  }): IError[] => {
+    const visitor: IValidationVisitor = {
+      functor: props.functor,
+      errors: [],
+      objects: new Set(),
+      arrays: new Set(),
+      tuples: new Set(),
+      aliases: new Set(),
+      functions: new Set(),
+    };
+    validateMeta({
+      ...props,
+      visitor,
+      explore: {
+        object: null,
+        property: null,
+        parameter: null,
+        nested: null,
+        top: true,
+        aliased: false,
+        escaped: false,
+        output: false,
+      },
+    });
+    return visitor.errors;
+  };
+
+  const validateMeta = (props: {
+    options: IOptions;
+    visitor: IValidationVisitor;
+    metadata: Metadata;
+    explore: IExplore;
+  }) => {
+    const result: string[] = [];
+    for (const atomic of props.metadata.atomics)
+      for (const row of atomic.tags)
+        for (const tag of row.filter(
+          (t) => t.validate !== undefined && t.predicate === undefined,
+        ))
+          try {
+            tag.predicate = ExpressionFactory.transpile({
+              script: tag.validate!,
+            });
+          } catch {
+            result.push(
+              `Unable to transpile type tag script: ${JSON.stringify(
+                tag.validate,
+              )}`,
+            );
+            tag.predicate = () => ts.factory.createTrue();
+          }
+    result.push(...props.visitor.functor(props.metadata, props.explore));
+    if (result.length)
+      props.visitor.errors.push({
+        name: props.metadata.getName(),
+        explore: { ...props.explore },
+        messages: [...new Set(result)],
+      });
+
+    for (const alias of props.metadata.aliases)
+      validateAlias({
+        ...props,
+        alias: alias.type,
+      });
+    for (const array of props.metadata.arrays)
+      validateArray({
+        ...props,
+        array: array.type,
+      });
+    for (const tuple of props.metadata.tuples)
+      validateTuple({
+        ...props,
+        tuple: tuple.type,
+      });
+    for (const object of props.metadata.objects)
+      validateObject({
+        ...props,
+        object: object.type,
+      });
+    for (const func of props.metadata.functions)
+      validateFunction({
+        ...props,
+        function: func,
+      });
+    for (const set of props.metadata.sets)
+      validateMeta({
+        ...props,
+        metadata: set.value,
+      });
+    for (const map of props.metadata.maps) {
+      validateMeta({
+        ...props,
+        metadata: map.key,
+      });
+      validateMeta({
+        ...props,
+        metadata: map.value,
+      });
+    }
+
+    if (props.options.escape === true && props.metadata.escaped !== null)
+      validateMeta({
+        ...props,
+        metadata: props.metadata.escaped.returns,
+        explore: {
+          ...props.explore,
+          escaped: true,
+        },
+      });
+  };
+
+  const validateAlias = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    alias: MetadataAliasType;
+    explore: IExplore;
+  }) => {
+    if (props.visitor.aliases.has(props.alias)) return;
+    props.visitor.aliases.add(props.alias);
+
+    validateMeta({
+      ...props,
+      metadata: props.alias.value,
+      explore: {
+        ...props.explore,
+        nested: props.alias,
+        aliased: true,
+      },
+    });
+  };
+
+  const validateArray = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    array: MetadataArrayType;
+    explore: IExplore;
+  }) => {
+    if (props.visitor.arrays.has(props.array)) return;
+    props.visitor.arrays.add(props.array);
+
+    validateMeta({
+      ...props,
+      metadata: props.array.value,
+      explore: {
+        ...props.explore,
+        nested: props.array,
+        top: false,
+      },
+    });
+  };
+
+  const validateTuple = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    tuple: MetadataTupleType;
+    explore: IExplore;
+  }) => {
+    if (props.visitor.tuples.has(props.tuple)) return;
+    props.visitor.tuples.add(props.tuple);
+
+    for (const elem of props.tuple.elements)
+      validateMeta({
+        ...props,
+        metadata: elem,
+        explore: {
+          ...props.explore,
+          nested: props.tuple,
+          top: false,
+        },
+      });
+  };
+
+  const validateObject = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    object: MetadataObjectType;
+  }) => {
+    if (props.visitor.objects.has(props.object)) return;
+    props.visitor.objects.add(props.object);
+
+    if (props.options.validate) {
+      const explore: IExplore = {
+        object: props.object,
+        top: false,
+        property: null,
+        parameter: null,
+        nested: null,
+        aliased: false,
+        escaped: false,
+        output: false,
+      };
+      const errors: string[] = props.options.validate(
+        Metadata.create({
+          ...Metadata.initialize(),
+          objects: [
+            MetadataObject.create({
+              type: props.object,
+              tags: [],
+            }),
+          ],
+        }),
+        explore,
+      );
+      if (errors.length)
+        props.visitor.errors.push({
+          name: props.object.name,
+          explore,
+          messages: [...new Set(errors)],
+        });
+    }
+
+    for (const property of props.object.properties)
+      validateMeta({
+        ...props,
+        metadata: property.value,
+        explore: {
+          object: props.object,
+          property: property.key.isSoleLiteral()
+            ? property.key.getSoleLiteral()!
+            : {},
+          parameter: null,
+          nested: null,
+          top: false,
+          aliased: false,
+          escaped: false,
+          output: false,
+        },
+      });
+  };
+
+  const validateFunction = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    function: MetadataFunction;
+    explore: IExplore;
+  }) => {
+    if (props.visitor.functions.has(props.function)) return;
+    props.visitor.functions.add(props.function);
+
+    for (const param of props.function.parameters)
+      validateMeta({
+        ...props,
+        metadata: param.type,
+        explore: {
+          ...props.explore,
+          parameter: param.name,
+          nested: null,
+          top: false,
+          output: false,
+        },
+      });
+    if (props.function.output)
+      validateMeta({
+        ...props,
+        metadata: props.function.output,
+        explore: {
+          ...props.explore,
+          parameter: null,
+          nested: null,
+          top: false,
+          output: true,
+        },
+      });
+  };
+
+  interface IValidationVisitor {
+    functor: Validator;
+    errors: IError[];
+    objects: Set<MetadataObjectType>;
+    arrays: Set<MetadataArrayType>;
+    tuples: Set<MetadataTupleType>;
+    aliases: Set<MetadataAliasType>;
+    functions: Set<MetadataFunction>;
+  }
+}