typia 3.5.0-dev.20230212 → 3.5.0-dev.20230214

package/src/programmers/RandomProgrammer.ts

@@ -0,0 +1,367 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TemplateFactory } from "../factories/TemplateFactory";
+
+import { IMetadataTag } from "../metadata/IMetadataTag";
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { RandomJoiner } from "./helpers/RandomJoiner";
+import { RandomRanger } from "./helpers/RandomRanger";
+
+export namespace RandomProgrammer {
+    export function generate(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+    ) {
+        const importer: FunctionImporter = new FunctionImporter();
+        return (type: ts.Type) => {
+            // INITIALIZE METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const meta: Metadata = MetadataFactory.generate(
+                project.checker,
+                collection,
+                type,
+                {
+                    resolve: true,
+                    constant: true,
+                },
+            );
+
+            // GENERATE FUNCTION
+            const functors: ts.VariableStatement[] =
+                generate_functors(importer)(collection);
+            const output: ts.Expression = decode(importer)({
+                object: false,
+                recursive: false,
+            })(meta, []);
+
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "generator",
+                        IdentifierFactory.join(modulo, "generator"),
+                    ),
+                ],
+                undefined,
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        ...importer.declare(modulo),
+                        ...functors,
+                        ts.factory.createReturnStatement(output),
+                    ],
+                    true,
+                ),
+            );
+        };
+    }
+
+    const generate_functors =
+        (importer: FunctionImporter) => (collection: MetadataCollection) =>
+            collection.objects().map((obj, i) =>
+                StatementFactory.constant(
+                    FUNCTOR(i),
+                    ts.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [
+                            IdentifierFactory.parameter(
+                                "recursive",
+                                ts.factory.createIdentifier(
+                                    String(obj.recursive),
+                                ),
+                            ),
+                            IdentifierFactory.parameter(
+                                "depth",
+                                ts.factory.createNumericLiteral(0),
+                            ),
+                        ],
+                        undefined,
+                        undefined,
+                        RandomJoiner.object(
+                            decode(importer)({
+                                recursive: obj.recursive,
+                                object: true,
+                            }),
+                        )(obj),
+                    ),
+                ),
+            );
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    const decode =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (meta: Metadata, tags: IMetadataTag[]): ts.Expression => {
+            const expressions: ts.Expression[] = [];
+            if (meta.any)
+                expressions.push(
+                    ts.factory.createStringLiteral(
+                        "fucking any type exists...",
+                    ),
+                );
+
+            // NULL COALESCING
+            if (meta.required === false)
+                expressions.push(ts.factory.createIdentifier("undefined"));
+            if (meta.nullable === true)
+                expressions.push(ts.factory.createNull());
+
+            // ATOMIC TYPES
+            for (const constant of meta.constants)
+                for (const value of constant.values)
+                    expressions.push(decode_atomic(value));
+            for (const template of meta.templates)
+                expressions.push(decode_template(importer)(explore)(template));
+            for (const atomic of meta.atomics)
+                if (atomic === "boolean") expressions.push(decode_boolean());
+                else if (atomic === "number")
+                    expressions.push(decode_number(tags));
+                else if (atomic === "string")
+                    expressions.push(decode_string(importer)(tags));
+                else if (atomic === "bigint")
+                    expressions.push(decode_bigint(tags));
+
+            // INSTANCE TYPES
+            if (meta.resolved)
+                expressions.push(
+                    decode(importer)(explore)(meta.resolved, tags),
+                );
+            for (const t of meta.tuples)
+                expressions.push(
+                    RandomJoiner.tuple(decode(importer)(explore))(t, tags),
+                );
+            for (const a of meta.arrays) {
+                const array = RandomJoiner.array(decode(importer)(explore))(
+                    a,
+                    tags,
+                );
+                expressions.push(
+                    explore.recursive && a.objects.length
+                        ? ts.factory.createConditionalExpression(
+                              ts.factory.createLogicalAnd(
+                                  ts.factory.createIdentifier("recursive"),
+                                  ts.factory.createLessThan(
+                                      ts.factory.createNumericLiteral(5),
+                                      ts.factory.createIdentifier("depth"),
+                                  ),
+                              ),
+                              undefined,
+                              ts.factory.createIdentifier("[]"),
+                              undefined,
+                              array,
+                          )
+                        : array,
+                );
+            }
+            for (const o of meta.objects)
+                expressions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(FUNCTOR(o.index)),
+                        undefined,
+                        explore.object
+                            ? [
+                                  explore.recursive
+                                      ? ts.factory.createTrue()
+                                      : ts.factory.createIdentifier(
+                                            "recursive",
+                                        ),
+                                  ts.factory.createConditionalExpression(
+                                      ts.factory.createIdentifier("recursive"),
+                                      undefined,
+                                      ts.factory.createAdd(
+                                          ts.factory.createNumericLiteral(1),
+                                          ts.factory.createIdentifier("depth"),
+                                      ),
+                                      undefined,
+                                      ts.factory.createIdentifier("depth"),
+                                  ),
+                              ]
+                            : undefined,
+                    ),
+                );
+            for (const native of meta.natives)
+                if (native === "Boolean") expressions.push(decode_boolean());
+                else if (native === "Number")
+                    expressions.push(decode_number(tags));
+                else if (native === "String")
+                    expressions.push(decode_string(importer)(tags));
+                else expressions.push(ts.factory.createIdentifier("{}"));
+            if (meta.sets.length || meta.maps.length)
+                expressions.push(ts.factory.createIdentifier("{}"));
+
+            // PRIMITIVE TYPES
+            if (expressions.length === 1) return expressions[0]!;
+            return ts.factory.createCallExpression(
+                ts.factory.createCallExpression(
+                    importer.use("pick"),
+                    undefined,
+                    [
+                        ts.factory.createArrayLiteralExpression(
+                            expressions.map((expr) =>
+                                ts.factory.createArrowFunction(
+                                    undefined,
+                                    undefined,
+                                    [],
+                                    undefined,
+                                    undefined,
+                                    expr,
+                                ),
+                            ),
+                            true,
+                        ),
+                    ],
+                ),
+                undefined,
+                undefined,
+            );
+        };
+
+    const decode_boolean = () =>
+        ts.factory.createLessThan(
+            ts.factory.createNumericLiteral(0.5),
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Math.random"),
+                undefined,
+                undefined,
+            ),
+        );
+
+    const decode_atomic = (value: Atomic) =>
+        typeof value === "boolean"
+            ? ts.factory.createIdentifier(value.toString())
+            : typeof value === "number"
+            ? ts.factory.createNumericLiteral(value)
+            : typeof value === "string"
+            ? ts.factory.createStringLiteral(value)
+            : ts.factory.createBigIntLiteral(value.toString());
+
+    const decode_template =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (template: Metadata[]) =>
+            TemplateFactory.generate(
+                template.map((meta) => decode(importer)(explore)(meta, [])),
+            );
+
+    const decode_number = (tags: IMetadataTag[]): ts.Expression => {
+        const type = tags.find((t) => t.kind === "type" && t.value === "uint")
+            ? "int"
+            : tags.find((t) => t.kind === "type" && t.value === "int")
+            ? "uint"
+            : "double";
+        return RandomRanger.number({
+            type,
+            transform: (value) => ts.factory.createNumericLiteral(value),
+            setter: (args) =>
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        type === "double" &&
+                            tags.every(
+                                (t) =>
+                                    t.kind !== "multipleOf" &&
+                                    t.kind !== "step",
+                            )
+                            ? "generator.number"
+                            : "generator.integer",
+                    ),
+                    undefined,
+                    args.map((val) => ts.factory.createNumericLiteral(val)),
+                ),
+        })({
+            minimum: 0,
+            maximum: 100,
+            gap: 10,
+        })(tags);
+    };
+
+    const decode_bigint = (tags: IMetadataTag[]): ts.Expression =>
+        RandomRanger.number({
+            type: tags.find((t) => t.kind === "type" && t.value === "uint")
+                ? "uint"
+                : "int",
+            transform: (value) =>
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("BigInt"),
+                    undefined,
+                    [ts.factory.createStringLiteral(value.toString())],
+                ),
+            setter: (args) =>
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("generator.bigint"),
+                    undefined,
+                    args.map((value) =>
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("BigInt"),
+                            undefined,
+                            [ts.factory.createStringLiteral(value.toString())],
+                        ),
+                    ),
+                ),
+        })({
+            minimum: 0,
+            maximum: 100,
+            gap: 10,
+        })(tags);
+
+    const decode_string =
+        (importer: FunctionImporter) =>
+        (tags: IMetadataTag[]): ts.Expression => {
+            for (const t of tags)
+                if (
+                    t.kind === "format" &&
+                    ["uuid", "email", "url", "ipv4", "ipv6"].includes(t.value)
+                )
+                    return ts.factory.createCallExpression(
+                        COALESCE(importer)(t.value),
+                        undefined,
+                        undefined,
+                    );
+                else if (t.kind === "pattern")
+                    return ts.factory.createCallExpression(
+                        COALESCE(importer)("pattern"),
+                        undefined,
+                        [ts.factory.createIdentifier(`/${t.value}/`)],
+                    );
+
+            const tail = RandomRanger.length({
+                minimum: 5,
+                maximum: 25,
+                gap: 5,
+            })({
+                fixed: "length",
+                minimum: "minLength",
+                maximum: "maxLength",
+            })(tags);
+            return ts.factory.createCallExpression(
+                ts.factory.createIdentifier("generator.string"),
+                undefined,
+                tail ? [tail] : undefined,
+            );
+        };
+}
+
+type Atomic = boolean | number | string | bigint;
+interface IExplore {
+    object: boolean;
+    recursive: boolean;
+}
+
+const FUNCTOR = (i: number) => `$ro${i}`;
+const COALESCE = (importer: FunctionImporter) => (name: string) =>
+    ExpressionFactory.coalesce(
+        ts.factory.createIdentifier(`generator.${name}`),
+        IdentifierFactory.join(importer.use("generator"), name),
+    );

