typia 5.4.2 → 5.4.3

package/src/programmers/RandomProgrammer.ts

@@ -620,6 +620,8 @@ export namespace RandomProgrammer {
       else if (type === "ArrayBuffer" || type === "SharedArrayBuffer")
         return decode_native_array_buffer(importer)(type);
       else if (type === "DataView") return decode_native_data_view(importer);
+      else if (type === "Blob") return decode_native_blob(importer);
+      else if (type === "File") return decode_native_file(importer);
       else
         return ts.factory.createNewExpression(
           ts.factory.createIdentifier(type),
@@ -709,6 +711,48 @@ export namespace RandomProgrammer {
       );
     };
 
+  const decode_native_blob = (importer: FunctionImporter) =>
+    ts.factory.createNewExpression(
+      ts.factory.createIdentifier("Blob"),
+      undefined,
+      [
+        ts.factory.createArrayLiteralExpression(
+          [decode_native_byte_array(importer)("Uint8Array")],
+          true,
+        ),
+      ],
+    );
+
+  const decode_native_file = (importer: FunctionImporter) =>
+    ts.factory.createNewExpression(
+      ts.factory.createIdentifier("File"),
+      undefined,
+      [
+        ts.factory.createArrayLiteralExpression(
+          [decode_native_byte_array(importer)("Uint8Array")],
+          true,
+        ),
+        ts.factory.createTemplateExpression(ts.factory.createTemplateHead(""), [
+          ts.factory.createTemplateSpan(
+            ts.factory.createCallExpression(
+              COALESCE(importer)("string"),
+              undefined,
+              [ts.factory.createNumericLiteral(8)],
+            ),
+            ts.factory.createTemplateMiddle("."),
+          ),
+          ts.factory.createTemplateSpan(
+            ts.factory.createCallExpression(
+              COALESCE(importer)("string"),
+              undefined,
+              [ts.factory.createNumericLiteral(3)],
+            ),
+            ts.factory.createTemplateTail(""),
+          ),
+        ]),
+      ],
+    );
+
   const decode_native_array_buffer =
     (importer: FunctionImporter) =>
     (type: "ArrayBuffer" | "SharedArrayBuffer"): ts.Expression =>

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -0,0 +1,75 @@
+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): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode("FormData"),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>`,
+        ),
+        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")],
+              ),
+              TypeFactory.keyword("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -0,0 +1,247 @@
+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 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.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("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.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] 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/HttpIsFormDataProgrammer.ts

@@ -0,0 +1,82 @@
+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.createTypeReferenceNode(
+            `typia.Resolved<${
+              name ?? TypeFactory.getFullName(project.checker)(type)
+            }>`,
+          ),
+          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

@@ -47,7 +47,7 @@ export namespace HttpIsHeadersProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "headers",
+            "decode",
             HttpHeadersProgrammer.write({
               ...project,
               options: {
@@ -60,7 +60,7 @@ export namespace HttpIsHeadersProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("headers"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/http/HttpIsQueryProgrammer.ts

@@ -45,7 +45,7 @@ export namespace HttpIsQueryProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "query",
+            "decode",
             HttpQueryProgrammer.write({
               ...project,
               options: {
@@ -58,7 +58,7 @@ export namespace HttpIsQueryProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/http/HttpValidateFormDataProgrammer.ts

@@ -0,0 +1,75 @@
+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 { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpValidateFormDataProgrammer {
+  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.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(
+            "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.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -44,7 +44,7 @@ export namespace HttpValidateHeadersProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "headers",
+            "decode",
             HttpHeadersProgrammer.write({
               ...project,
               options: {
@@ -57,7 +57,7 @@ export namespace HttpValidateHeadersProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("headers"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -42,7 +42,7 @@ export namespace HttpValidateQueryProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "query",
+            "decode",
             HttpQueryProgrammer.write({
               ...project,
               options: {
@@ -55,7 +55,7 @@ export namespace HttpValidateQueryProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/internal/application_native.ts

@@ -11,7 +11,13 @@ export const application_native =
   (options: JsonApplicationProgrammer.IOptions) =>
   (components: IJsonComponents) =>
   (name: string) =>
-  (nullable: boolean): IJsonSchema.IReference => {
+  (nullable: boolean): IJsonSchema => {
+    if (name === "Blob" || name === "File")
+      return {
+        type: "string",
+        format: "binary",
+        nullable,
+      };
     const key: string =
       options.purpose === "ajv"
         ? name

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -4,6 +4,7 @@ import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { TransformerError } from "../../transformers/TransformerError";
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
 
 import { application_schema } from "../internal/application_schema";
 
@@ -31,7 +32,6 @@ export namespace JsonApplicationProgrammer {
         schemas: {},
       };
       const generator = application_schema(fullOptions)(true)(components);
-
       return {
         schemas: metadatas.map((meta, i) => {
           const schema: IJsonSchema | null = generator(meta)({});
@@ -46,4 +46,31 @@ export namespace JsonApplicationProgrammer {
         ...fullOptions,
       };
     };
+
+  export const validate = (meta: Metadata) => {
+    const output: string[] = [];
+    if (
+      meta.atomics.some((a) => a.type === "bigint") ||
+      meta.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON schema does not support bigint type.");
+    if (
+      meta.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      meta.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON schema does not support undefined type in array.");
+    if (meta.maps.length) output.push("JSON schema does not support Map type.");
+    if (meta.sets.length) output.push("JSON schema does not support Set type.");
+    for (const native of meta.natives)
+      if (
+        AtomicPredicator.native(native) === false &&
+        native !== "Date" &&
+        native !== "Blob" &&
+        native !== "File"
+      )
+        output.push(`JSON schema does not support ${native} type.`);
+    return output;
+  };
 }