typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -59,7 +59,10 @@ export namespace HttpQueryProgrammer {
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
-    const statements: ts.Statement[] = decode_object(props.importer)(object);
+    const statements: ts.Statement[] = decode_object({
+      importer: props.importer,
+      object,
+    });
     return {
       functions: {},
       statements: [],
@@ -173,132 +176,150 @@ export namespace HttpQueryProgrammer {
     return errors;
   };
 
-  const decode_object =
-    (importer: FunctionImporter) =>
-    (object: MetadataObject): ts.Statement[] => {
-      const input: ts.Identifier = ts.factory.createIdentifier("input");
-      const output: ts.Identifier = ts.factory.createIdentifier("output");
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    object: MetadataObject;
+  }): ts.Statement[] => {
+    const input: ts.Identifier = ts.factory.createIdentifier("input");
+    const output: ts.Identifier = ts.factory.createIdentifier("output");
 
-      return [
-        ts.factory.createExpressionStatement(
-          ts.factory.createBinaryExpression(
-            input,
-            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                importer.use("params"),
-                undefined,
-                [input],
-              ),
-              ts.factory.createTypeReferenceNode("URLSearchParams"),
+    return [
+      ts.factory.createExpressionStatement(
+        ts.factory.createBinaryExpression(
+          input,
+          ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+          ts.factory.createAsExpression(
+            ts.factory.createCallExpression(
+              props.importer.use("params"),
+              undefined,
+              [input],
             ),
+            ts.factory.createTypeReferenceNode("URLSearchParams"),
           ),
         ),
-        StatementFactory.constant(
-          "output",
-          ts.factory.createObjectLiteralExpression(
-            object.properties.map((prop) =>
-              decode_regular_property(importer)(prop),
-            ),
-            true,
+      ),
+      StatementFactory.constant(
+        "output",
+        ts.factory.createObjectLiteralExpression(
+          props.object.properties.map((p) =>
+            decode_regular_property({
+              importer: props.importer,
+              property: p,
+            }),
           ),
+          true,
         ),
-        ts.factory.createReturnStatement(
-          ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
-        ),
-      ];
-    };
+      ),
+      ts.factory.createReturnStatement(
+        ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
+      ),
+    ];
+  };
 
-  const decode_regular_property =
-    (importer: FunctionImporter) =>
-    (property: MetadataProperty): ts.PropertyAssignment => {
-      const key: string = property.key.constants[0]!.values[0]!.value as string;
-      const value: Metadata = property.value;
+  const decode_regular_property = (props: {
+    importer: FunctionImporter;
+    property: MetadataProperty;
+  }): ts.PropertyAssignment => {
+    const key: string = props.property.key.constants[0]!.values[0]!
+      .value as string;
+    const value: Metadata = props.property.value;
 
-      const [type, isArray]: [Atomic.Literal, boolean] = value.atomics.length
-        ? [value.atomics[0]!.type, false]
-        : value.constants.length
-          ? [value.constants[0]!.type, false]
-          : value.templates.length
-            ? ["string", false]
-            : (() => {
-                const meta =
-                  value.arrays[0]?.type.value ??
-                  value.tuples[0]!.type.elements[0]!;
-                return meta.atomics.length
-                  ? [meta.atomics[0]!.type, true]
-                  : meta.templates.length
-                    ? ["string", true]
-                    : [meta.constants[0]!.type, true];
-              })();
-      return ts.factory.createPropertyAssignment(
-        Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
-        isArray
-          ? decode_array(importer)(value)(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("input.getAll"),
-                    undefined,
-                    [ts.factory.createStringLiteral(key)],
-                  ),
-                )("map"),
-                undefined,
-                [
-                  ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [IdentifierFactory.parameter("elem")],
-                    undefined,
-                    undefined,
-                    decode_value(importer)(type)(false)(
-                      ts.factory.createIdentifier("elem"),
-                    ),
-                  ),
-                ],
-              ),
-            )
-          : decode_value(importer)(type)(
-              value.nullable === false && value.isRequired() === false,
-            )(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("input.get"),
-                undefined,
-                [ts.factory.createStringLiteral(key)],
-              ),
+    const [type, isArray]: [Atomic.Literal, boolean] = value.atomics.length
+      ? [value.atomics[0]!.type, false]
+      : value.constants.length
+        ? [value.constants[0]!.type, false]
+        : value.templates.length
+          ? ["string", false]
+          : (() => {
+              const meta =
+                value.arrays[0]?.type.value ??
+                value.tuples[0]!.type.elements[0]!;
+              return meta.atomics.length
+                ? [meta.atomics[0]!.type, true]
+                : meta.templates.length
+                  ? ["string", true]
+                  : [meta.constants[0]!.type, true];
+            })();
+    return ts.factory.createPropertyAssignment(
+      Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
+      isArray
+        ? decode_array({
+            importer: props.importer,
+            metadata: value,
+            input: ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("input.getAll"),
+                  undefined,
+                  [ts.factory.createStringLiteral(key)],
+                ),
+              )("map"),
+              undefined,
+              [
+                ts.factory.createArrowFunction(
+                  undefined,
+                  undefined,
+                  [IdentifierFactory.parameter("elem")],
+                  undefined,
+                  undefined,
+                  decode_value({
+                    importer: props.importer,
+                    type,
+                    coalesce: false,
+                    input: ts.factory.createIdentifier("elem"),
+                  }),
+                ),
+              ],
             ),
-      );
-    };
+          })
+        : decode_value({
+            importer: props.importer,
+            type,
+            coalesce: value.nullable === false && value.isRequired() === false,
+            input: ts.factory.createCallExpression(
+              ts.factory.createIdentifier("input.get"),
+              undefined,
+              [ts.factory.createStringLiteral(key)],
+            ),
+          }),
+    );
+  };
 
