typia 7.0.0-dev.20240916 → 7.0.0-dev.20240918

package/src/factories/JsonMetadataFactory.ts

@@ -10,24 +10,31 @@ import { MetadataCollection } from "./MetadataCollection";
 import { MetadataFactory } from "./MetadataFactory";
 
 export namespace JsonMetadataFactory {
-  export const analyze =
-    (method: string) =>
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (type: ts.Type): [MetadataCollection, Metadata] => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        checker,
-        context,
-      )({
+  export interface IProps {
+    method: string;
+    checker: ts.TypeChecker;
+    transformer?: ts.TransformationContext;
+    type: ts.Type;
+  }
+
+  export const analyze = (props: IProps): [MetadataCollection, Metadata] => {
+    const collection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.checker,
+      transformer: props.transformer,
+      options: {
         escape: true,
         constant: true,
         absorb: true,
         validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(method)(result.errors);
-      return [collection, result.data];
-    };
+      },
+      collection,
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from(props.method)(result.errors);
+    return [collection, result.data];
+  };
 
   export const validate = (meta: Metadata) => {
     const output: string[] = [];

package/src/factories/MetadataFactory.ts

@@ -19,6 +19,13 @@ 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;
@@ -27,7 +34,6 @@ export namespace MetadataFactory {
     validate?: Validator;
     onError?: (node: ts.Node | undefined, message: string) => void;
   }
-
   export interface IExplore {
     top: boolean;
     object: MetadataObject | null;
@@ -45,15 +51,12 @@ export namespace MetadataFactory {
     messages: string[];
   }
 
-  export const analyze =
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
-      const errors: IError[] = [];
-      const meta: Metadata = explore_metadata(checker)(options)(collection)(
-        errors,
-      )(type, {
+  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,
@@ -62,22 +65,36 @@ export namespace MetadataFactory {
         aliased: false,
         escaped: false,
         output: false,
-      });
-      iterate_metadata_collection(errors)(collection);
-      iterate_metadata_sort(collection)(meta);
+      },
+    });
+    iterate_metadata_collection({
+      errors,
+      collection: props.collection,
+    });
+    iterate_metadata_sort({
+      collection: props.collection,
+      metadata: metadata,
+    });
 
-      if (options.validate)
-        errors.push(...validate(context)(options)(options.validate)(meta));
-      return errors.length
-        ? {
-            success: false,
-            errors,
-          }
-        : {
-            success: true,
-            data: meta,
-          };
-    };
+    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
@@ -98,21 +115,25 @@ export namespace MetadataFactory {
     return meta;
   };
 
-  export const validate =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (functor: Validator) =>
-    (meta: Metadata): IError[] => {
-      const visitor: IValidationVisitor = {
-        functor,
-        errors: [],
-        objects: new Set(),
-        arrays: new Set(),
-        tuples: new Set(),
-        aliases: new Set(),
-        functions: new Set(),
-      };
-      validateMeta(context)(options)(visitor)(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,
@@ -121,149 +142,202 @@ export namespace MetadataFactory {
         aliased: false,
         escaped: false,
         output: false,
-      });
-      return visitor.errors;
-    };
+      },
+    });
+    return visitor.errors;
+  };
 
-  const validateMeta =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (meta: Metadata, explore: IExplore) => {
-      const result: string[] = [];
-      if (context !== undefined)
-        for (const atomic of meta.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(context)(
-                  tag.validate!,
-                );
-              } catch {
-                result.push(
-                  `Unable to transpile type tag script: ${JSON.stringify(
-                    tag.validate,
-                  )}`,
-                );
-                tag.predicate = () => ts.factory.createTrue();
-              }
-      result.push(...visitor.functor(meta, explore));
-      if (result.length)
-        visitor.errors.push({
-          name: meta.getName(),
-          explore: { ...explore },
-          messages: [...new Set(result)],
-        });
+  const validateMeta = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    metadata: Metadata;
+    explore: IExplore;
+  }) => {
+    const result: string[] = [];
+    if (props.transformer !== undefined)
+      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(props.transformer)(
+                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 meta.aliases)
-        validateAlias(context)(options)(visitor)(alias, explore);
-      for (const array of meta.arrays)
-        validateArray(context)(options)(visitor)(array.type, explore);
-      for (const tuple of meta.tuples)
-        validateTuple(context)(options)(visitor)(tuple.type, explore);
-      for (const obj of meta.objects)
-        validateObject(context)(options)(visitor)(obj);
-      for (const func of meta.functions)
-        validateFunction(context)(options)(visitor)(func, explore);
-      for (const set of meta.sets)
-        validateMeta(context)(options)(visitor)(set, explore);
-      for (const map of meta.maps) {
-        validateMeta(context)(options)(visitor)(map.key, explore);
-        validateMeta(context)(options)(visitor)(map.value, explore);
-      }
+    for (const alias of props.metadata.aliases)
+      validateAlias({
+        ...props,
+        alias,
+      });
+    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,
+      });
+    for (const func of props.metadata.functions)
+      validateFunction({
+        ...props,
+        function: func,
+      });
+    for (const set of props.metadata.sets)
+      validateMeta({
+        ...props,
+        metadata: set,
+      });
+    for (const map of props.metadata.maps) {
+      validateMeta({
+        ...props,
+        metadata: map.key,
+      });
+      validateMeta({
+        ...props,
+        metadata: map.value,
+      });
+    }
 
-      if (options.escape === true && meta.escaped !== null)
-        validateMeta(context)(options)(visitor)(meta.escaped.returns, {
-          ...explore,
+    if (props.options.escape === true && props.metadata.escaped !== null)
+      validateMeta({
+        ...props,
+        metadata: props.metadata.escaped.returns,
+        explore: {
+          ...props.explore,
           escaped: true,
-        });
-    };
+        },
+      });
+  };
 
