typia 6.6.2 → 6.7.0-dev.20240802

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -1,82 +1,82 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { application_v30_schema } from "../internal/application_v30_schema";
-import { application_v31_schema } from "../internal/application_v31_schema";
-
-export namespace JsonApplicationProgrammer {
-  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;
-  };
-
-  export const write = <Version extends "3.0" | "3.1">(version: Version) =>
-    version === "3.0" ? v30 : v31;
-
-  const v30 = (metadatas: Array<Metadata>): IJsonApplication<"3.0"> => {
-    const components: OpenApiV3.IComponents = {};
-    const generator = (meta: Metadata): OpenApiV3.IJsonSchema | null =>
-      application_v30_schema(true)(components)({})(meta);
-    return {
-      version: "3.0",
-      components,
-      schemas: metadatas.map((meta, i) => {
-        const schema: OpenApiV3.IJsonSchema | null = generator(meta);
-        if (schema === null)
-          throw new TransformerError({
-            code: "typia.json.application",
-            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-          });
-        return schema;
-      }),
-    };
-  };
-
-  const v31 = (metadatas: Array<Metadata>): IJsonApplication<"3.1"> => {
-    const components: OpenApi.IComponents = {
-      schemas: {},
-    };
-    const generator = (meta: Metadata): OpenApi.IJsonSchema | null =>
-      application_v31_schema(true)(components)({})(meta);
-    return {
-      version: "3.1",
-      components,
-      schemas: metadatas.map((meta, i) => {
-        const schema: OpenApi.IJsonSchema | null = generator(meta);
-        if (schema === null)
-          throw new TransformerError({
-            code: "typia.json.application",
-            message: `invalid type on argument - (${meta.getName()}, ${i})`,
-          });
-        return schema;
-      }),
-    };
-  };
-}
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { IJsonApplication } from "../../schemas/json/IJsonApplication";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { application_v30_schema } from "../internal/application_v30_schema";
+import { application_v31_schema } from "../internal/application_v31_schema";
+
+export namespace JsonApplicationProgrammer {
+  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;
+  };
+
+  export const write = <Version extends "3.0" | "3.1">(version: Version) =>
+    version === "3.0" ? v30 : v31;
+
+  const v30 = (metadatas: Array<Metadata>): IJsonApplication<"3.0"> => {
+    const components: OpenApiV3.IComponents = {};
+    const generator = (meta: Metadata): OpenApiV3.IJsonSchema | null =>
+      application_v30_schema(true)(components)({})(meta);
+    return {
+      version: "3.0",
+      components,
+      schemas: metadatas.map((meta, i) => {
+        const schema: OpenApiV3.IJsonSchema | null = generator(meta);
+        if (schema === null)
+          throw new TransformerError({
+            code: "typia.json.application",
+            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+          });
+        return schema;
+      }),
+    };
+  };
+
+  const v31 = (metadatas: Array<Metadata>): IJsonApplication<"3.1"> => {
+    const components: OpenApi.IComponents = {
+      schemas: {},
+    };
+    const generator = (meta: Metadata): OpenApi.IJsonSchema | null =>
+      application_v31_schema(true)(components)({})(meta);
+    return {
+      version: "3.1",
+      components,
+      schemas: metadatas.map((meta, i) => {
+        const schema: OpenApi.IJsonSchema | null = generator(meta);
+        if (schema === null)
+          throw new TransformerError({
+            code: "typia.json.application",
+            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+          });
+        return schema;
+      }),
+    };
+  };
+}

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,81 +1,96 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-
-export namespace JsonAssertParseProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction => {
-      JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
-        project.checker,
-        project.context,
-      )(type);
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Primitive"),
-          [
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ],
-          false,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          ts.factory.createExpressionStatement(
-            ts.factory.createBinaryExpression(
-              ts.factory.createIdentifier("input"),
-              ts.SyntaxKind.EqualsToken,
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("JSON.parse"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [
-                  ts.factory.createIdentifier("input"),
-                  AssertProgrammer.Guardian.identifier(),
-                ],
-              ),
-              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 { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+
+export namespace JsonAssertParseProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      equals: false,
+      guard: false,
+    });
+    return {
+      functions: assert.functions,
+      statements: [
+        ...assert.statements,
+        StatementFactory.constant("__assert", assert.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
+          AssertProgrammer.Guardian.parameter(props.init),
+        ],
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Primitive"),
+          [
+            ts.factory.createTypeReferenceNode(
+              props.name ??
+                TypeFactory.getFullName(props.project.checker)(props.type),
+            ),
+          ],
+          false,
+        ),
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("JSON.parse"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            AssertProgrammer.Guardian.identifier(),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        importer,
+        type,
+        name,
+        init,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -1,67 +1,104 @@
-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 { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonAssertStringifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression) =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(init),
-        ],
-        TypeFactory.keyword("string"),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: true,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            JsonStringifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("assert"),
-                  undefined,
-                  [
-                    ts.factory.createIdentifier("input"),
-                    AssertProgrammer.Guardian.identifier(),
-                  ],
-                ),
-              ],
-            ),
-          ),
-        ]),
-      );
-}
+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 { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonAssertStringifyProgrammer {
+  export const decompose = (props: {
+    project: IProject;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+    init: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      project: {
+        ...props.project,
+        options: {
+          ...props.project.options,
+          functional: false,
+          numeric: true,
+        },
+      },
+      equals: false,
+      guard: false,
+    });
+    const stringify: FeatureProgrammer.IDecomposed =
+      JsonStringifyProgrammer.decompose({
+        ...props,
+        validated: true,
+      });
+    return {
+      functions: {
+        ...assert.functions,
+        ...stringify.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...stringify.statements,
+        StatementFactory.constant("__assert", assert.arrow),
+        StatementFactory.constant("__stringify", stringify.arrow),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(props.init),
+        ],
+        stringify.arrow.type,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createExpressionStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__assert"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("input"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__stringify"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const result: FeatureProgrammer.IDecomposed = decompose({
+        project,
+        importer,
+        type,
+        name,
+        init,
+      });
+      return FeatureProgrammer.writeDecomposed({
+        modulo,
+        importer,
+        result,
+      });
+    };
+}