typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -1,49 +1,82 @@
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
 import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { TransformerError } from "../../transformers/TransformerError";
 
-import { application_schema } from "../internal/application_schema";
+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 interface IOptions {
-    purpose: "ajv" | "swagger";
-    surplus: boolean;
-  }
+  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;
+  };
 
-  /**
-   * @internal
-   */
-  export namespace IOptions {
-    export const complement = (options?: Partial<IOptions>): IOptions => ({
-      purpose: options?.purpose ?? "swagger",
-      surplus: options?.surplus ?? false,
-    });
-  }
+  export const write = <Version extends "3.0" | "3.1">(version: Version) =>
+    version === "3.0" ? v30 : v31;
 
-  export const write =
-    (options?: Partial<IOptions>) =>
-    (metadatas: Array<Metadata>): IJsonApplication => {
-      const fullOptions: IOptions = IOptions.complement(options);
-      const components: IJsonComponents = {
-        schemas: {},
-      };
-      const generator = application_schema(fullOptions)(true)(components);
+  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;
+      }),
+    };
+  };
 
-      return {
-        schemas: metadatas.map((meta, i) => {
-          const schema: IJsonSchema | null = generator(meta)({});
-          if (schema === null)
-            throw new TransformerError({
-              code: "typia.json.application",
-              message: `invalid type on argument - (${meta.getName()}, ${i})`,
-            });
-          return schema;
-        }),
-        components,
-        ...fullOptions,
-      };
+  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

