typia 3.3.12 → 3.4.0-dev.20221212

package/src/factories/IdentifierFactory.ts

@@ -0,0 +1,72 @@
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export function generate(name: string) {
+        return Escaper.variable(name)
+            ? ts.factory.createIdentifier(name)
+            : ts.factory.createStringLiteral(name);
+    }
+
+    export function join(prefix: ts.Expression, name: string) {
+        const postfix = generate(name);
+        return ts.isStringLiteral(postfix)
+            ? ts.factory.createElementAccessExpression(prefix, postfix)
+            : ts.factory.createPropertyAccessExpression(prefix, postfix);
+    }
+
+    export function postfix(str: string): string {
+        return Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+    }
+
+    export function parameter(
+        name: string | ts.BindingName,
+        init?: ts.Expression,
+    ) {
+        if (ts.version >= "4.8")
+            return ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                name,
+                undefined,
+                undefined,
+                init,
+            );
+        // eslint-disable-next-line
+        return ts.factory.createParameterDeclaration(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            undefined,
+            undefined,
+            init,
+        );
+    }
+
+    // export function property(
+    //     name: string | ts.PropertyName,
+    //     value: ts.Expression,
+    // ): ts.PropertyDeclaration {
+    //     if (ts.version >= "4.8")
+    //         return ts.factory.createPropertyDeclaration(
+    //             undefined,
+    //             name,
+    //             undefined,
+    //             undefined,
+    //             value,
+    //         );
+    //     // eslint-disable-next-line
+    //     return ts.factory.createPropertyDeclaration(
+    //         undefined,
+    //         undefined,
+    //         name,
+    //         undefined,
+    //         undefined,
+    //         value,
+    //     );
+    // }
+}

package/src/factories/LiteralFactory.ts

@@ -0,0 +1,44 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+    export function generate(input: any): ts.Expression {
+        if (input === null) return ts.factory.createNull();
+        else if (ts.isIdentifier(input)) return input;
+        else if (input instanceof Array) return generate_array(input);
+        else if (typeof input === "object") return generate_object(input);
+        else if (typeof input === "string") return generate_string(input);
+        else if (typeof input === "boolean") return generate_value(input);
+        else if (typeof input === "number") return generate_value(input);
+        else if (typeof input === "bigint") return generate_value(input);
+        else throw new Error("Unknown type.");
+    }
+
+    function generate_object(obj: object): ts.ObjectLiteralExpression {
+        const properties = Object.entries(obj)
+            .filter((tuple) => tuple[1] !== undefined)
+            .map(([key, value]) =>
+                ts.factory.createPropertyAssignment(
+                    IdentifierFactory.generate(key),
+                    generate(value),
+                ),
+            );
+        return ts.factory.createObjectLiteralExpression(properties, true);
+    }
+
+    function generate_array(array: any[]): ts.ArrayLiteralExpression {
+        return ts.factory.createArrayLiteralExpression(
+            array.map(generate),
+            true,
+        );
+    }
+
+    function generate_value(value: number | boolean | bigint): ts.Identifier {
+        return ts.factory.createIdentifier(value.toString());
+    }
+
+    function generate_string(value: string): ts.StringLiteral {
+        return ts.factory.createStringLiteral(value);
+    }
+}

package/src/factories/MetadataCollection.ts

