typia 3.3.12 → 3.4.0-dev.20221212

package/src/programmers/helpers/UnionExplorer.ts

@@ -0,0 +1,437 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { UnionPredicator } from "./UnionPredicator";
+
+export namespace UnionExplorer {
+    export interface Decoder<T> {
+        (
+            input: ts.Expression,
+            target: T,
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+        ): ts.Expression;
+    }
+    export type ObjectCombiner = Decoder<MetadataObject[]>;
+
+    export function object(
+        config: FeatureProgrammer.IConfig,
+        level: number = 0,
+    ) {
+        return function (
+            input: ts.Expression,
+            targets: MetadataObject[],
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+        ): ts.Expression {
+            // BREAKER
+            if (targets.length === 1)
+                return config.objector.decoder(
+                    input,
+                    targets[0]!,
+                    explore,
+                    tags,
+                );
+
+            const expected: string = `(${targets
+                .map((t) => t.name)
+                .join(" | ")})`;
+
+            // POSSIBLE TO SPECIALIZE?
+            const specList = UnionPredicator.object(targets);
+            if (specList.length === 0) {
+                const condition: ts.Expression = config.objector.unionizer(
+                    input,
+                    targets,
+                    {
+                        ...explore,
+                        tracable: false,
+                    },
+                    tags,
+                );
+                return config.objector.full
+                    ? config.objector.full(condition)(input, expected, explore)
+                    : condition;
+            }
+            const remained: MetadataObject[] = targets.filter(
+                (t) => specList.find((s) => s.object === t) === undefined,
+            );
+
+            // DO SPECIALIZE
+            const conditions: ts.IfStatement[] = specList
+                .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+                .map((spec) => {
+                    const key: string = spec.property.key.getSoleLiteral()!;
+                    const accessor: ts.Expression = IdentifierFactory.join(
+                        input,
+                        key,
+                    );
+                    const pred: ts.Expression = spec.neighbour
+                        ? config.objector.checker(
+                              accessor,
+                              spec.property.value,
+                              {
+                                  ...explore,
+                                  tracable: false,
+                                  postfix: IdentifierFactory.postfix(key),
+                              },
+                              tags,
+                          )
+                        : (config.objector.required || ((exp) => exp))(
+                              ExpressionFactory.isRequired(accessor),
+                          );
+                    return ts.factory.createIfStatement(
+                        (config.objector.is || ((exp) => exp))(pred),
+                        ts.factory.createReturnStatement(
+                            config.objector.decoder(
+                                input,
+                                spec.object,
+                                explore,
+                                tags,
+                            ),
+                        ),
+                    );
+                });
+
+            // RETURNS WITH CONDITIONS
+            return ts.factory.createCallExpression(
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(
+                        [
+                            ...conditions,
+                            remained.length
+                                ? ts.factory.createReturnStatement(
+                                      object(config, level + 1)(
+                                          input,
+                                          remained,
+                                          explore,
+                                          tags,
+                                      ),
+                                  )
+                                : config.objector.failure(
+                                      input,
+                                      expected,
+                                      explore,
+                                  ),
+                        ],
+                        true,
+                    ),
+                ),
+                undefined,
+                undefined,
+            );
+        };
+    }
+
+    export const array = (props: array.IProps) =>
+        iterate<Metadata>({
+            size: (input) => IdentifierFactory.join(input, "length"),
+            front: (input) =>
+                ts.factory.createElementAccessExpression(input, 0),
+            array: (input) => input,
+            name: (t) => `Array<${t.getName()}>`,
+        })(props);
+    export namespace array {
+        export type IProps = iterate.IProps<Metadata>;
+    }
+
+    export const set = (props: set.IProps) =>
+        iterate<Metadata>({
+            size: (input) => IdentifierFactory.join(input, "size"),
+            front: (input) =>
+                IdentifierFactory.join(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.join(input, "values"),
+                                undefined,
+                                undefined,
+                            ),
+                            "next",
+                        ),
+                        undefined,
+                        undefined,
+                    ),
+                    "value",
+                ),
+            array: (input) =>
+                ts.factory.createArrayLiteralExpression(
+                    [ts.factory.createSpreadElement(input)],
+                    false,
+                ),
+            name: (t) => `Set<${t.getName()}>`,
+        })(props);
+    export namespace set {
+        export type IProps = iterate.IProps<Metadata>;
+    }
+
+    export const map = (props: map.IProps) =>
+        iterate<[Metadata, Metadata]>({
+            size: (input) => IdentifierFactory.join(input, "size"),
+            front: (input) =>
+                IdentifierFactory.join(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.join(input, "entries"),
+                                undefined,
+                                undefined,
+                            ),
+                            "next",
+                        ),
+                        undefined,
+                        undefined,
+                    ),
+                    "value",
+                ),
+            array: (input) =>
+                ts.factory.createArrayLiteralExpression(
+                    [ts.factory.createSpreadElement(input)],
+                    false,
+                ),
+            name: ([k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+        })(props);
+
+    export namespace map {
+        export type IProps = iterate.IProps<[Metadata, Metadata]>;
+    }
+
+    const iterate =
+        <T>(accessor: iterate.IAccessor<T>) =>
+        (props: iterate.IProps<T>) =>
+        (
+            input: ts.Expression,
+            targets: T[],
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+        ): ts.Expression => {
+            if (targets.length === 1)
+                return props.decoder(
+                    accessor.array(input),
+                    targets[0]!,
+                    explore,
+                    tags,
+                );
+
+            //----
+            // LIST UP VARIABLES
+            //----
+            // TUPLES
+            const tupleListVariable: ts.VariableStatement =
+                StatementFactory.constant(
+                    "tupleList",
+                    ts.factory.createArrayLiteralExpression(
+                        targets.map((meta) =>
+                            ts.factory.createArrayLiteralExpression([
+                                ts.factory.createArrowFunction(
+                                    undefined,
+                                    undefined,
+                                    [IdentifierFactory.parameter("branch")],
+                                    undefined,
+                                    undefined,
+                                    props.checker(
+                                        ts.factory.createIdentifier("branch"),
+                                        meta,
+                                        {
+                                            ...explore,
+                                            tracable: false,
+                                            postfix: `"[0]"`,
+                                        },
+                                        tags,
+                                    ),
+                                ),
+                                ts.factory.createArrowFunction(
+                                    undefined,
+                                    undefined,
+                                    [IdentifierFactory.parameter("branch")],
+                                    undefined,
+                                    undefined,
+                                    props.decoder(
+                                        ts.factory.createIdentifier("branch"),
+                                        meta,
+                                        {
+                                            ...explore,
+                                            tracable: true,
+                                        },
+                                        tags,
+                                    ),
+                                ),
+                            ]),
+                        ),
+                    ),
+                );
+
+            // FILTERED TUPLES
+            const filteredVariable = StatementFactory.constant(
+                "filtered",
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("tupleList.filter"),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [IdentifierFactory.parameter("tuple")],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                props.success,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("tuple[0]"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("front")],
+                                ),
+                            ),
+                        ),
+                    ],
+                ),
+            );
+
+            //----
+            // STATEMENTS
+            //----
+            // ONLY ONE TYPE
+            const uniqueStatement = ts.factory.createIfStatement(
+                ts.factory.createStrictEquality(
+                    ts.factory.createNumericLiteral(1),
+                    ts.factory.createIdentifier("filtered.length"),
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(`filtered[0][1]`),
+                        undefined,
+                        [accessor.array(input)],
+                    ),
+                ),
+            );
+
+            // UNION TYPE
+            const forOfStatement = ts.factory.createForOfStatement(
+                undefined,
+                ts.factory.createVariableDeclarationList(
+                    [ts.factory.createVariableDeclaration("tuple")],
+                    ts.NodeFlags.Const,
+                ),
+                // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
+                ts.factory.createIdentifier("filtered"),
+                ts.factory.createIfStatement(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(
+                            ts.factory.createIdentifier("array"),
+                            "every",
+                        ),
+                        undefined,
+                        [
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter("value")],
+                                undefined,
+                                undefined,
+                                ts.factory.createStrictEquality(
+                                    props.success,
+                                    ts.factory.createCallExpression(
+                                        ts.factory.createIdentifier("tuple[0]"),
+                                        undefined,
+                                        [ts.factory.createIdentifier("value")],
+                                    ),
+                                ),
+                            ),
+                        ],
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier(`tuple[1]`),
+                            undefined,
+                            [ts.factory.createIdentifier("array")],
+                        ),
+                    ),
+                ),
+            );
+            const unionStatement = ts.factory.createIfStatement(
+                ts.factory.createLessThan(
+                    ts.factory.createNumericLiteral(1),
+                    ts.factory.createIdentifier("filtered.length"),
+                ),
+                forOfStatement,
+            );
+
+            const block = [
+                // ARRAY.LENGTH := 0
+                ts.factory.createIfStatement(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        accessor.size(input),
+                    ),
+                    ts.factory.createReturnStatement(props.empty),
+                ),
+
+                // UNION PREDICATORS
+                tupleListVariable,
+                StatementFactory.constant("front", accessor.front(input)),
+                filteredVariable,
+                uniqueStatement,
+
+                // CONDITIONAL STATEMENTS
+                StatementFactory.constant("array", accessor.array(input)),
+                unionStatement,
+                props.failure(
+                    input,
+                    `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
+                    explore,
+                ),
+            ];
+
+            return ts.factory.createCallExpression(
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(block, true),
+                ),
+                undefined,
+                undefined,
+            );
+        };
+    namespace iterate {
+        export interface IProps<T> {
+            checker(
+                input: ts.Expression,
+                target: T,
+                explore: FeatureProgrammer.IExplore,
+                tags: IMetadataTag[],
+            ): ts.Expression;
+            decoder: Decoder<T>;
+            empty: ts.Expression;
+            success: ts.Expression;
+            failure(
+                input: ts.Expression,
+                expected: string,
+                explore: CheckerProgrammer.IExplore,
+            ): ts.Statement;
+        }
+
+        export interface IAccessor<T> {
+            name(metadata: T): string;
+            size(input: ts.Expression): ts.Expression;
+            front(input: ts.Expression): ts.Expression;
+            array(input: ts.Expression): ts.Expression;
+        }
+    }
+}

package/src/programmers/helpers/UnionPredicator.ts

@@ -0,0 +1,81 @@
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataProperty } from "../../metadata/MetadataProperty";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { MapUtil } from "../../utils/MapUtil";
+
+export namespace UnionPredicator {
+    export interface ISpecialized {
+        index: number;
+        object: MetadataObject;
+        property: MetadataProperty;
+        neighbour: boolean;
+    }
+
+    export function object(targets: MetadataObject[]): Array<ISpecialized> {
+        // PROPERTY MATRIX
+        const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
+        for (const obj of targets)
+            for (const prop of obj.properties) {
+                const key: string | null = prop.key.getSoleLiteral();
+                if (key !== null)
+                    MapUtil.take(matrix, key, () =>
+                        ArrayUtil.repeat(targets.length, () => null),
+                    );
+            }
+        targets.forEach((obj, i) => {
+            for (const prop of obj.properties) {
+                const key: string | null = prop.key.getSoleLiteral();
+                if (key !== null) matrix.get(key)![i] = prop;
+            }
+        });
+
+        // EXPLORE SPECIALIZERS
+        const output: ISpecialized[] = [];
+        targets.forEach((obj, i) => {
+            const children: ISpecializedProperty[] = [];
+            obj.properties.forEach((prop) => {
+                // MUST BE REQUIRED
+                if (prop.value.required === false) return;
+                const key: string | null = prop.key.getSoleLiteral();
+                if (key === null) return;
+
+                // FIND NEIGHBORHOOD PROPERTIES
+                const neighbors: MetadataProperty[] = matrix
+                    .get(key)!
+                    .filter(
+                        (oppo, k) => i !== k && oppo !== null,
+                    ) as MetadataProperty[];
+
+                // NO NEIGHBORHOOD
+                const unique: boolean =
+                    neighbors.length === 0 ||
+                    neighbors.every(
+                        (n) => !Metadata.intersects(prop.value, n.value, false),
+                    );
+                if (unique === true)
+                    children.push({
+                        property: prop,
+                        neighbour: neighbors.length !== 0,
+                    });
+            });
+            if (children.length === 0) return;
+
+            const top: ISpecializedProperty =
+                children.find((child) => child.property.value.isConstant()) ||
+                children[0]!;
+            output.push({
+                index: i,
+                object: obj,
+                ...top,
+            });
+        });
+        return output;
+    }
+}
+
+interface ISpecializedProperty {
+    property: MetadataProperty;
+    neighbour: boolean;
+}

package/src/programmers/internal/application_array.ts

@@ -0,0 +1,45 @@
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_array =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (
+        metadata: Metadata,
+        nullable: boolean,
+        attribute: IJsonSchema.IAttribute,
+    ): IJsonSchema.IArray => {
+        // SCHEMA
+        const output: IJsonSchema.IArray = {
+            type: "array",
+            items: application_schema(options)(components)(false)(
+                metadata,
+                attribute,
+            ),
+            nullable,
+            ...attribute,
+        };
+
+        // RANGE
+        for (const tag of attribute["x-typia-metaTags"] || [])
+            if (tag.kind === "minItems") output.minItems = tag.value;
+            else if (tag.kind === "maxItems") output.maxItems = tag.value;
+            else if (tag.kind === "items") {
+                if (tag.minimum !== undefined)
+                    output.minItems =
+                        tag.minimum.value +
+                        (tag.minimum.include === true ? 0 : 1);
+                if (tag.maximum !== undefined)
+                    output.maxItems =
+                        tag.maximum.value -
+                        (tag.maximum.include === true ? 0 : 1);
+            }
+        return output;
+    };

package/src/programmers/internal/application_boolean.ts

@@ -0,0 +1,17 @@
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_boolean = (
+    nullable: boolean,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IBoolean => ({
+    type: "boolean",
+    nullable,
+    ...attribute,
+    default: application_default(attribute)(
+        (def) => def === "true" || def === "false",
+    )((str) => Boolean(str)),
+});

package/src/programmers/internal/application_constant.ts

@@ -0,0 +1,29 @@
+import { MetadataConstant } from "../../metadata/MetadataConstant";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_constant = (
+    constant: MetadataConstant,
+    nullable: boolean,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IEnumeration<any> => ({
+    type: constant.type,
+    enum: constant.values as any,
+    nullable,
+    ...attribute,
+    default: application_default(attribute)((def) =>
+        constant.values.some((v) => v.toString() === def),
+    )(
+        constant.type === "string"
+            ? (str) => str
+            : constant.type === "number"
+            ? (str) => Number(str)
+            : constant.type === "boolean"
+            ? (str) => Boolean(str)
+            : (str) => BigInt(str) as any,
+    ),
+});

package/src/programmers/internal/application_default.ts

@@ -0,0 +1,17 @@
+import { IJsonSchema } from "../../module";
+
+/**
+ * @internal
+ */
+export const application_default =
+    (attribute: IJsonSchema.IAttribute) =>
+    (pred: (value: string) => boolean) =>
+    <T>(caster: (str: string) => T): T | undefined => {
+        const defaults = (attribute["x-typia-jsDocTags"] || []).filter(
+            (tag) => tag.name === "default",
+        );
+        for (const def of defaults)
+            if (def.text?.length && pred(def.text[0]!.text))
+                return caster(def.text[0]!.text);
+        return undefined;
+    };

package/src/programmers/internal/application_default_string.ts

@@ -0,0 +1,32 @@
+import { Metadata } from "../../metadata/Metadata";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_default_string =
+    (meta: Metadata, attribute: IJsonSchema.IAttribute) =>
+    (schema: IJsonSchema.IString) =>
+        application_default(attribute)((str) => {
+            const conditions: boolean[] = [];
+
+            // OTHER ATOMIC TYPES
+            if (meta.atomics.find((t) => t === "number" || t === "bigint"))
+                conditions.push(Number.isNaN(Number(str)));
+            if (meta.atomics.find((t) => t === "boolean"))
+                conditions.push(str !== "true" && str !== "false");
+            for (const constant of meta.constants)
+                for (const value of constant.values)
+                    conditions.push(str !== value.toString());
+
+            // CONSIDER TAGS
+            if (schema.minLength !== undefined)
+                conditions.push(str.length >= schema.minLength);
+            if (schema.maxLength !== undefined)
+                conditions.push(str.length <= schema.maxLength);
+            if (schema.pattern !== undefined)
+                conditions.push(new RegExp(schema.pattern).test(str));
+            return conditions.every((c) => c);
+        })((str) => str);

package/src/programmers/internal/application_native.ts

@@ -0,0 +1,29 @@
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+
+import { IJsonSchema } from "../../module";
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+
+export const application_native =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (name: string) =>
+    (
+        nullable: boolean,
+        attribute: IJsonSchema.IAttribute,
+    ): IJsonSchema.IReference => {
+        const key: string = name + (nullable ? ".Nullable" : "");
+        if (components.schemas[key] === undefined)
+            components.schemas[key] = {
+                type: "object",
+                $id:
+                    options.purpose === "ajv"
+                        ? options.prefix + "/" + key
+                        : undefined,
+                properties: {},
+                nullable,
+            };
+        return {
+            $ref: `#/components/schemas/${name}`,
+            ...attribute,
+        };
+    };