typia 3.3.12 → 3.4.0-dev.20221212

package/src/programmers/internal/check_everything.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+/**
+ * @internal
+ */
+export const check_everything = (array: ts.Expression) =>
+    ts.factory.createCallExpression(
+        IdentifierFactory.join(array, "every"),
+        undefined,
+        [
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("flag")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                    ts.factory.createTrue(),
+                    ts.factory.createIdentifier("flag"),
+                ),
+            ),
+        ],
+    );

package/src/programmers/internal/check_length.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+/**
+ * @internal
+ */
+export function check_length(
+    conditions: ts.Expression[],
+    length: ts.Expression,
+    tag: Omit<IMetadataTag.ILength, "kind">,
+) {
+    if (
+        tag.minimum !== undefined &&
+        tag.maximum !== undefined &&
+        tag.minimum.value === tag.maximum.value &&
+        tag.minimum.include === true &&
+        tag.maximum.include === true
+    ) {
+        conditions.push(
+            ts.factory.createStrictEquality(
+                ts.factory.createNumericLiteral(tag.minimum.value),
+                length,
+            ),
+        );
+    } else {
+        if (tag.minimum !== undefined)
+            conditions.push(
+                (tag.minimum.include
+                    ? ts.factory.createLessThanEquals
+                    : ts.factory.createLessThan)(
+                    ts.factory.createNumericLiteral(tag.minimum.value),
+                    length,
+                ),
+            );
+        if (tag.maximum !== undefined)
+            conditions.push(
+                (tag.maximum.include
+                    ? ts.factory.createGreaterThanEquals
+                    : ts.factory.createGreaterThan)(
+                    ts.factory.createNumericLiteral(tag.maximum.value),
+                    length,
+                ),
+            );
+    }
+}

package/src/programmers/internal/check_native.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+/**
+ * @internal
+ */
+export const check_native = (type: string) => (input: ts.Expression) =>
+    ExpressionFactory.isInstanceOf(input, type);

package/src/programmers/internal/check_number.ts

