typia 3.3.12 → 3.4.0-dev.20221212

package/src/programmers/ValidateParseProgrammer.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidateParseProgrammer {
+    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(
+                        "validate",
+                        ValidateProgrammer.generate(project, 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")],
+                            ),
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/ValidateProgrammer.ts

@@ -0,0 +1,236 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { check_everything } from "./internal/check_everything";
+import { check_object } from "./internal/check_object";
+
+export namespace ValidateProgrammer {
+    export const generate =
+        (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            equals: boolean = false,
+        ) =>
+        (type: ts.Type) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            const program: ts.ArrowFunction = CheckerProgrammer.generate(
+                project,
+                {
+                    functors: "$vo",
+                    unioners: "$vu",
+                    path: true,
+                    trace: true,
+                    numeric: !!project.options.numeric,
+                    equals,
+                    combiner: combine(equals)(importer),
+                    joiner: joiner(equals)(importer),
+                    success: ts.factory.createTrue(),
+                },
+                importer,
+            )(type);
+
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        StatementFactory.constant(
+                            "errors",
+                            ts.factory.createArrayLiteralExpression([]),
+                        ),
+                        StatementFactory.constant(
+                            "$report",
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.join(modulo, "report"),
+                                [],
+                                [ts.factory.createIdentifier("errors")],
+                            ),
+                        ),
+                        ...importer.declare(modulo),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                program,
+                                undefined,
+                                [
+                                    ts.factory.createIdentifier("input"),
+                                    ts.factory.createStringLiteral("$input"),
+                                    ts.factory.createTrue(),
+                                ],
+                            ),
+                        ),
+                        StatementFactory.constant(
+                            "success",
+                            ts.factory.createStrictEquality(
+                                ts.factory.createNumericLiteral(0),
+                                ts.factory.createIdentifier("errors.length"),
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(create_output()),
+                    ],
+                    true,
+                ),
+            );
+        };
+}
+
+const combine =
+    (equals: boolean) =>
+    (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
+    (explore: CheckerProgrammer.IExplore) => {
+        if (explore.tracable === false && explore.from !== "top")
+            return IsProgrammer.CONFIG({
+                object: validate_object(equals)(importer),
+                numeric: true,
+            }).combiner(explore);
+
+        const path: string = explore.postfix
+            ? `path + ${explore.postfix}`
+            : "path";
+        return (logic) => (input, binaries, expected) =>
+            logic === "and"
+                ? binaries
+                      .map((binary) =>
+                          binary.combined
+                              ? binary.expression
+                              : ts.factory.createLogicalOr(
+                                    binary.expression,
+                                    create_report_call(
+                                        explore.source === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(path),
+                                        expected,
+                                        input,
+                                    ),
+                                ),
+                      )
+                      .reduce(ts.factory.createLogicalAnd)
+                : ts.factory.createLogicalOr(
+                      binaries
+                          .map((binary) => binary.expression)
+                          .reduce(ts.factory.createLogicalOr),
+                      create_report_call(
+                          explore.source === "top"
+                              ? ts.factory.createTrue()
+                              : ts.factory.createIdentifier("exceptionable"),
+                      )(ts.factory.createIdentifier(path), expected, input),
+                  );
+    };
+
+const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
+    check_object({
+        equals,
+        assert: false,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (value) =>
+            create_report_call()(
+                ts.factory.createAdd(
+                    ts.factory.createIdentifier("path"),
+                    ts.factory.createCallExpression(
+                        importer.use("join"),
+                        undefined,
+                        [ts.factory.createIdentifier("key")],
+                    ),
+                ),
+                "undefined",
+                value,
+            ),
+        halt: (expr) =>
+            ts.factory.createLogicalOr(
+                ts.factory.createStrictEquality(
+                    ts.factory.createFalse(),
+                    ts.factory.createIdentifier("exceptionable"),
+                ),
+                expr,
+            ),
+    });
+
+const joiner =
+    (equals: boolean) =>
+    (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
+        object: validate_object(equals)(importer),
+        array: (input, arrow) =>
+            check_everything(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(input, "map"),
+                    undefined,
+                    [arrow],
+                ),
+            ),
+        failure: (value, expected, explore) =>
+            create_report_call(
+                explore?.from === "top"
+                    ? ts.factory.createTrue()
+                    : ts.factory.createIdentifier("exceptionable"),
+            )(
+                ts.factory.createIdentifier(
+                    explore?.postfix ? `path + ${explore.postfix}` : "path",
+                ),
+                expected,
+                value,
+            ),
+        tuple: (binaries) =>
+            check_everything(
+                ts.factory.createArrayLiteralExpression(binaries, true),
+            ),
+    });
+
+function create_output() {
+    return ts.factory.createObjectLiteralExpression(
+        [
+            ts.factory.createShorthandPropertyAssignment("success"),
+            ts.factory.createShorthandPropertyAssignment("errors"),
+            ts.factory.createPropertyAssignment(
+                "data",
+                ts.factory.createConditionalExpression(
+                    ts.factory.createIdentifier("success"),
+                    undefined,
+                    ts.factory.createIdentifier("input"),
+                    undefined,
+                    ts.factory.createIdentifier("undefined"),
+                ),
+            ),
+        ],
+        true,
+    );
+}
+
+const create_report_call =
+    (exceptionable?: ts.Expression) =>
+    (
+        path: ts.Expression,
+        expected: string,
+        value: ts.Expression,
+    ): ts.Expression =>
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("$report"),
+            undefined,
+            [
+                exceptionable || ts.factory.createIdentifier("exceptionable"),
+                ts.factory.createObjectLiteralExpression(
+                    [
+                        ts.factory.createPropertyAssignment("path", path),
+                        ts.factory.createPropertyAssignment(
+                            "expected",
+                            ts.factory.createStringLiteral(expected),
+                        ),
+                        ts.factory.createPropertyAssignment("value", value),
+                    ],
+                    true,
+                ),
+            ],
+        );

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -0,0 +1,60 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { StringifyProgrammer } from "./StringifyProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidateStringifyProgrammer {
+    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(
+                        "validate",
+                        ValidateProgrammer.generate(project, modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "stringify",
+                        StringifyProgrammer.generate(project, modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createTrue(),
+                            ts.factory.createIdentifier("output.success"),
+                        ),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createIdentifier("output.data"),
+                                ts.SyntaxKind.EqualsToken,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("stringify"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/helpers/AtomicPredicator.ts

@@ -0,0 +1,15 @@
+import { Metadata } from "../../metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (type) => type === "string");
+}

package/src/programmers/helpers/FunctionImporeter.ts

@@ -0,0 +1,31 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+export class FunctionImporter {
+    private readonly used_: Set<string> = new Set();
+    private sequence_: number = 0;
+
+    public empty(): boolean {
+        return this.used_.size === 0;
+    }
+
+    public use(name: string): ts.Identifier {
+        this.used_.add(name);
+        return ts.factory.createIdentifier("$" + name);
+    }
+
+    public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
+        return [...this.used_].map((name) =>
+            StatementFactory.constant(
+                "$" + name,
+                IdentifierFactory.join(modulo, name),
+            ),
+        );
+    }
+
+    public increment(): number {
+        return ++this.sequence_;
+    }
+}

package/src/programmers/helpers/IExpressionEntry.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+export interface IExpressionEntry {
+    input: ts.Expression;
+    key: Metadata;
+    meta: Metadata;
+    expression: ts.Expression;
+}

package/src/programmers/helpers/OptionPredicator.ts

@@ -0,0 +1,18 @@
+import { ITransformOptions } from "../../transformers/ITransformOptions";
+
+export namespace OptionPredicator {
+    export function functional(options: ITransformOptions): boolean {
+        return options.functional !== false;
+    }
+
+    export function numeric(
+        options: ITransformOptions,
+        from: "checker" | "stringify",
+    ): boolean {
+        return (
+            options.numeric === undefined ||
+            options.numeric === true ||
+            options.numeric === from
+        );
+    }
+}

package/src/programmers/helpers/StringifyJoinder.ts

@@ -0,0 +1,111 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { stringify_dynamic_properties } from "../internal/stringify_dynamic_properties";
+import { stringify_regular_properties } from "../internal/stringify_regular_properties";
+import { FunctionImporter } from "./FunctionImporeter";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace StringifyJoiner {
+    export const object =
+        (importer: FunctionImporter) =>
+        (entries: IExpressionEntry[]): ts.Expression => {
+            // CHECK AND SORT ENTRIES
+            const regular: IExpressionEntry[] = entries.filter((entry) =>
+                entry.key.isSoleLiteral(),
+            );
+            const dynamic: IExpressionEntry[] = entries.filter(
+                (entry) => !entry.key.isSoleLiteral(),
+            );
+            if (regular.length === 0 && dynamic.length === 0)
+                return ts.factory.createStringLiteral("{}");
+
+            // PROPERTIES
+            const expressions: ts.Expression[] = [
+                ...stringify_regular_properties(regular, dynamic),
+                ...(dynamic.length
+                    ? [
+                          stringify_dynamic_properties(
+                              dynamic,
+                              regular.map((r) => r.key.getSoleLiteral()!),
+                          ),
+                      ]
+                    : []),
+            ];
+
+            // POP LAST COMMA, IF REQUIRED
+            const filtered: ts.Expression[] =
+                (regular.length &&
+                    regular[regular.length - 1]!.meta.required &&
+                    dynamic.length === 0) ||
+                (regular.length === 0 && dynamic.length)
+                    ? expressions
+                    : [
+                          ts.factory.createCallExpression(
+                              importer.use("tail"),
+                              undefined,
+                              [TemplateFactory.generate(expressions)],
+                          ),
+                      ];
+
+            // RETURNS WITH OBJECT BRACKET
+            return TemplateFactory.generate([
+                ts.factory.createStringLiteral(`{`),
+                ...filtered,
+                ts.factory.createStringLiteral(`}`),
+            ]);
+        };
+
+    export function array(
+        input: ts.Expression,
+        arrow: ts.ArrowFunction,
+    ): ts.Expression {
+        return TemplateFactory.generate([
+            ts.factory.createStringLiteral(`[`),
+            ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(input, "map"),
+                        undefined,
+                        [arrow],
+                    ),
+                    ts.factory.createIdentifier("join"),
+                ),
+                undefined,
+                [ts.factory.createStringLiteral(`,`)],
+            ),
+            ts.factory.createStringLiteral(`]`),
+        ]);
+    }
+
+    export function tuple(
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression {
+        if (children.length === 0) return ts.factory.createStringLiteral("[]");
+        if (
+            rest === null &&
+            children.every((child) => ts.isStringLiteral(child))
+        )
+            return ts.factory.createStringLiteral(
+                "[" +
+                    children
+                        .map((child) => (child as ts.StringLiteral).text)
+                        .join(",") +
+                    "]",
+            );
+
+        const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
+        children.forEach((child, i) => {
+            elements.push(child);
+            if (i !== children.length - 1)
+                elements.push(ts.factory.createStringLiteral(`,`));
+        });
+        if (rest !== null) elements.push(rest);
+
+        elements.push(ts.factory.createStringLiteral(`]`));
+        return TemplateFactory.generate(elements);
+    }
+}

package/src/programmers/helpers/StringifyPredicator.ts

@@ -0,0 +1,18 @@
+import { Metadata } from "../../metadata/Metadata";
+
+export namespace StringifyPredicator {
+    export function require_escape(value: string): boolean {
+        return value
+            .split("")
+            .some((ch) => ESCAPED.some((escaped) => escaped === ch));
+    }
+
+    export function undefindable(meta: Metadata): boolean {
+        return (
+            meta.required === false ||
+            (meta.resolved !== null && meta.resolved.required === false)
+        );
+    }
+
+    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+}