@@ -0,0 +1,122 @@
+import ts from "typescript";
+
+import { Metadata } from "../metadata/Metadata";
+import { MetadataObject } from "../metadata/MetadataObject";
+
+import { MapUtil } from "../utils/MapUtil";
+
+import { CommentFactory } from "./CommentFactory";
+import { TypeFactory } from "./TypeFactory";
+
+export class MetadataCollection {
+    private readonly dict_: Map<ts.Type, MetadataObject>;
+    private readonly names_: Map<string, Map<ts.Type, string>>;
+    private readonly unions_: Map<string, MetadataObject[]>;
+    private index_: number;
+
+    public constructor(
+        private readonly options?: Partial<MetadataCollection.IOptions>,
+    ) {
+        this.dict_ = new Map();
+        this.names_ = new Map();
+        this.unions_ = new Map();
+        this.index_ = 0;
+    }
+
+    public objects(): MetadataObject[] {
+        return [...this.dict_.values()];
+    }
+    public unions(): MetadataObject[][] {
+        return [...this.unions_.values()];
+    }
+
+    public emplace(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+    ): [MetadataObject, boolean] {
+        const oldbie = this.dict_.get(type);
+        if (oldbie !== undefined) return [oldbie, false];
+
+        const $id: string = this.get_name(checker, type);
+        const obj: MetadataObject = MetadataObject.create({
+            name: $id,
+            properties: [],
+            description:
+                (type.symbol &&
+                    CommentFactory.generate(
+                        type.symbol.getDocumentationComment(checker),
+                    )) ||
+                undefined,
+            jsDocTags: type.symbol?.getJsDocTags() || [],
+            validated: false,
+            index: this.index_++,
+            recursive: false,
+            nullables: [],
+        });
+        this.dict_.set(type, obj);
+        return [obj, true];
+    }
+
+    /**
+     * @internal
+     */
+    public getUnionIndex(meta: Metadata): number {
+        const key: string = meta.objects.map((obj) => obj.name).join(" | ");
+        MapUtil.take(this.unions_, key, () => meta.objects);
+        return [...this.unions_.keys()].indexOf(key);
+    }
+
+    private get_name(checker: ts.TypeChecker, type: ts.Type): string {
+        const name: string = (() => {
+            const str: string = TypeFactory.getFullName(checker, type);
+            return this.options?.replace ? this.options.replace(str) : str;
+        })();
+
+        const duplicates: Map<ts.Type, string> = MapUtil.take(
+            this.names_,
+            name,
+            () => new Map(),
+        );
+        const oldbie: string | undefined = duplicates.get(type);
+        if (oldbie !== undefined) return oldbie;
+
+        const addicted: string = duplicates.size
+            ? `${name}.o${duplicates.size}`
+            : name;
+        duplicates.set(type, addicted);
+        return addicted;
+    }
+}
+export namespace MetadataCollection {
+    export interface IOptions {
+        replace?(str: string): string;
+    }
+
+    export function replace(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function escape(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];

package/src/factories/MetadataFactory.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { explore_metadata } from "./internal/explore_metadata";
+
+export namespace MetadataFactory {
+    export interface IOptions {
+        resolve: boolean;
+        constant: boolean;
+    }
+
+    export function generate(
+        checker: ts.TypeChecker,
+        collection: MetadataCollection,
+        type: ts.Type | null,
+        options: IOptions,
+    ): Metadata {
+        // CONSTRUCT SCHEMA WITH OBJECTS
+        const metadata: Metadata = explore_metadata(checker)(options)(
+            collection,
+        )(type, false);
+
+        // FIND RECURSIVE OBJECTS
+        for (const object of collection.objects())
+            object.recursive = object.properties.some(
+                (prop) =>
+                    ArrayUtil.has(
+                        prop.value.objects,
+                        (elem) => elem.name === object.name,
+                    ) ||
+                    prop.value.arrays.some((meta) =>
+                        ArrayUtil.has(
+                            meta.objects,
+                            (elem) => elem.name === object.name,
+                        ),
+                    ),
+            );
+
+        // RETURNS
+        return metadata;
+    }
+}

package/src/factories/MetadataTagFactory.ts

@@ -0,0 +1,347 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../metadata/IMetadataTag";
+import { Metadata } from "../metadata/Metadata";
+
+export namespace MetadataTagFactory {
+    export function generate(
+        identifier: () => string,
+        metadata: Metadata,
+        tagList: ts.JSDocTagInfo[],
+    ): IMetadataTag[] {
+        const output: IMetadataTag[] = [];
+        for (const tag of tagList) {
+            const elem: IMetadataTag | null = parse(
+                identifier,
+                metadata,
+                tag,
+                output,
+            );
+            if (elem !== null) output.push(elem);
+        }
+        return output;
+    }
+
+    function parse(
+        identifier: () => string,
+        metadata: Metadata,
+        tag: ts.JSDocTagInfo,
+        output: IMetadataTag[],
+    ): IMetadataTag | null {
+        const closure = PARSER[tag.name];
+        if (closure === undefined) return null;
+
+        const text = (tag.text || [])[0]?.text;
+        if (text === undefined)
+            throw new Error(`${LABEL}: no tag value on ${identifier()}`);
+
+        return closure(identifier, metadata, text, output);
+    }
+}
+
+const PARSER: Record<
+    string,
+    (
+        identifier: () => string,
+        metadata: Metadata,
+        text: string,
+        output: IMetadataTag[],
+    ) => IMetadataTag | null
+> = {
+    /* -----------------------------------------------------------
+        ARRAY
+    ----------------------------------------------------------- */
+    items: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "items", "array", [
+            "minItems",
+            "maxItems",
+        ]);
+        return parse_range("items", identifier, text, true);
+    },
+    minItems: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "minItems", "array", ["items"]);
+        return {
+            kind: "minItems",
+            value: parse_number(identifier, text),
+        };
+    },
+    maxItems: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "maxItems", "array", ["items"]);
+        return {
+            kind: "maxItems",
+            value: parse_number(identifier, text),
+        };
+    },
+
+    /* -----------------------------------------------------------
+        NUMBER
+    ----------------------------------------------------------- */
+    type: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "type", "number", []);
+        if (text !== "int" && text !== "uint")
+            throw new Error(`${LABEL}: invalid type tag on "${identifier()}".`);
+        return { kind: "type", value: text };
+    },
+    range: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "range", "number", [
+            "exclusiveMinimum",
+            "minimum",
+            "maximum",
+            "exclusiveMaximum",
+        ]);
+        return parse_range("range", identifier, text, false);
+    },
+    minimum: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "minimum", "number", [
+            "range",
+            "exclusiveMaximum",
+            "exclusiveMinimum",
+        ]);
+        return {
+            kind: "minimum",
+            value: parse_number(identifier, text),
+        };
+    },
+    maximum: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "maximum", "number", [
+            "range",
+            "exclusiveMinimum",
+            "exclusiveMaximum",
+        ]);
+        return {
+            kind: "maximum",
+            value: parse_number(identifier, text),
+        };
+    },
+    exclusiveMinimum: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "exclusiveMinimum", "number", [
+            "range",
+            "minimum",
+            "maximum",
+        ]);
+        return {
+            kind: "exclusiveMinimum",
+            value: parse_number(identifier, text),
+        };
+    },
+    exclusiveMaximum: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "exclusiveMaximum", "number", [
+            "range",
+            "minimum",
+            "maximum",
+        ]);
+        return {
+            kind: "exclusiveMaximum",
+            value: parse_number(identifier, text),
+        };
+    },
+    multipleOf: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "multipleOf", "number", [
+            "step",
+        ]);
+        return {
+            kind: "multipleOf",
+            value: parse_number(identifier, text),
+        };
+    },
+    step: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "step", "number", [
+            "multipleOf",
+        ]);
+
+        const minimum: boolean = output.some(
+            (tag) =>
+                tag.kind === "minimum" ||
+                tag.kind === "exclusiveMinimum" ||
+                (tag.kind === "range" && tag.minimum !== undefined),
+        );
+        if (minimum === undefined)
+            throw new Error(
+                `${LABEL}: step requires minimum tag on "${identifier()}".`,
+            );
+
+        return {
+            kind: "step",
+            value: parse_number(identifier, text),
+        };
+    },
+
+    /* -----------------------------------------------------------
+        STRING
+    ----------------------------------------------------------- */
+    format: (identifier, metadata, value, output) => {
+        validate(identifier, metadata, output, "format", "string", ["pattern"]);
+
+        // Ignore arbitrary @format values in the internal metadata,
+        // these are currently only supported on the typia.application() API.
+        if (FORMATS.has(value) === false) return null;
+
+        return {
+            kind: "format",
+            value: value as "uuid",
+        };
+    },
+    pattern: (identifier, metadata, value, output) => {
+        validate(identifier, metadata, output, "pattern", "string", ["format"]);
+        return {
+            kind: "pattern",
+            value,
+        };
+    },
+    length: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "length", "string", [
+            "minLength",
+            "maxLength",
+        ]);
+        return parse_range("length", identifier, text, true);
+    },
+    minLength: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "minLength", "string", [
+            "length",
+        ]);
+        return {
+            kind: "minLength",
+            value: parse_number(identifier, text),
+        };
+    },
+    maxLength: (identifier, metadata, text, output) => {
+        validate(identifier, metadata, output, "maxLength", "string", [
+            "length",
+        ]);
+        return {
+            kind: "maxLength",
+            value: parse_number(identifier, text),
+        };
+    },
+};
+
+function parse_range<Kind extends string>(
+    kind: Kind,
+    identifier: () => string,
+    text: string,
+    allowScalar: boolean,
+): Omit<IMetadataTag.IRange, "kind"> & { kind: Kind } {
+    if (allowScalar === true && Number.isNaN(Number(text)) === false) {
+        const value: number = Number(text);
+        if (Math.floor(value) !== value)
+            throw new Error(`${LABEL}: invalid length on "${identifier()}".`);
+        return {
+            kind,
+            minimum: {
+                include: true,
+                value,
+            },
+            maximum: {
+                include: true,
+                value,
+            },
+        };
+    } else if (text.indexOf(",") === -1)
+        if (LEFT_PARENTHESIS.some((str) => text.indexOf(str) !== -1))
+            return {
+                kind,
+                minimum: parse_side("left")(kind)(identifier)(text),
+            };
+        else if (RIGHT_PARENTHESIS.some((str) => text.indexOf(str) !== -1))
+            return {
+                kind,
+                maximum: parse_side("right")(kind)(identifier)(text),
+            };
+        else
+            throw new Error(
+                `${LABEL}: invalid ${kind} tag on "${identifier()}".`,
+            );
+
+    const [left, right] = text.split(",") as [string, string];
+    return {
+        kind,
+        minimum: parse_side("left")(kind)(identifier)(left),
+        maximum: parse_side("right")(kind)(identifier)(right),
+    };
+}
+
+const parse_side = (side: "left" | "right") => {
+    const symbol = side === "left" ? LEFT_PARENTHESIS : RIGHT_PARENTHESIS;
+    const substring: (str: string, index: number) => string =
+        side === "left"
+            ? (str, index) => str.substring(index + 1)
+            : (str, index) => str.substring(0, index);
+    return (tag: string) => (identifier: () => string) => (text: string) => {
+        const [index, include] =
+            text.indexOf(symbol[0]) !== -1
+                ? [text.indexOf(symbol[0]), true]
+                : [text.indexOf(symbol[1]), false];
+        if (index === -1)
+            throw new Error(
+                `${LABEL}: invalid ${tag} tag on "${identifier()}".`,
+            );
+        return {
+            include,
+            value: parse_number(identifier, substring(text, index)),
+        };
+    };
+};
+
+function parse_number(identifier: () => string, str: string): number {
+    const value: number = Number(str);
+    if (isNaN(value) === true)
+        throw new Error(`${LABEL}: invalid number on "${identifier()}".`);
+    return value;
+}
+
+const LABEL = "Error on typia.MetadataTagFactory.generate()";
+const LEFT_PARENTHESIS = ["[", "("] as const;
+const RIGHT_PARENTHESIS = ["]", ")"] as const;
+const FORMATS = new Set(["uuid", "email", "url", "mobile", "ipv4", "ipv6"]);
+
+const WRONG_TYPE = (
+    tag: string,
+    type: "string" | "number" | "array",
+    identifier: () => string,
+) => `${LABEL}: ${tag} requires ${type} type, but no "${identifier()}".`;
+
+function validate(
+    identifier: () => string,
+    metadata: Metadata,
+    output: IMetadataTag[],
+    kind: IMetadataTag["kind"],
+    type: "array" | "string" | "number",
+    neighbors: IMetadataTag["kind"][],
+): void {
+    // TYPE CHECKING
+    if (type === "array") {
+        if (has_array(metadata) === false)
+            throw new Error(WRONG_TYPE(kind, "array", identifier));
+    } else if (has_atomic(metadata, type) === false)
+        throw new Error(WRONG_TYPE(kind, type, identifier));
+
+    // DUPLICATED TAG
+    if (output.some((tag) => tag.kind === kind))
+        throw new Error(
+            `${LABEL}: duplicated ${kind} tags on "${identifier()}".`,
+        );
+
+    // NEIGHBOR TAG
+    for (const name of neighbors)
+        if (output.some((tag) => tag.kind === name))
+            throw new Error(
+                `${LABEL}: ${kind} and ${name} tags on "${identifier()}".`,
+            );
+}
+
+function has_atomic(metadata: Metadata, type: "string" | "number"): boolean {
+    return (
+        metadata.atomics.find((atom) => atom === type) !== undefined ||
+        metadata.arrays.some((child) => has_atomic(child, type)) ||
+        metadata.tuples.some((tuple) =>
+            tuple.some((child) => has_atomic(child, type)),
+        )
+    );
+}
+
+function has_array(metadata: Metadata): boolean {
+    return (
+        metadata.arrays.length !== 0 ||
+        metadata.tuples.some((tuple) => tuple.some((child) => has_array(child)))
+    );
+}