@@ -0,0 +1,181 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { IProject } from "../../transformers/IProject";
+
+import { OptionPredicator } from "../helpers/OptionPredicator";
+
+/**
+ * @internal
+ */
+export function check_number(project: IProject, numeric: boolean) {
+    return function (input: ts.Expression, tagList: IMetadataTag[]) {
+        // TYPEOF
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("number"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // TAG (RANGE)
+        for (const tag of tagList)
+            if (tag.kind === "type") {
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("parseInt"),
+                            undefined,
+                            [input],
+                        ),
+                        input,
+                    ),
+                );
+                if (tag.value === "uint")
+                    conditions.push(
+                        ts.factory.createLessThanEquals(
+                            ts.factory.createNumericLiteral(0),
+                            input,
+                        ),
+                    );
+            } else if (tag.kind === "multipleOf")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createModulo(
+                            input,
+                            ts.factory.createNumericLiteral(tag.value),
+                        ),
+                    ),
+                );
+            else if (tag.kind === "step") {
+                const modulo = () =>
+                    ts.factory.createModulo(
+                        input,
+                        ts.factory.createNumericLiteral(tag.value),
+                    );
+                const minimum = (() => {
+                    for (const tag of tagList)
+                        if (tag.kind === "minimum") return tag.value;
+                        else if (tag.kind === "exclusiveMinimum")
+                            return tag.value;
+                        else if (
+                            tag.kind === "range" &&
+                            tag.minimum !== undefined
+                        )
+                            return tag.minimum.value;
+                    return undefined;
+                })();
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(
+                                  modulo(),
+                                  ts.factory.createNumericLiteral(minimum),
+                              )
+                            : modulo(),
+                    ),
+                );
+            } else if (tag.kind === "range") {
+                if (tag.minimum !== undefined)
+                    conditions.push(
+                        (tag.minimum.include
+                            ? ts.factory.createLessThanEquals
+                            : ts.factory.createLessThan)(
+                            ts.factory.createNumericLiteral(tag.minimum.value),
+                            input,
+                        ),
+                    );
+                if (tag.maximum !== undefined)
+                    conditions.push(
+                        (tag.maximum.include
+                            ? ts.factory.createLessThanEquals
+                            : ts.factory.createLessThan)(
+                            input,
+                            ts.factory.createNumericLiteral(tag.maximum.value),
+                        ),
+                    );
+            } else if (tag.kind === "minimum")
+                conditions.push(
+                    ts.factory.createLessThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "maximum")
+                conditions.push(
+                    ts.factory.createGreaterThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "exclusiveMinimum")
+                conditions.push(
+                    ts.factory.createLessThan(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "exclusiveMaximum")
+                conditions.push(
+                    ts.factory.createGreaterThan(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+
+        // NUMERIC VALIDATION
+        const finite: boolean =
+            !!tagList.find(
+                (tag) =>
+                    tag.kind === "range" &&
+                    tag.minimum !== undefined &&
+                    tag.maximum !== undefined,
+            ) ||
+            (!!tagList.find(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
+            ) &&
+                !!tagList.find(
+                    (tag) =>
+                        tag.kind === "maximum" ||
+                        tag.kind === "exclusiveMaximum",
+                )) ||
+            !!tagList.find(
+                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
+            );
+        const valid: boolean =
+            finite || tagList.find((tag) => tag.kind === "type") !== undefined;
+
+        if (
+            numeric &&
+            OptionPredicator.numeric(project.options, "checker") === false
+        ) {
+            if (finite === false)
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Number.isFinite"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            if (valid === false)
+                conditions.push(
+                    ts.factory.createLogicalNot(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+        }
+
+        // COMBINATION
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };
+}

package/src/programmers/internal/check_object.ts

@@ -0,0 +1,42 @@
+import ts from "typescript";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_properties } from "./check_dynamic_properties";
+import { check_everything } from "./check_everything";
+
+/**
+ * @internal
+ */
+export const check_object =
+    (props: check_object.IProps) => (entries: IExpressionEntry[]) => {
+        // PREPARE ASSETS
+        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+        const flags: ts.Expression[] = regular.map((entry) => entry.expression);
+
+        // REGULAR WITHOUT DYNAMIC PROPERTIES
+        if (props.equals === false && dynamic.length === 0)
+            return regular.length === 0 ? props.positive : reduce(props)(flags);
+
+        // CHECK DYNAMIC PROPERTIES
+        flags.push(check_dynamic_properties(props)(regular, dynamic));
+        return reduce(props)(flags);
+    };
+export namespace check_object {
+    export interface IProps {
+        equals: boolean;
+        assert: boolean;
+        halt?: (exp: ts.Expression) => ts.Expression;
+        reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
+        positive: ts.Expression;
+        superfluous: (value: ts.Expression) => ts.Expression;
+        entries?: ts.Identifier;
+    }
+}
+
+const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
+    props.assert
+        ? expressions.reduce(props.reduce)
+        : check_everything(
+              ts.factory.createArrayLiteralExpression(expressions),
+          );

package/src/programmers/internal/check_string.ts

@@ -0,0 +1,24 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_string_tags } from "./check_string_tags";
+
+/**
+ * @internal
+ */
+export function check_string(importer: FunctionImporter) {
+    return function (input: ts.Expression, tagList: IMetadataTag[]) {
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            ...check_string_tags(importer)(input, tagList),
+        ];
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };
+}

package/src/programmers/internal/check_string_tags.ts

@@ -0,0 +1,63 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_length } from "./check_length";
+
+/**
+ * @internal
+ */
+export const check_string_tags =
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, tagList: IMetadataTag[]) => {
+        const conditions: ts.Expression[] = [];
+        for (const tag of tagList)
+            if (tag.kind === "format")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createTrue(),
+                        ts.factory.createCallExpression(
+                            importer.use(`is_${tag.value}`),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+            else if (tag.kind === "pattern")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createTrue(),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier(
+                                `RegExp(/${tag.value}/).test`,
+                            ),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+            else if (tag.kind === "minLength")
+                conditions.push(
+                    ts.factory.createLessThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
+            else if (tag.kind === "maxLength")
+                conditions.push(
+                    ts.factory.createGreaterThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
+            else if (tag.kind === "length")
+                check_length(
+                    conditions,
+                    IdentifierFactory.join(input, "length"),
+                    tag,
+                );
+        return conditions;
+    };

package/src/programmers/internal/check_template.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_string_tags } from "./check_string_tags";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        templates: Metadata[][],
+        tagList: IMetadataTag[],
+    ) => {
+        // TYPEOF STRING & TAGS
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            ...check_string_tags(importer)(input, tagList),
+        ];
+
+        // TEMPLATES
+        const internal = templates.map((tpl) =>
+            ts.factory.createStrictEquality(
+                ts.factory.createTrue(),
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
+                    ),
+                    undefined,
+                    [input],
+                ),
+            ),
+        );
+        conditions.push(
+            internal.length === 1
+                ? internal[0]!
+                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+        );
+
+        // COMBINATION
+        return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };

