typia 7.0.0-dev.20240916 → 7.0.0-dev.20240919

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -1,107 +1,110 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-
-export namespace HttpParameterProgrammer {
-  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate,
-    })(new MetadataCollection())(props.type);
-    if (result.success === false)
-      throw TransformerError.from(props.modulo.getText())(result.errors);
-
-    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-    const importer: FunctionImporter = new FunctionImporter(
-      props.modulo.getText(),
-    );
-    const block: ts.Statement[] = [
-      StatementFactory.constant(
-        "assert",
-        AssertProgrammer.write({
-          ...props,
-          context: {
-            ...props.context,
-            options: {
-              numeric: true,
-            },
-          },
-          config: {
-            equals: false,
-            guard: false,
-          },
-        }),
-      ),
-      StatementFactory.constant(
-        "value",
-        ts.factory.createCallExpression(importer.use(atomic), undefined, [
-          ts.factory.createIdentifier("input"),
-        ]),
-      ),
-      ts.factory.createReturnStatement(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("assert"),
-          undefined,
-          [ts.factory.createIdentifier("value")],
-        ),
-      ),
-    ];
-
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [
-        IdentifierFactory.parameter(
-          "input",
-          ts.factory.createTypeReferenceNode("string"),
-        ),
-      ],
-      ts.factory.createTypeReferenceNode(
-        props.name ??
-          TypeFactory.getFullName(props.context.checker)(props.type),
-      ),
-      undefined,
-      ts.factory.createBlock(
-        [...importer.declare(props.modulo), ...block],
-        true,
-      ),
-    );
-  };
-
-  export const validate = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = HttpMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpParameterProgrammer {
+  export const write = (props: IProgrammerProps): ts.ArrowFunction => {
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from(props.modulo.getText())(result.errors);
+
+    const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const block: ts.Statement[] = [
+      StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write({
+          ...props,
+          context: {
+            ...props.context,
+            options: {
+              numeric: true,
+            },
+          },
+          config: {
+            equals: false,
+            guard: false,
+          },
+        }),
+      ),
+      StatementFactory.constant(
+        "value",
+        ts.factory.createCallExpression(importer.use(atomic), undefined, [
+          ts.factory.createIdentifier("input"),
+        ]),
+      ),
+      ts.factory.createReturnStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [ts.factory.createIdentifier("value")],
+        ),
+      ),
+    ];
+
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [
+        IdentifierFactory.parameter(
+          "input",
+          ts.factory.createTypeReferenceNode("string"),
+        ),
+      ],
+      ts.factory.createTypeReferenceNode(
+        props.name ??
+          TypeFactory.getFullName(props.context.checker)(props.type),
+      ),
+      undefined,
+      ts.factory.createBlock(
+        [...importer.declare(props.modulo), ...block],
+        true,
+      ),
+    );
+  };
+
+  export const validate = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = HttpMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+}

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -39,15 +39,19 @@ export namespace HttpQueryProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     // ANALYZE TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate: (meta, explore) => validate(meta, explore, props.allowOptional),
-    })(collection)(props.type);
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: (meta, explore) =>
+          validate(meta, explore, props.allowOptional),
+      },
+      collection,
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.http.${props.importer.method}`)(
         result.errors,

package/src/programmers/internal/application_array.ts

@@ -8,43 +8,38 @@ import { application_plugin } from "./application_plugin";
 /**
  * @internal
  */
-export const application_array =
-  <Version extends "3.0" | "3.1">(
-    generator: (value: Metadata) => Schema<Version>,
-  ) =>
-  (
-    components: Version extends "3.0"
-      ? OpenApiV3.IComponents
-      : OpenApi.IComponents,
-  ) =>
-  (
-    array: MetadataArray,
-  ): Array<ArraySchema<Version> | OpenApiV3.IJsonSchema.IReference> => {
-    const factory = (): ArraySchema<Version>[] =>
-      application_plugin<ArraySchema<Version>>(
-        {
-          type: "array",
-          items: generator(array.type.value),
-        } as ArraySchema<Version>,
-        array.tags,
-      );
-    if (array.type.recursive === true) {
-      const out = () => [{ $ref }];
-      const $ref: string = `#/components/schemas/${array.type.name}`;
-      if (components.schemas?.[$ref] !== undefined) return out();
+export const application_array = <Version extends "3.0" | "3.1">(props: {
+  generator: (value: Metadata) => Schema<Version>;
+  components: Version extends "3.0"
+    ? OpenApiV3.IComponents
+    : OpenApi.IComponents;
+  array: MetadataArray;
+}): Array<ArraySchema<Version> | OpenApiV3.IJsonSchema.IReference> => {
+  const factory = (): ArraySchema<Version>[] =>
+    application_plugin<ArraySchema<Version>>({
+      schema: {
+        type: "array",
+        items: props.generator(props.array.type.value),
+      } as ArraySchema<Version>,
+      tags: props.array.tags,
+    });
+  if (props.array.type.recursive === true) {
+    const out = () => [{ $ref }];
+    const $ref: string = `#/components/schemas/${props.array.type.name}`;
+    if (props.components.schemas?.[$ref] !== undefined) return out();
 
-      components.schemas ??= {};
-      components.schemas[$ref] ??= {};
+    props.components.schemas ??= {};
+    props.components.schemas[$ref] ??= {};
 
-      const oneOf: ArraySchema<Version>[] = factory();
-      Object.assign(
-        components.schemas[$ref]!,
-        oneOf.length === 1 ? oneOf[0] : { oneOf },
-      );
-      return out();
-    }
-    return factory();
-  };
+    const oneOf: ArraySchema<Version>[] = factory();
+    Object.assign(
+      props.components.schemas[$ref]!,
+      oneOf.length === 1 ? oneOf[0] : { oneOf },
+    );
+    return out();
+  }
+  return factory();
+};
 
 /**
  * @internal

package/src/programmers/internal/application_bigint.ts

@@ -10,12 +10,12 @@ import { application_plugin } from "./application_plugin";
 export const application_bigint = <Version extends "3.0" | "3.1">(
   atomic: MetadataAtomic,
 ): Schema<Version>[] =>
-  application_plugin(
-    {
+  application_plugin({
+    schema: {
       type: "integer",
     } satisfies Schema<Version>,
-    atomic.tags,
-  );
+    tags: atomic.tags,
+  });
 
 /**
  * @internal

package/src/programmers/internal/application_boolean.ts

@@ -10,12 +10,12 @@ import { application_plugin } from "./application_plugin";
 export const application_boolean = <Version extends "3.0" | "3.1">(
   atomic: MetadataAtomic,
 ): Schema<Version>[] =>
-  application_plugin(
-    {
+  application_plugin({
+    schema: {
       type: "boolean",
     } satisfies Schema<Version>,
-    atomic.tags,
-  );
+    tags: atomic.tags,
+  });
 
 /**
  * @internal

package/src/programmers/internal/application_escaped.ts

@@ -6,29 +6,33 @@ import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
 /**
  * @internal
  */