package/src/factories/StatementFactory.ts

@@ -0,0 +1,60 @@
+import ts from "typescript";
+
+export namespace StatementFactory {
+    export function constant(name: string, initializer?: ts.Expression) {
+        return ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Const,
+            ),
+        );
+    }
+
+    export function transpile(script: string) {
+        return ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(ts.transpile(script)),
+        );
+    }
+
+    // export function require(variable: string, location: string) {
+    //     return ts.factory.createImportDeclaration(
+    //         undefined,
+    //         undefined,
+    //         ts.factory.createImportClause(
+    //             false,
+    //             undefined,
+    //             ts.factory.createNamespaceImport(
+    //                 ts.factory.createIdentifier(variable),
+    //             ),
+    //         ),
+    //         ts.factory.createStringLiteral(location),
+    //     );
+    // }
+
+    // export function importModulo(variable: string, location: string) {
+    //     return ts.factory.createImportDeclaration(
+    //         undefined,
+    //         undefined,
+    //         ts.factory.createImportClause(
+    //             false,
+    //             undefined,
+    //             ts.factory.createNamedImports([
+    //                 ts.factory.createImportSpecifier(
+    //                     false,
+    //                     undefined,
+    //                     ts.factory.createIdentifier(variable),
+    //                 ),
+    //             ]),
+    //         ),
+    //         ts.factory.createStringLiteral(location),
+    //     );
+    // }
+}