typia 3.5.8 → 3.6.0-dev.20230225

package/src/programmers/ApplicationProgrammer.ts

@@ -1,55 +1,55 @@
-import { Metadata } from "../metadata/Metadata";
-import { IJsonApplication } from "../schemas/IJsonApplication";
-import { IJsonComponents } from "../schemas/IJsonComponents";
-import { IJsonSchema } from "../schemas/IJsonSchema";
-
-import { application_schema } from "./internal/application_schema";
-
-export namespace ApplicationProgrammer {
-    export const AJV_PREFIX = "components#/schemas";
-    export const SWAGGER_PREFIX = "#/components/schemas";
-
-    export interface IOptions {
-        purpose: "swagger" | "ajv";
-        prefix: string;
-    }
-
-    /**
-     * @internal
-     */
-    export namespace IOptions {
-        export function complement(options?: Partial<IOptions>): IOptions {
-            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
-            return {
-                purpose,
-                prefix:
-                    options?.prefix ||
-                    (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
-            };
-        }
-    }
-
-    export function generate(
-        metadatas: Array<Metadata>,
-        options?: Partial<IOptions>,
-    ): IJsonApplication {
-        const fullOptions: IOptions = IOptions.complement(options);
-        const components: IJsonComponents = {
-            schemas: {},
-        };
-        const generator = application_schema(fullOptions)(components)(true);
-
-        return {
-            schemas: metadatas.map((meta, i) => {
-                const schema: IJsonSchema | null = generator(meta, {});
-                if (schema === null)
-                    throw new Error(
-                        `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                    );
-                return schema;
-            }),
-            components,
-            ...fullOptions,
-        };
-    }
-}
+import { Metadata } from "../metadata/Metadata";
+import { IJsonApplication } from "../schemas/IJsonApplication";
+import { IJsonComponents } from "../schemas/IJsonComponents";
+import { IJsonSchema } from "../schemas/IJsonSchema";
+
+import { application_schema } from "./internal/application_schema";
+
+export namespace ApplicationProgrammer {
+    export const AJV_PREFIX = "components#/schemas";
+    export const SWAGGER_PREFIX = "#/components/schemas";
+
+    export interface IOptions {
+        purpose: "swagger" | "ajv";
+        prefix: string;
+    }
+
+    /**
+     * @internal
+     */
+    export namespace IOptions {
+        export function complement(options?: Partial<IOptions>): IOptions {
+            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
+            return {
+                purpose,
+                prefix:
+                    options?.prefix ||
+                    (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
+            };
+        }
+    }
+
+    export function generate(
+        metadatas: Array<Metadata>,
+        options?: Partial<IOptions>,
+    ): IJsonApplication {
+        const fullOptions: IOptions = IOptions.complement(options);
+        const components: IJsonComponents = {
+            schemas: {},
+        };
+        const generator = application_schema(fullOptions)(components)(true);
+
+        return {
+            schemas: metadatas.map((meta, i) => {
+                const schema: IJsonSchema | null = generator(meta, {});
+                if (schema === null)
+                    throw new Error(
+                        `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
+                    );
+                return schema;
+            }),
+            components,
+            ...fullOptions,
+        };
+    }
+}

package/src/programmers/AssertCloneProgrammer.ts

@@ -1,60 +1,71 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { AssertProgrammer } from "./AssertProgrammer";
-import { CloneProgrammer } from "./CloneProgrammer";
-
-export namespace AssertCloneProgrammer {
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
-                    ),
-                    StatementFactory.constant(
-                        "clone",
-                        CloneProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
-                            },
-                            modulo,
-                        )(type),
-                    ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("assert"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("clone"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+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 { CloneProgrammer } from "./CloneProgrammer";
+
+export namespace AssertCloneProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.Primitive<${TypeFactory.getFullName(
+                        project.checker,
+                        type,
+                    )}>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.generate(project, modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "clone",
+                        CloneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("assert"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("clone"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/AssertParseProgrammer.ts

@@ -1,55 +1,66 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { AssertProgrammer } from "./AssertProgrammer";
-
-export namespace AssertParseProgrammer {
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
-                            },
-                            modulo,
-                        )(type),
-                    ),
-                    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.createCallExpression(
-                            ts.factory.createIdentifier("assert"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                ]),
-            );
-}
+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";
+
+export namespace AssertParseProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("string"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.Primitive<${TypeFactory.getFullName(
+                        project.checker,
+                        type,
+                    )}>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    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.createCallExpression(
+                            ts.factory.createIdentifier("assert"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                ]),
+            );
+}