@@ -13,7 +13,7 @@ export namespace JsonAssertParseProgrammer {
   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 => {
       JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
         project.checker,
         project.context,
@@ -21,11 +21,22 @@ export namespace JsonAssertParseProgrammer {
       return ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.Primitive<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        [
+          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([
@@ -56,7 +67,10 @@ export namespace JsonAssertParseProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("input")],
+                [
+                  ts.factory.createIdentifier("input"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               ts.factory.createTypeReferenceNode("any"),
             ),

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -13,11 +13,14 @@ export namespace JsonAssertStringifyProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         TypeFactory.keyword("string"),
         undefined,
         ts.factory.createBlock([
@@ -51,7 +54,10 @@ export namespace JsonAssertStringifyProgrammer {
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("assert"),
                   undefined,
-                  [ts.factory.createIdentifier("input")],
+                  [
+                    ts.factory.createIdentifier("input"),
+                    AssertProgrammer.Guardian.identifier(),
+                  ],
                 ),
               ],
             ),

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -22,10 +22,18 @@ export namespace JsonIsParseProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.Primitive<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        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([

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -37,9 +37,8 @@ import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
 
 export namespace JsonStringifyProgrammer {
   /* -----------------------------------------------------------
-        WRITER
-    ----------------------------------------------------------- */
-
+    WRITER
+  ----------------------------------------------------------- */
   export const write =
     (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
       const importer: FunctionImporter = new FunctionImporter(modulo.getText());
@@ -51,7 +50,7 @@ export namespace JsonStringifyProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(),
+          ...importer.declare(modulo),
         ],
       })(importer);
     };
@@ -125,8 +124,8 @@ export namespace JsonStringifyProgrammer {
         );
 
   /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
+    DECODERS
+  ----------------------------------------------------------- */
   const decode =
     (project: IProject) =>
     (config: FeatureProgrammer.IConfig) =>
@@ -188,7 +187,11 @@ export namespace JsonStringifyProgrammer {
       if (meta.escaped !== null)
         unions.push({
           type: "resolved",
-          is: () => IsProgrammer.decode_to_json(false)(input),
+          is:
+            meta.escaped.original.size() === 1 &&
+            meta.escaped.original.natives[0] === "Date"
+              ? () => check_native("Date")(input)
+              : () => IsProgrammer.decode_to_json(false)(input),
           value: () =>
             decode_to_json(project)(config)(importer)(
               input,
@@ -267,7 +270,7 @@ export namespace JsonStringifyProgrammer {
             value: () =>
               decode_constant_string(project)(importer)(
                 input,
-                [...constant.values] as string[],
+                [...constant.values.map((v) => v.value)] as string[],
                 explore,
               ),
           });
@@ -319,17 +322,21 @@ export namespace JsonStringifyProgrammer {
                   from: "array",
                 })
             : meta.arrays.some((elem) => elem.type.value.any)
-            ? () =>
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("JSON.stringify"),
-                  undefined,
-                  [input],
-                )
-            : () =>
-                explore_arrays(project)(config)(importer)(input, meta.arrays, {
-                  ...explore,
-                  from: "array",
-                });
+              ? () =>
+                  ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("JSON.stringify"),
+                    undefined,
+                    [input],
+                  )
+              : () =>
+                  explore_arrays(project)(config)(importer)(
+                    input,
+                    meta.arrays,
+                    {
+                      ...explore,
+                      from: "array",
+                    },
+                  );
 
         unions.push({
           type: "array",
@@ -640,8 +647,8 @@ export namespace JsonStringifyProgrammer {
       : ts.factory.createIdentifier("undefined");
 
   /* -----------------------------------------------------------
-        EXPLORERS
-    ----------------------------------------------------------- */
+    EXPLORERS
+  ----------------------------------------------------------- */
   const explore_objects =
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
@@ -736,8 +743,8 @@ export namespace JsonStringifyProgrammer {
     };
 
   /* -----------------------------------------------------------
-        RETURN SCRIPTS
-    ----------------------------------------------------------- */
+    RETURN SCRIPTS
+  ----------------------------------------------------------- */
   const wrap_required = (
     input: ts.Expression,
     meta: Metadata,
@@ -814,8 +821,8 @@ export namespace JsonStringifyProgrammer {
     );
 
   /* -----------------------------------------------------------
-        CONFIGURATIONS
-    ----------------------------------------------------------- */
+    CONFIGURATIONS
+  ----------------------------------------------------------- */
   const PREFIX = "$s";
 
   const configure =
@@ -868,7 +875,7 @@ export namespace JsonStringifyProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws", true),
+          importer.use("throws"),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -13,15 +13,26 @@ export namespace MiscAssertCloneProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          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([
@@ -44,7 +55,10 @@ export namespace MiscAssertCloneProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           StatementFactory.constant(

package/src/programmers/misc/MiscAssertPruneProgrammer.ts

@@ -13,11 +13,14 @@ export namespace MiscAssertPruneProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           name ?? TypeFactory.getFullName(project.checker)(type),
         ),
@@ -42,7 +45,10 @@ export namespace MiscAssertPruneProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           ts.factory.createExpressionStatement(

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -33,7 +33,7 @@ export namespace MiscCloneProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(),
+          ...importer.declare(modulo),
         ],
       })(importer);
     };
@@ -127,11 +127,9 @@ export namespace MiscCloneProgrammer {
             !!t.type.elements.length && t.type.elements.every((e) => e.any),
         )
       )
-        return ts.factory.createCallExpression(
-          importer.use("clone"),
-          undefined,
-          [input],
-        );
+        return ts.factory.createCallExpression(importer.use("any"), undefined, [
+          input,
+        ]);
 
       interface IUnion {
         type: string;
@@ -383,14 +381,14 @@ export namespace MiscCloneProgrammer {
     type === "Float64Array"
       ? decode_native_copyable(type)(input)
       : type === "ArrayBuffer" || type === "SharedArrayBuffer"
-      ? decode_native_buffer(type)(input)
-      : type === "DataView"
-      ? decode_native_data_view(input)
-      : ts.factory.createCallExpression(
-          ts.factory.createIdentifier(type),
-          undefined,
-          [],
-        );
+        ? decode_native_buffer(type)(input)
+        : type === "DataView"
+          ? decode_native_data_view(input)
+          : ts.factory.createCallExpression(
+              ts.factory.createIdentifier(type),
+              undefined,
+              [],
+            );
 
   const decode_native_copyable = (type: string) => (input: ts.Expression) =>
     ts.factory.createNewExpression(
@@ -633,10 +631,18 @@ export namespace MiscCloneProgrammer {
               name ?? TypeFactory.getFullName(project.checker)(type),
             ),
           output: (type, name) =>
-            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,
             ),
         },
         prefix: PREFIX,
@@ -696,7 +702,7 @@ export namespace MiscCloneProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws", true),
+          importer.use("throws"),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -19,10 +19,18 @@ export namespace MiscIsCloneProgrammer {
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
         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()),
         ]),

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -11,8 +11,6 @@ import { TransformerError } from "../../transformers/TransformerError";
 
 import { Atomic } from "../../typings/Atomic";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
 export namespace MiscLiteralsProgrammer {
   export const write = (project: IProject) => (type: ts.Type) => {
     const result = MetadataFactory.analyze(
@@ -38,7 +36,7 @@ export namespace MiscLiteralsProgrammer {
 
     const meta: Metadata = result.data;
     const values: Set<Atomic.Type | null> = new Set([
-      ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
+      ...meta.constants.map((c) => c.values.map((v) => v.value)).flat(),
       ...(meta.atomics.filter((a) => a.type === "boolean").length
         ? [true, false]
         : []),
@@ -50,14 +48,14 @@ export namespace MiscLiteralsProgrammer {
           v === null
             ? ts.factory.createNull()
             : typeof v === "boolean"
-            ? v
-              ? ts.factory.createTrue()
-              : ts.factory.createFalse()
-            : typeof v === "number"
-            ? ExpressionFactory.number(v)
-            : typeof v === "bigint"
-            ? ExpressionFactory.bigint(Number(v))
-            : ts.factory.createStringLiteral(v),
+              ? v
+                ? ts.factory.createTrue()
+                : ts.factory.createFalse()
+              : typeof v === "number"
+                ? ExpressionFactory.number(v)
+                : typeof v === "bigint"
+                  ? ExpressionFactory.bigint(Number(v))
+                  : ts.factory.createStringLiteral(v),
         ),
         true,
       ),

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -33,7 +33,7 @@ export namespace MiscPruneProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(),
+          ...importer.declare(modulo),
         ],
       })(importer);
     };

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -14,11 +14,14 @@ export namespace NotationAssertGeneralProgrammer {
     (rename: (str: string) => string) =>
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode(
           NotationGeneralProgrammer.returnType(rename)(
             name ?? TypeFactory.getFullName(project.checker)(type),
@@ -45,7 +48,10 @@ export namespace NotationAssertGeneralProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier("assert"),
               undefined,
-              [ts.factory.createIdentifier("input")],
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
             ),
           ),
           StatementFactory.constant(