typia 5.3.5-dev.20231206 → 5.3.5

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -1,252 +1,252 @@
-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 { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { IProject } from "../../transformers/IProject";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
-
-export namespace HttpQueryProgrammer {
-  export const INPUT_TYPE = "string | URLSearchParams";
-
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction => {
-      // GET OBJECT TYPE
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const collection: MetadataCollection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.context,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(`typia.http.${importer.method}`)(
-          result.errors,
-        );
-
-      // DO TRANSFORM
-      const object: MetadataObject = result.data.objects[0]!;
-      const statements: ts.Statement[] = decode_object(importer)(object);
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(INPUT_TYPE),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
-        ),
-        undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo), ...statements],
-          true,
-        ),
-      );
-    };
-
-  export const validate = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
-        insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("query parameters cannot be null.");
-      if (meta.isRequired() === false)
-        insert("query parameters cannot be undefined.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArrayType
-    ) {
-      //----
-      // ARRAY
-      //----
-      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 (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.size() !== expected)
-        insert("only atomic or constant types are allowed in array.");
-    } else if (explore.object && explore.property !== null) {
-      //----
-      // COMMON
-      //----
-      // PROPERTY MUST BE SOLE
-      if (typeof explore.property === "object")
-        insert("dynamic property is not allowed.");
-      // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
-      // DO NOT ALLOW UNION TYPE
-      if (HttpMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
-      // DO NOT ALLOW NESTED OBJECT
-      if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
-      )
-        insert("nested object type is not allowed.");
-    }
-    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");
-
-      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"),
-            ),
-          ),
-        ),
-        StatementFactory.constant(
-          "output",
-          ts.factory.createObjectLiteralExpression(
-            object.properties.map((prop) =>
-              decode_regular_property(importer)(prop),
-            ),
-            true,
-          ),
-        ),
-        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] as string;
-      const value: Metadata = 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 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_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
-              ? ts.factory.createNull()
-              : ts.factory.createIdentifier("undefined"),
-          ])
-        : expression;
-}
+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 { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpQueryProgrammer {
+  export const INPUT_TYPE = "string | URLSearchParams";
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction => {
+      // GET OBJECT TYPE
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const collection: MetadataCollection = new MetadataCollection();
+      const result = MetadataFactory.analyze(
+        project.checker,
+        project.context,
+      )({
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      })(collection)(type);
+      if (result.success === false)
+        throw TransformerError.from(`typia.http.${importer.method}`)(
+          result.errors,
+        );
+
+      // DO TRANSFORM
+      const object: MetadataObject = result.data.objects[0]!;
+      const statements: ts.Statement[] = decode_object(importer)(object);
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(INPUT_TYPE),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        undefined,
+        ts.factory.createBlock(
+          [...importer.declare(modulo), ...statements],
+          true,
+        ),
+      );
+    };
+
+  export const validate = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      // TOP MUST BE ONLY OBJECT
+      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+        insert("only one object type is allowed.");
+      if (meta.nullable === true) insert("query parameters cannot be null.");
+      if (meta.isRequired() === false)
+        insert("query parameters cannot be undefined.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArrayType
+    ) {
+      //----
+      // ARRAY
+      //----
+      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 (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.size() !== expected)
+        insert("only atomic or constant types are allowed in array.");
+    } else if (explore.object && explore.property !== null) {
+      //----
+      // COMMON
+      //----
+      // PROPERTY MUST BE SOLE
+      if (typeof explore.property === "object")
+        insert("dynamic property is not allowed.");
+      // DO NOT ALLOW TUPLE TYPE
+      if (meta.tuples.length) insert("tuple type is not allowed.");
+      // DO NOT ALLOW UNION TYPE
+      if (HttpMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      // DO NOT ALLOW NESTED OBJECT
+      if (
+        meta.objects.length ||
+        meta.sets.length ||
+        meta.maps.length ||
+        meta.natives.length
+      )
+        insert("nested object type is not allowed.");
+    }
+    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");
+
+      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"),
+            ),
+          ),
+        ),
+        StatementFactory.constant(
+          "output",
+          ts.factory.createObjectLiteralExpression(
+            object.properties.map((prop) =>
+              decode_regular_property(importer)(prop),
+            ),
+            true,
+          ),
+        ),
+        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] as string;
+      const value: Metadata = 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 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_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
+              ? ts.factory.createNull()
+              : ts.factory.createIdentifier("undefined"),
+          ])
+        : expression;
+}

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpValidateHeadersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(
-              HttpHeadersProgrammer.INPUT_TYPE,
-            ),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>>`,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: true,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "headers",
-            HttpHeadersProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("headers"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("output")],
-              ),
-              ts.factory.createTypeReferenceNode("any"),
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpValidateHeadersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(
+              HttpHeadersProgrammer.INPUT_TYPE,
+            ),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.IValidation<typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "validate",
+            ValidateProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: true,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "headers",
+            HttpHeadersProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("headers"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+}