-  const decode_value =
-    (importer: FunctionImporter) =>
-    (type: Atomic.Literal) =>
-    (onlyUndefindable: boolean) =>
-    (value: ts.Expression) => {
-      const call = ts.factory.createCallExpression(
-        importer.use(type),
-        undefined,
-        [value],
-      );
-      return onlyUndefindable
-        ? ts.factory.createBinaryExpression(
-            call,
-            ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-            ts.factory.createIdentifier("undefined"),
-          )
-        : call;
-    };
+  const decode_value = (props: {
+    importer: FunctionImporter;
+    type: Atomic.Literal;
+    coalesce: boolean;
+    input: ts.Expression;
+  }) => {
+    const call = ts.factory.createCallExpression(
+      props.importer.use(props.type),
+      undefined,
+      [props.input],
+    );
+    return props.coalesce
+      ? ts.factory.createBinaryExpression(
+          call,
+          ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+          ts.factory.createIdentifier("undefined"),
+        )
+      : call;
+  };
 
-  const decode_array =
-    (importer: FunctionImporter) =>
-    (value: Metadata) =>
-    (expression: ts.Expression): ts.Expression =>
-      value.nullable || value.isRequired() === false
-        ? ts.factory.createCallExpression(importer.use("array"), undefined, [
-            expression,
-            value.nullable
+  const decode_array = (props: {
+    importer: FunctionImporter;
+    metadata: Metadata;
+    input: ts.Expression;
+  }): ts.Expression =>
+    props.metadata.nullable || props.metadata.isRequired() === false
+      ? ts.factory.createCallExpression(
+          props.importer.use("array"),
+          undefined,
+          [
+            props.input,
+            props.metadata.nullable
               ? ts.factory.createNull()
               : ts.factory.createIdentifier("undefined"),
-          ])
-        : expression;
+          ],
+        )
+      : props.input;
 }

package/src/programmers/internal/application_escaped.ts