package/src/programmers/StringifyProgrammer.ts

@@ -135,7 +135,7 @@ export namespace StringifyProgrammer {
                 else
                     unions.push({
                         type: "resolved",
-                        is: () => IsProgrammer.decode_to_json(input),
+                        is: () => IsProgrammer.decode_to_json(input, false),
                         value: () =>
                             decode_to_json(project, importer)(
                                 input,
@@ -374,9 +374,7 @@ export namespace StringifyProgrammer {
                                           decoder: decode(project, importer),
                                           trace: false,
                                           path: false,
-                                      })(obj)(
-                                          input,
-                                      );
+                                      })(obj)(input);
                                   return StringifyJoiner.object(importer)(
                                       input,
                                       entries,

package/src/programmers/ValidateCloneProgrammer.ts

@@ -0,0 +1,77 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { CloneProgrammer } from "./CloneProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidateCloneProgrammer {
+    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,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "clone",
+                        CloneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        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("clone"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -56,10 +56,7 @@ export namespace ValidateStringifyProgrammer {
                         ),
                     ),
                     ts.factory.createIfStatement(
-                        ts.factory.createStrictEquality(
-                            ts.factory.createTrue(),
-                            ts.factory.createIdentifier("output.success"),
-                        ),
+                        ts.factory.createIdentifier("output.success"),
                         ts.factory.createExpressionStatement(
                             ts.factory.createBinaryExpression(
                                 ts.factory.createIdentifier("output.data"),

package/src/programmers/helpers/CloneJoiner.ts

@@ -0,0 +1,124 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace CloneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry<ts.Expression>[],
+        _obj: MetadataObject,
+    ): ts.ConciseBody => {
+        if (entries.length === 0) return ts.factory.createIdentifier("{}");
+
+        const regular = entries.filter((e) => e.key.isSoleLiteral());
+        const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+        const literal = ts.factory.createObjectLiteralExpression(
+            regular.map((entry) => {
+                const str: string = entry.key.getSoleLiteral()!;
+                return ts.factory.createPropertyAssignment(
+                    Escaper.variable(str)
+                        ? str
+                        : ts.factory.createStringLiteral(str),
+                    entry.expression,
+                );
+            }),
+            true,
+        );
+        if (dynamic.length === 0) return literal;
+
+        const key = ts.factory.createIdentifier("key");
+        const value = ts.factory.createIdentifier("value");
+        const output = ts.factory.createIdentifier("output");
+
+        const statements: ts.Statement[] = dynamic.map((entry) =>
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [key],
+                ),
+                ts.factory.createBlock([
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createElementAccessExpression(
+                                output,
+                                key,
+                            ),
+                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                            entry.expression,
+                        ),
+                    ),
+                    ts.factory.createContinueStatement(),
+                ]),
+            ),
+        );
+
+        return ts.factory.createBlock([
+            StatementFactory.constant("output", literal),
+            ts.factory.createForOfStatement(
+                undefined,
+                ts.factory.createVariableDeclarationList(
+                    [
+                        ts.factory.createVariableDeclaration(
+                            ts.factory.createArrayBindingPattern([
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    key,
+                                    undefined,
+                                ),
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    value,
+                                    undefined,
+                                ),
+                            ]),
+                            undefined,
+                            undefined,
+                            undefined,
+                        ),
+                    ],
+                    ts.NodeFlags.Const,
+                ),
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [input],
+                ),
+                ts.factory.createBlock(statements),
+            ),
+            ts.factory.createReturnStatement(output),
+        ]);
+    };
+
+    export const tuple = (
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression => {
+        if (rest === null)
+            return ts.factory.createArrayLiteralExpression(children, true);
+        return ts.factory.createArrayLiteralExpression(
+            [...children, ts.factory.createSpreadElement(rest)],
+            true,
+        );
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.Expression) =>
+        ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(input, "map"),
+            undefined,
+            [arrow],
+        );
+}