-export const application_escaped =
-  <Version extends "3.0" | "3.1">(
-    generator: (meta: Metadata) => Schema<Version>,
-  ) =>
-  (escaped: MetadataEscaped): Schema<Version>[] => {
-    const output: Schema<Version> | null = generator(escaped.returns);
-    if (output === null) return [];
+export const application_escaped = <Version extends "3.0" | "3.1">(props: {
+  generator: (meta: Metadata) => Schema<Version>;
+  escaped: MetadataEscaped;
+}): Schema<Version>[] => {
+  const output: Schema<Version> | null = props.generator(props.escaped.returns);
+  if (output === null) return [];
 
-    if (is_date(new Set())(escaped.original)) {
-      const string: StringSchema<Version> | undefined = is_string(output)
-        ? output
-        : is_one_of(output)
-          ? (output.oneOf.find(is_string) as StringSchema<Version>)
-          : undefined;
-      if (
-        string !== undefined &&
-        string.format !== "date" &&
-        string.format !== "date-time"
-      )
-        string.format = "date-time";
-    }
-    return is_one_of(output) ? (output.oneOf as Schema<Version>[]) : [output];
-  };
+  if (
+    is_date({
+      visited: new Set(),
+      metadata: props.escaped.original,
+    })
+  ) {
+    const string: StringSchema<Version> | undefined = is_string(output)
+      ? output
+      : is_one_of(output)
+        ? (output.oneOf.find(is_string) as StringSchema<Version>)
+        : undefined;
+    if (
+      string !== undefined &&
+      string.format !== "date" &&
+      string.format !== "date-time"
+    )
+      string.format = "date-time";
+  }
+  return is_one_of(output) ? (output.oneOf as Schema<Version>[]) : [output];
+};
 
 /**
  * @internal
@@ -49,19 +53,37 @@ const is_one_of = <Version extends "3.0" | "3.1">(
 /**
  * @internal
  */