@@ -38,17 +38,17 @@ export const application_escaped = <Version extends "3.0" | "3.1">(props: {
  * @internal
  */
 const is_string = <Version extends "3.0" | "3.1">(
-  elem: Schema<Version>,
-): elem is StringSchema<Version> =>
-  (elem as StringSchema<Version>).type === "string";
+  schema: Schema<Version>,
+): schema is StringSchema<Version> =>
+  (schema as StringSchema<Version>).type === "string";
 
 /**
  * @internal
  */
 const is_one_of = <Version extends "3.0" | "3.1">(
-  elem: Schema<Version>,
-): elem is OneOfSchema<Version> =>
-  Array.isArray((elem as OneOfSchema<Version>).oneOf);
+  schema: Schema<Version>,
+): schema is OneOfSchema<Version> =>
+  Array.isArray((schema as OneOfSchema<Version>).oneOf);
 
 /**
  * @internal

package/src/programmers/internal/application_templates.ts

@@ -24,24 +24,26 @@ export const application_templates = <Version extends "3.0" | "3.1">(
   if (pureTemplates.length)
     output.push({
       type: "string",
-      pattern: metadata_to_pattern(true)(
-        Metadata.create({
+      pattern: metadata_to_pattern({
+        top: true,
+        metadata: Metadata.create({
           ...Metadata.initialize(),
           templates: pureTemplates,
         }),
-      ),
+      }),
     });
   for (const tpl of taggedTemplates)
     output.push(
       application_plugin({
         schema: {
           type: "string",
-          pattern: metadata_to_pattern(false)(
-            Metadata.create({
+          pattern: metadata_to_pattern({
+            top: false,
+            metadata: Metadata.create({
               ...Metadata.initialize(),
               templates: [tpl],
             }),
-          ),
+          }),
         },
         tags: tpl.tags ?? [],
       }) as any,

package/src/programmers/internal/application_union_discriminator.ts

@@ -5,19 +5,19 @@ import { Metadata } from "../../schemas/metadata/Metadata";
 import { UnionPredicator } from "../helpers/UnionPredicator";
 
 export const application_union_discriminator = (
-  meta: Metadata,
+  metadata: Metadata,
 ): OpenApi.IJsonSchema.IOneOf.IDiscriminator | undefined => {
   if (
-    meta.size() === 0 ||
-    meta.size() !== meta.objects.length ||
-    meta.objects.some((o) => o.isLiteral()) === true
+    metadata.size() === 0 ||
+    metadata.size() !== metadata.objects.length ||
+    metadata.objects.some((o) => o.isLiteral()) === true
   )
     return undefined;
   const specialized: UnionPredicator.ISpecialized[] = UnionPredicator.object(
-    meta.objects,
+    metadata.objects,
   );
   const meet: boolean =
-    specialized.length === meta.objects.length &&
+    specialized.length === metadata.objects.length &&
     specialized.every(
       (s) => s.property.key.isSoleLiteral() && s.property.value.isSoleLiteral(),
     ) &&

package/src/programmers/internal/application_v30_object.ts

@@ -95,7 +95,10 @@ const create_object_schema = (props: {
       properties[key] = schema;
       if (property.value.isRequired() === true) required.push(key);
     } else {
-      const pattern: string = metadata_to_pattern(true)(property.key);
+      const pattern: string = metadata_to_pattern({
+        top: true,
+        metadata: property.key,
+      });
       if (pattern === PatternUtil.STRING)
         extraMeta.additionalProperties = [property.value, schema];
       else extraMeta.patternProperties[pattern] = [property.value, schema];
@@ -140,7 +143,7 @@ const join = (props: {
   else if (elements.length === 1) return elements[0]![1]!;
 
   // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
-  const meta: Metadata = elements
+  const metadata: Metadata = elements
     .map((tuple) => tuple[0])
     .reduce((x, y) => Metadata.merge(x, y));
   return (
@@ -148,7 +151,7 @@ const join = (props: {
       blockNever: true,
       components: props.components,
       attribute: {},
-      metadata: meta,
+      metadata,
     }) ?? undefined
   );
 };

package/src/programmers/internal/application_v31_object.ts

@@ -78,7 +78,10 @@ const create_object_schema = (props: {
       properties[key] = schema;
       if (property.value.isRequired() === true) required.push(key);
     } else {
-      const pattern: string = metadata_to_pattern(true)(property.key);
+      const pattern: string = metadata_to_pattern({
+        top: true,
+        metadata: property.key,
+      });
       if (pattern === PatternUtil.STRING)
         extraMeta.additionalProperties = [property.value, schema];
       else extraMeta.patternProperties[pattern] = [property.value, schema];

package/src/programmers/internal/application_v31_tuple.ts

@@ -7,7 +7,7 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
  * @internal
  */
 export const application_v31_tuple = (props: {
-  generator: (meta: Metadata) => OpenApi.IJsonSchema;
+  generator: (metadata: Metadata) => OpenApi.IJsonSchema;
   tuple: MetadataTuple;
 }): OpenApi.IJsonSchema.ITuple => {
   const tail: Metadata | null = props.tuple.type.elements.at(-1)?.rest ?? null;

package/src/programmers/internal/check_array_length.ts

@@ -2,7 +2,6 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 
 import { ITypiaContext } from "../../transformers/ITypiaContext";
@@ -12,34 +11,36 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
 /**
  * @internal
  */
-export const check_array_length =
-  (project: ITypiaContext) =>
-  (array: MetadataArray) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
-      project,
-    )(array.tags)(input);
-
-    return {
-      expected: array.getName(),
-      expression: null,
-      conditions,
-    };
+export const check_array_length = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_array_type_tags(props);
+  return {
+    expected: props.array.getName(),
+    expression: null,
+    conditions,
   };
+};
 
-const check_string_type_tags =
-  (project: ITypiaContext) =>
-  (matrix: IMetadataTypeTag[][]) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    matrix
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `Array<> & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+/**
+ * @internal
+ */
+const check_array_type_tags = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.array.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) =>
+      row.map((tag) => ({
+        expected: `Array<> & ${tag.name}`,
+        expression: (
+          tag.predicate ??
+          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+        )(props.input),
+      })),
+    );

package/src/programmers/internal/check_bigint.ts

@@ -11,39 +11,39 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
 /**
  * @internal
  */
-export const check_bigint =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] =
-      check_bigint_type_tags(project)(atomic)(input);
-
-    return {
-      expected: atomic.getName(),
-      expression: ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("bigint"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-      conditions,
-    };
+export const check_bigint = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_bigint_type_tags(props);
+  return {
+    expected: props.atomic.getName(),
+    expression: ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("bigint"),
+      ts.factory.createTypeOfExpression(props.input),
+    ),
+    conditions,
   };
+};
 
 /**
  * @internal
  */
-const check_bigint_type_tags =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `bigint & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+const check_bigint_type_tags = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.atomic.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) =>
+      row.map((tag) => ({
+        expected: `bigint & ${tag.name}`,
+        expression: (
+          tag.predicate ??
+          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+        )(props.input),
+      })),
+    );