package/src/programmers/internal/decode_union_object.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const decode_union_object =
+    (
+        checker: (
+            input: ts.Expression,
+            obj: MetadataObject,
+            explore: FeatureProgrammer.IExplore,
+        ) => ts.Expression,
+    ) =>
+    (
+        decoder: (
+            input: ts.Expression,
+            obj: MetadataObject,
+            explore: FeatureProgrammer.IExplore,
+        ) => ts.Expression,
+    ) =>
+    (success: (exp: ts.Expression) => ts.Expression) =>
+    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+    (
+        input: ts.Expression,
+        targets: MetadataObject[],
+        explore: FeatureProgrammer.IExplore,
+    ): ts.CallExpression =>
+        ts.factory.createCallExpression(
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                iterate(escaper)(
+                    input,
+                    targets.map((obj) => ({
+                        type: "object",
+                        is: () => success(checker(input, obj, explore)),
+                        value: () => decoder(input, obj, explore),
+                    })),
+                    `(${targets.map((t) => t.name).join(" | ")})`,
+                ),
+            ),
+            undefined,
+            undefined,
+        );
+
+const iterate =
+    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+    (input: ts.Expression, unions: IUnion[], expected: string) =>
+        ts.factory.createBlock(
+            [
+                ...unions.map((u) =>
+                    ts.factory.createIfStatement(
+                        u.is(),
+                        ts.factory.createReturnStatement(u.value()),
+                    ),
+                ),
+                escaper(input, expected),
+            ],
+            true,
+        );
+
+interface IUnion {
+    type: string;
+    is: () => ts.Expression;
+    value: () => ts.Expression;
+}

package/src/programmers/internal/feature_object_entries.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+export const feature_object_entries =
+    (config: Pick<FeatureProgrammer.IConfig, "decoder" | "path" | "trace">) =>
+    (obj: MetadataObject) =>
+    (input: ts.Expression) =>
+        obj.properties.map((prop) => {
+            const sole: string | null = prop.key.getSoleLiteral();
+            const propInput =
+                sole === null
+                    ? ts.factory.createIdentifier("value")
+                    : Escaper.variable(sole)
+                    ? ts.factory.createPropertyAccessExpression(
+                          input,
+                          ts.factory.createIdentifier(sole),
+                      )
+                    : ts.factory.createElementAccessExpression(
+                          input,
+                          ts.factory.createStringLiteral(sole),
+                      );
+
+            return {
+                input: propInput,
+                key: prop.key,
+                meta: prop.value,
+                expression: config.decoder(
+                    propInput,
+                    prop.value,
+                    {
+                        tracable: config.path || config.trace,
+                        source: "object",
+                        from: "object",
+                        postfix:
+                            sole !== null
+                                ? IdentifierFactory.postfix(sole)
+                                : `$join(key)`,
+                    },
+                    prop.tags,
+                ),
+            };
+        });

package/src/programmers/internal/metadata_to_pattern.ts

@@ -0,0 +1,31 @@
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+export const metadata_to_pattern =
+    (top: boolean) =>
+    (meta: Metadata): string => {
+        if (meta.atomics.find((type) => type === "string") !== undefined)
+            return "(.*)";
+
+        const values: string[] = ArrayUtil.flat(
+            meta.constants.map((c) => {
+                if (c.type !== "string")
+                    return c.values.map((v) => v.toString());
+                return c.values.map((str) => PatternUtil.escape(str));
+            }),
+        );
+        for (const type of meta.atomics)
+            if (type === "number" || type === "bigint")
+                values.push(PatternUtil.NUMBER);
+            else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
+        for (const childTpl of meta.templates)
+            values.push("(" + template_to_pattern(false)(childTpl) + ")");
+
+        const pattern: string =
+            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+        return top ? PatternUtil.fix(pattern) : pattern;
+    };