-const is_date =
-  (visited: Set<Metadata>) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
+const is_date = (props: {
+  visited: Set<Metadata>;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
 
-    return (
-      meta.natives.some((name) => name === "Date") ||
-      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
-      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
-      meta.aliases.some((alias) => is_date(visited)(alias.value))
-    );
-  };
+  return (
+    props.metadata.natives.some((name) => name === "Date") ||
+    props.metadata.arrays.some((array) =>
+      is_date({
+        visited: props.visited,
+        metadata: array.type.value,
+      }),
+    ) ||
+    props.metadata.tuples.some((tuple) =>
+      tuple.type.elements.some((e) =>
+        is_date({
+          visited: props.visited,
+          metadata: e,
+        }),
+      ),
+    ) ||
+    props.metadata.aliases.some((alias) =>
+      is_date({
+        visited: props.visited,
+        metadata: alias.value,
+      }),
+    )
+  );
+};
 
 type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
   ? OpenApiV3.IJsonSchema

package/src/programmers/internal/application_number.ts

@@ -10,12 +10,12 @@ import { application_plugin } from "./application_plugin";
 export const application_number = <Version extends "3.0" | "3.1">(
   atomic: MetadataAtomic,
 ): Schema<Version>[] =>
-  application_plugin(
-    {
+  application_plugin({
+    schema: {
       type: "number",
     } satisfies Schema<Version>,
-    atomic.tags,
-  );
+    tags: atomic.tags,
+  });
 
 /**
  * @internal

package/src/programmers/internal/application_plugin.ts

@@ -3,16 +3,16 @@ import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 /**
  * @internal
  */
-export const application_plugin = <Schema extends object>(
-  schema: Schema,
-  tags: IMetadataTypeTag[][],
-): Schema[] => {
-  const plugins: IMetadataTypeTag[][] = tags
+export const application_plugin = <Schema extends object>(props: {
+  schema: Schema;
+  tags: IMetadataTypeTag[][];
+}): Schema[] => {
+  const plugins: IMetadataTypeTag[][] = props.tags
     .map((row) => row.filter((t) => t.schema !== undefined))
     .filter((row) => row.length !== 0);
-  if (plugins.length === 0) return [schema];
+  if (plugins.length === 0) return [props.schema];
   return plugins.map((row) => {
-    const base: Schema = { ...schema };
+    const base: Schema = { ...props.schema };
     for (const tag of row) Object.assign(base, tag.schema);
     return base;
   });

package/src/programmers/internal/application_string.ts

@@ -10,12 +10,12 @@ import { application_plugin } from "./application_plugin";
 export const application_string = <Version extends "3.0" | "3.1">(
   atomic: MetadataAtomic,
 ): Schema<Version>[] =>
-  application_plugin(
-    {
+  application_plugin({
+    schema: {
       type: "string",
     } satisfies Schema<Version>,
-    atomic.tags,
-  );
+    tags: atomic.tags,
+  });
 
 /**
  * @internal

package/src/programmers/internal/application_templates.ts

@@ -33,8 +33,8 @@ export const application_templates = <Version extends "3.0" | "3.1">(
     });
   for (const tpl of taggedTemplates)
     output.push(
-      application_plugin(
-        {
+      application_plugin({
+        schema: {
           type: "string",
           pattern: metadata_to_pattern(false)(
             Metadata.create({
@@ -43,8 +43,8 @@ export const application_templates = <Version extends "3.0" | "3.1">(
             }),
           ),
         },
-        tpl.tags ?? [],
-      ) as any,
+        tags: tpl.tags ?? [],
+      }) as any,
     );
   return output;
 };

package/src/programmers/internal/application_v30_alias.ts

@@ -12,41 +12,48 @@ import { application_v30_schema } from "./application_v30_schema";
 /**
  * @internal
  */
-export const application_v30_alias =
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: OpenApiV3.IComponents) =>
-  (alias: MetadataAlias) =>
-  (nullable: boolean): OpenApiV3.IJsonSchema.IReference => {
-    if (alias.value.size() === 1 && alias.value.objects.length === 1)
-      return application_v30_object(components)(alias.value.objects[0]!)(
-        nullable,
-      ) as OpenApiV3.IJsonSchema.IReference;
+export const application_v30_alias = <BlockNever extends boolean>(props: {
+  blockNever: BlockNever;
+  components: OpenApiV3.IComponents;
+  alias: MetadataAlias;
+  nullable: boolean;
+}): OpenApiV3.IJsonSchema.IReference => {
+  if (props.alias.value.size() === 1 && props.alias.value.objects.length === 1)
+    return application_v30_object({
+      object: props.alias.value.objects[0]!,
+      components: props.components,
+      nullable: props.nullable,
+    }) as OpenApiV3.IJsonSchema.IReference;
 
-    const key: string = `${alias.name}${nullable ? ".Nullable" : ""}`;
-    const $ref: string = `#/components/schemas/${key}`;
+  const key: string = `${props.alias.name}${props.nullable ? ".Nullable" : ""}`;
+  const $ref: string = `#/components/schemas/${key}`;
 
-    if (components.schemas?.[key] === undefined) {
-      // TEMPORARY ASSIGNMENT
-      components.schemas ??= {};
-      components.schemas[key] = {};
+  if (props.components.schemas?.[key] === undefined) {
+    // TEMPORARY ASSIGNMENT
+    props.components.schemas ??= {};
+    props.components.schemas[key] = {};
 
-      // GENERATE SCHEMA
-      const schema: OpenApiV3.IJsonSchema | null = application_v30_schema(
-        blockNever,
-      )(components)({
+    // GENERATE SCHEMA
+    const schema: OpenApiV3.IJsonSchema | null = application_v30_schema({
+      blockNever: props.blockNever,
+      components: props.components,
+      attribute: {
         deprecated:
-          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
+          props.alias.jsDocTags.some((tag) => tag.name === "deprecated") ||
+          undefined,
         title: (() => {
-          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
+          const info: IJsDocTagInfo | undefined = props.alias.jsDocTags.find(
             (tag) => tag.name === "title",
           );
           return info?.text?.length
             ? CommentFactory.merge(info.text)
             : undefined;
         })(),
-        description: application_description(alias),
-      })(alias.value);
-      if (schema !== null) Object.assign(components.schemas[key]!, schema);
-    }
-    return { $ref };
-  };
+        description: application_description(props.alias),
+      },
+      metadata: props.alias.value,
+    });
+    if (schema !== null) Object.assign(props.components.schemas[key]!, schema);
+  }
+  return { $ref };
+};