-  const validateAlias =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (alias: MetadataAlias, explore: IExplore) => {
-      if (visitor.aliases.has(alias)) return;
-      visitor.aliases.add(alias);
+  const validateAlias = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    alias: MetadataAlias;
+    explore: IExplore;
+  }) => {
+    if (props.visitor.aliases.has(props.alias)) return;
+    props.visitor.aliases.add(props.alias);
 
-      validateMeta(context)(options)(visitor)(alias.value, {
-        ...explore,
-        nested: alias,
+    validateMeta({
+      ...props,
+      metadata: props.alias.value,
+      explore: {
+        ...props.explore,
+        nested: props.alias,
         aliased: true,
-      });
-    };
+      },
+    });
+  };
 
-  const validateArray =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (array: MetadataArrayType, explore: IExplore) => {
-      if (visitor.arrays.has(array)) return;
-      visitor.arrays.add(array);
+  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(context)(options)(visitor)(array.value, {
-        ...explore,
-        nested: array,
+    validateMeta({
+      ...props,
+      metadata: props.array.value,
+      explore: {
+        ...props.explore,
+        nested: props.array,
         top: false,
-      });
-    };
+      },
+    });
+  };
 
-  const validateTuple =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (tuple: MetadataTupleType, explore: IExplore) => {
-      if (visitor.tuples.has(tuple)) return;
-      visitor.tuples.add(tuple);
+  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 tuple.elements)
-        validateMeta(context)(options)(visitor)(elem, {
-          ...explore,
-          nested: tuple,
+    for (const elem of props.tuple.elements)
+      validateMeta({
+        ...props,
+        metadata: elem,
+        explore: {
+          ...props.explore,
+          nested: props.tuple,
           top: false,
-        });
-    };
+        },
+      });
+  };
 
-  const validateObject =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (object: MetadataObject) => {
-      if (visitor.objects.has(object)) return;
-      visitor.objects.add(object);
+  const validateObject = (props: {
+    transformer?: ts.TransformationContext;
+    options: IOptions;
+    visitor: IValidationVisitor;
+    object: MetadataObject;
+  }) => {
+    if (props.visitor.objects.has(props.object)) return;
+    props.visitor.objects.add(props.object);
 
-      if (options.validate) {
-        const explore: IExplore = {
-          object,
-          top: false,
-          property: null,
-          parameter: null,
-          nested: null,
-          aliased: false,
-          escaped: false,
-          output: false,
-        };
-        const errors: string[] = options.validate(
-          Metadata.create({
-            ...Metadata.initialize(),
-            objects: [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: [props.object],
+        }),
+        explore,
+      );
+      if (errors.length)
+        props.visitor.errors.push({
+          name: props.object.name,
           explore,
-        );
-        if (errors.length)
-          visitor.errors.push({
-            name: object.name,
-            explore,
-            messages: [...new Set(errors)],
-          });
-      }
+          messages: [...new Set(errors)],
+        });
+    }
 
-      for (const property of object.properties)
-        validateMeta(context)(options)(visitor)(property.value, {
-          object,
+    for (const property of props.object.properties)
+      validateMeta({
+        ...props,
+        metadata: property.value,
+        explore: {
+          object: props.object,
           property: property.key.isSoleLiteral()
             ? property.key.getSoleLiteral()!
             : {},
@@ -273,34 +347,45 @@ export namespace MetadataFactory {
           aliased: false,
           escaped: false,
           output: false,
-        });
-    };
+        },
+      });
+  };
 
-  const validateFunction =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (func: MetadataFunction, explore: IExplore) => {
-      if (visitor.functions.has(func)) return;
-      visitor.functions.add(func);
+  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 func.parameters)
-        validateMeta(context)(options)(visitor)(param.type, {
-          ...explore,
+    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 (func.output)
-        validateMeta(context)(options)(visitor)(func.output, {
-          ...explore,
+        },
+      });
+    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;

package/src/factories/ProtobufFactory.ts

@@ -15,26 +15,33 @@ import { MetadataCollection } from "./MetadataCollection";
 import { MetadataFactory } from "./MetadataFactory";
 
 export namespace ProtobufFactory {
-  export const metadata =
-    (method: string) =>
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type): Metadata => {
-      // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
-      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-        MetadataFactory.analyze(
-          checker,
-          context,
-        )({
+  export interface IProps {
+    method: string;
+    checker: ts.TypeChecker;
+    transformer?: ts.TransformationContext;
+    collection: MetadataCollection;
+    type: ts.Type;
+  }
+
+  export const metadata = (props: IProps): Metadata => {
+    // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        ...props,
+        transformer: props.transformer,
+        options: {
           escape: false,
           constant: true,
           absorb: true,
           validate,
-        })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(`typia.protobuf.${method}`)(result.errors);
-      return result.data;
-    };
+        },
+      });
+    if (result.success === false)
+      throw TransformerError.from(`typia.protobuf.${props.method}`)(
+        result.errors,
+      );
+    return result.data;
+  };
 
   const validate = (
     meta: Metadata,

package/src/factories/internal/metadata/IMetadataIteratorProps.ts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export interface IMetadataIteratorProps<Type extends ts.Type = ts.Type> {
+  options: MetadataFactory.IOptions;
+  checker: ts.TypeChecker;
+  collection: MetadataCollection;
+  errors: MetadataFactory.IError[];
+  metadata: Metadata;
+  type: Type;
+  explore: MetadataFactory.IExplore;
+}