typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -0,0 +1,87 @@
+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 { AssertProgrammer } from "../AssertProgrammer";
+import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpAssertFormDataProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode("FormData"),
+          ),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "decode",
+            HttpFormDataProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertHeadersProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -24,11 +24,20 @@ export namespace HttpAssertHeadersProgrammer {
               HttpHeadersProgrammer.INPUT_TYPE,
             ),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([
@@ -67,7 +76,10 @@ export namespace HttpAssertHeadersProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertQueryProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -22,11 +22,20 @@ export namespace HttpAssertQueryProgrammer {
             "input",
             ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([
@@ -65,7 +74,10 @@ export namespace HttpAssertQueryProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -0,0 +1,256 @@
+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/FunctionImporter";
+import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
+
+export namespace HttpFormDataProgrammer {
+  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("FormData"),
+          ),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
+        ),
+        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("formdata parameters cannot be null.");
+      if (meta.isRequired() === false)
+        insert("formdata 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) +
+        meta.natives.filter((n) => n === "Blob" || n === "File").length;
+      if (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.size() !== expected)
+        insert(
+          "only atomic, constant or blob (file) 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.filter((n) => n !== "Blob" && n !== "File").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 [
+        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]!.value as string;
+      const value: Metadata = property.value;
+
+      const [type, isArray]: [Atomic.Literal | "blob" | "file", boolean] = value
+        .atomics.length
+        ? [value.atomics[0]!.type, false]
+        : value.constants.length
+          ? [value.constants[0]!.type, false]
+          : value.templates.length
+            ? ["string", false]
+            : value.natives.includes("Blob")
+              ? ["blob", false]
+              : value.natives.includes("File")
+                ? ["file", 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.natives.includes("Blob")
+                          ? ["blob", true]
+                          : meta.natives.includes("File")
+                            ? ["file", 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 | "blob" | "file") =>
+    (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/HttpHeadersProgrammer.ts

@@ -59,13 +59,24 @@ export namespace HttpHeadersProgrammer {
             ts.factory.createTypeReferenceNode(INPUT_TYPE),
           ),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
-        ts.factory.createBlock([...importer.declare(), ...statements], true),
+        ts.factory.createBlock(
+          [...importer.declare(modulo), ...statements],
+          true,
+        ),
       );
     };
 
@@ -175,7 +186,9 @@ export namespace HttpHeadersProgrammer {
                 !prop.value.isRequired() &&
                 prop.value.arrays.length + prop.value.tuples.length > 0
               )
-                optionals.push(prop.key.constants[0]!.values[0] as string);
+                optionals.push(
+                  prop.key.constants[0]!.values[0]!.value as string,
+                );
               return decode_regular_property(importer)(prop);
             }),
             true,
@@ -202,24 +215,25 @@ export namespace HttpHeadersProgrammer {
   const decode_regular_property =
     (importer: FunctionImporter) =>
     (property: MetadataProperty): ts.PropertyAssignment => {
-      const key: string = property.key.constants[0]!.values[0] as string;
+      const key: string = property.key.constants[0]!.values[0]!.value 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: Metadata =
-              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];
-          })();
+          ? [value.constants[0]!.type, false]
+          : value.templates.length
+            ? ["string", false]
+            : (() => {
+                const meta: Metadata =
+                  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];
+              })();
       const accessor = IdentifierFactory.access(
         ts.factory.createIdentifier("input"),
       )(key.toLowerCase());
@@ -240,7 +254,7 @@ export namespace HttpHeadersProgrammer {
     (value: ts.Expression) =>
       type === "string"
         ? value
-        : ts.factory.createCallExpression(reader(importer)(type), undefined, [
+        : ts.factory.createCallExpression(importer.use(type), undefined, [
             value,
           ]);
 
@@ -267,7 +281,7 @@ export namespace HttpHeadersProgrammer {
         ),
         undefined,
         undefined,
-        [reader(importer)(type)],
+        [importer.use(type)],
       );
       return ts.factory.createConditionalExpression(
         ExpressionFactory.isArray(accessor),
@@ -275,7 +289,7 @@ export namespace HttpHeadersProgrammer {
         ts.factory.createCallExpression(
           IdentifierFactory.access(accessor)("map"),
           undefined,
-          [reader(importer)(type)],
+          [importer.use(type)],
         ),
         undefined,
         value.isRequired() === false
@@ -309,6 +323,3 @@ const SINGULAR: Set<string> = new Set([
   "server",
   "user-agent",
 ]);
-
-const reader = (importer: FunctionImporter) => (type: Atomic.Literal) =>
-  IdentifierFactory.access(importer.use("HeadersReader"))(type);

package/src/programmers/http/HttpIsFormDataProgrammer.ts

@@ -0,0 +1,90 @@
+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 { IsProgrammer } from "../IsProgrammer";
+import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpIsFormDataProgrammer {
+  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("FormData"),
+          ),
+        ],
+        ts.factory.createUnionTypeNode([
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
+          ),
+          ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+        ]),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "is",
+            IsProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "decode",
+            HttpFormDataProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createIfStatement(
+            ts.factory.createPrefixUnaryExpression(
+              ts.SyntaxKind.ExclamationToken,
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("is"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+            ),
+            ts.factory.createReturnStatement(ts.factory.createNull()),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpIsHeadersProgrammer.ts

@@ -26,10 +26,18 @@ export namespace HttpIsHeadersProgrammer {
           ),
         ],
         ts.factory.createUnionTypeNode([
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           ts.factory.createLiteralTypeNode(ts.factory.createNull()),
         ]),
@@ -47,7 +55,7 @@ export namespace HttpIsHeadersProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "headers",
+            "decode",
             HttpHeadersProgrammer.write({
               ...project,
               options: {
@@ -60,7 +68,7 @@ export namespace HttpIsHeadersProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("headers"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),