typia 3.3.12 → 3.4.0-dev.20221212-2

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -0,0 +1,164 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export function stringify_dynamic_properties(
+    dynamic: IExpressionEntry[],
+    regular: string[],
+): ts.Expression {
+    // BASIC STATMEMENT, CHECK UNDEFINED
+    const statements: ts.Statement[] = [
+        ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+            ),
+            ts.factory.createReturnStatement(
+                ts.factory.createStringLiteral(""),
+            ),
+        ),
+    ];
+
+    // PREPARE RETURN FUNCTION
+    const output = () => {
+        const mapped = ts.factory.createCallExpression(
+            IdentifierFactory.join(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [ts.factory.createIdentifier("input")],
+                ),
+                "map",
+            ),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                        IdentifierFactory.parameter(
+                            ts.factory.createArrayBindingPattern([
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "key",
+                                ),
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "value",
+                                ),
+                            ]),
+                        ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(statements),
+                ),
+            ],
+        );
+        const filtered = ts.factory.createCallExpression(
+            IdentifierFactory.join(mapped, "filter"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [IdentifierFactory.parameter("str")],
+                    undefined,
+                    undefined,
+                    ts.factory.createStrictInequality(
+                        ts.factory.createStringLiteral(""),
+                        ts.factory.createIdentifier("str"),
+                    ),
+                ),
+            ],
+        );
+        return ts.factory.createCallExpression(
+            IdentifierFactory.join(filtered, "join"),
+            undefined,
+            [ts.factory.createStringLiteral(",")],
+        );
+    };
+
+    // WHEN REGULAR PROPERTY EXISTS
+    if (regular.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(
+                        ts.factory.createArrayLiteralExpression(
+                            regular.map((key) =>
+                                ts.factory.createStringLiteral(key),
+                            ),
+                        ),
+                        "some",
+                    ),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [IdentifierFactory.parameter("regular")],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                ts.factory.createIdentifier("regular"),
+                                ts.factory.createIdentifier("key"),
+                            ),
+                        ),
+                    ],
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createStringLiteral(""),
+                ),
+            ),
+        );
+
+    // ONLY STRING TYPED KEY EXISTS
+    const simple: boolean =
+        dynamic.length === 1 &&
+        dynamic[0]!.key.size() === 1 &&
+        dynamic[0]!.key.atomics[0] === "string";
+    if (simple === true) {
+        statements.push(stringify(dynamic[0]!));
+        return output();
+    }
+
+    // COMPOSITE TEMPLATE LITERAL TYPES
+    for (const entry of dynamic) {
+        const condition: ts.IfStatement = ts.factory.createIfStatement(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+                ),
+                undefined,
+                [ts.factory.createIdentifier("key")],
+            ),
+            stringify(entry),
+        );
+        statements.push(condition);
+    }
+    return output();
+}
+
+function stringify(entry: IExpressionEntry): ts.ReturnStatement {
+    return ts.factory.createReturnStatement(
+        TemplateFactory.generate([
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("JSON.stringify"),
+                [],
+                [ts.factory.createIdentifier("key")],
+            ),
+            ts.factory.createStringLiteral(":"),
+            entry.expression,
+        ]),
+    );
+}

package/src/programmers/internal/stringify_native.ts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+
+/**
+ * @internal
+ */
+export function stringify_native(): ts.Expression {
+    return ts.factory.createStringLiteral("{}");
+}

package/src/programmers/internal/stringify_regular_properties.ts

@@ -0,0 +1,81 @@
+import ts from "typescript";
+
+import { TemplateFactory } from "../../factories/TemplateFactory";
+import { ValueFactory } from "../../factories/ValueFactory";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+
+/**
+ * @internal
+ */
+export function stringify_regular_properties(
+    regular: IExpressionEntry[],
+    dynamic: IExpressionEntry[],
+): ts.Expression[] {
+    const output: ts.Expression[] = [];
+
+    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+    regular.forEach((entry, index) => {
+        // BASE ELEMENTS
+        const key: string = entry.key.getSoleLiteral()!;
+        const base: ts.Expression[] = [
+            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+            entry.expression,
+        ];
+        if (index !== regular.length - 1 || dynamic.length !== 0)
+            base.push(ts.factory.createStringLiteral(`,`));
+
+        const empty: boolean =
+            (entry.meta.required === false &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 0) ||
+            (entry.meta.functional &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 1);
+
+        if (empty === true) return;
+        else if (
+            entry.meta.required === false ||
+            entry.meta.functional === true ||
+            entry.meta.any === true
+        )
+            output.push(
+                ts.factory.createConditionalExpression(
+                    (() => {
+                        const conditions: ts.BinaryExpression[] = [];
+                        if (entry.meta.required === false || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("undefined"),
+                                    entry.input,
+                                ),
+                            );
+                        if (entry.meta.functional || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createStringLiteral("function"),
+                                    ValueFactory.TYPEOF(entry.input),
+                                ),
+                            );
+                        return conditions.length === 1
+                            ? conditions[0]!
+                            : conditions.reduce((x, y) =>
+                                  ts.factory.createLogicalOr(x, y),
+                              );
+                    })(),
+                    undefined,
+                    ts.factory.createStringLiteral(""),
+                    undefined,
+                    TemplateFactory.generate(base),
+                ),
+            );
+        else output.push(...base);
+    });
+    return output;
+}
+
+function sequence(meta: Metadata): number {
+    return meta.any || !meta.required || meta.functional ? 0 : 1;
+}

package/src/programmers/internal/template_to_pattern.ts

@@ -0,0 +1,15 @@
+import { Metadata } from "../../metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const template_to_pattern = (top: boolean) => (template: Metadata[]) => {
+    const pattern: string = template
+        .map((meta) => metadata_to_pattern(false)(meta))
+        .join("");
+    return top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/schemas/IJsonApplication.ts

@@ -0,0 +1,9 @@
+import { IJsonComponents } from "./IJsonComponents";
+import { IJsonSchema } from "./IJsonSchema";
+
+export interface IJsonApplication {
+    schemas: IJsonSchema[];
+    components: IJsonComponents;
+    purpose: "swagger" | "ajv";
+    prefix: string;
+}

package/src/schemas/IJsonComponents.ts

@@ -0,0 +1,24 @@
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+
+import { IJsonSchema } from "./IJsonSchema";
+
+export interface IJsonComponents {
+    schemas: Record<string, IJsonComponents.IObject>;
+}
+export namespace IJsonComponents {
+    export interface IObject {
+        $id?: string;
+        type: "object";
+        nullable: boolean;
+
+        properties: Record<string, IJsonSchema>;
+        patternProperties?: Record<string, IJsonSchema>;
+        additionalProperties?: IJsonSchema;
+
+        required?: string[];
+        description?: string;
+        "x-typia_jsDocTags"?: IJsDocTagInfo[];
+
+        $recursiveAnchor?: boolean;
+    }
+}

package/src/schemas/IJsonSchema.ts

@@ -0,0 +1,92 @@
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../metadata/IMetadataTag";
+
+import { Atomic } from "../typings/Atomic";
+
+export type IJsonSchema = IJsonSchema.NotUnknown | IJsonSchema.IUnknown;
+export namespace IJsonSchema {
+    export type NotUnknown =
+        | IEnumeration<"boolean">
+        | IEnumeration<"number">
+        | IEnumeration<"bigint">
+        | IEnumeration<"string">
+        | IBoolean
+        | INumber
+        | IBigInt
+        | IString
+        | IArray
+        | ITuple
+        | IOneOf
+        | IReference
+        | IRecursiveReference
+        | INullOnly;
+
+    /* -----------------------------------------------------------
+        ATOMICS
+    ----------------------------------------------------------- */
+    export interface IEnumeration<Literal extends Atomic.Literal>
+        extends IAtomic<Literal> {
+        enum: Array<Atomic.Mapper[Literal]>;
+    }
+    export interface IAtomic<Literal extends Atomic.Literal>
+        extends ISignificant<Literal> {
+        default?: Atomic.Mapper[Literal];
+    }
+    export interface IString extends IAtomic<"string"> {
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        format?: string;
+    }
+    export interface INumber extends IAtomic<"number" | "integer"> {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: number;
+        exclusiveMaximum?: number;
+        multipleOf?: number;
+    }
+    export interface IBoolean extends IAtomic<"boolean"> {}
+    export interface IBigInt extends IAtomic<"bigint"> {}
+
+    /* -----------------------------------------------------------
+        OBJECTS
+    ----------------------------------------------------------- */
+    export interface IArray extends ISignificant<"array"> {
+        items: IJsonSchema;
+        minItems?: number;
+        maxItems?: number;
+    }
+    export interface ITuple extends ISignificant<"array"> {
+        items: IJsonSchema[];
+    }
+    export interface IReference extends IAttribute {
+        $ref: string;
+    }
+    export interface IRecursiveReference extends IAttribute {
+        $recursiveRef: string;
+    }
+    export interface INullOnly extends IAttribute {
+        type: "null";
+    }
+
+    /* -----------------------------------------------------------
+        MISCELLANEOUS
+    ----------------------------------------------------------- */
+    export interface IOneOf extends IAttribute {
+        oneOf: IJsonSchema[];
+    }
+    export interface IUnknown {}
+
+    export interface ISignificant<Literal extends string> extends IAttribute {
+        type: Literal;
+        nullable: boolean;
+    }
+    export interface IAttribute {
+        deprecated?: boolean;
+        title?: string;
+        description?: string;
+        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-required"?: boolean;
+    }
+}

package/src/transform.ts

@@ -0,0 +1,20 @@
+import ts from "typescript";
+
+import { FileTransformer } from "./transformers/FileTransformer";
+import { IProject } from "./transformers/IProject";
+import { ITransformOptions } from "./transformers/ITransformOptions";
+
+export default function transform(
+    program: ts.Program,
+    options?: ITransformOptions,
+): ts.TransformerFactory<ts.SourceFile> {
+    const project: IProject = {
+        program,
+        compilerOptions: program.getCompilerOptions(),
+        checker: program.getTypeChecker(),
+        printer: ts.createPrinter(),
+        options: options || {},
+    };
+    return (context) => (file) =>
+        FileTransformer.transform(project, context, file);
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -0,0 +1,124 @@
+import path from "path";
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
+import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
+import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
+import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
+import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
+import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
+import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
+import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
+import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
+import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
+import { CreateStringifyTransformer } from "./features/stringifiers/CreateStringifyTransformer";
+import { CreateValidateStringifyTransformer } from "./features/stringifiers/CreateValidateStringifyProgrammer";
+import { IsStringifyTransformer } from "./features/stringifiers/IsStringifyTransformer";
+import { StringifyTransformer } from "./features/stringifiers/StringifyTransformer";
+import { ValidateStringifyTransformer } from "./features/stringifiers/ValidateStringifyTransformer";
+import { AssertTransformer } from "./features/validators/AssertTransformer";
+import { CreateAssertTransformer } from "./features/validators/CreateAssertTransformer";
+import { CreateIsTransformer } from "./features/validators/CreateIsTransformer";
+import { CreateValidateTransformer } from "./features/validators/CreateValidateTransformer";
+import { IsTransformer } from "./features/validators/IsTransformer";
+import { ValidateTransformer } from "./features/validators/ValidateTransformer";
+
+export namespace CallExpressionTransformer {
+    export function transform(
+        project: IProject,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        //----
+        // VALIDATIONS
+        //----
+        // SIGNATURE DECLARATION
+        const declaration: ts.Declaration | undefined =
+            project.checker.getResolvedSignature(expression)?.declaration;
+        if (!declaration) return expression;
+
+        // FILE PATH
+        const file: string = path.resolve(declaration.getSourceFile().fileName);
+        if (file.indexOf(LIB_PATH) === -1 && file !== SRC_PATH)
+            return expression;
+
+        //----
+        // TRANSFORMATION
+        //----
+        // FUNCTION NAME
+        const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+
+        // FIND TRANSFORMER
+        const functor: (() => Task) | undefined = FUNCTORS[name];
+        if (functor === undefined) return expression;
+
+        // RETURNS WITH TRANSFORMATION
+        return functor()(project, expression.expression, expression);
+    }
+}
+
+type Task = (
+    project: IProject,
+    modulo: ts.LeftHandSideExpression,
+    expression: ts.CallExpression,
+) => ts.Expression;
+
+const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
+const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+
+const FUNCTORS: Record<string, () => Task> = {
+    //----
+    // SINGLE FUNCTIONS
+    //----
+    // BASIC VALIDATORS
+    assert: () => AssertTransformer.transform(false),
+    assertType: () => AssertTransformer.transform(false),
+    is: () => IsTransformer.transform(false),
+    validate: () => ValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
+    assertEquals: () => AssertTransformer.transform(true),
+    equals: () => IsTransformer.transform(true),
+    validateEquals: () => ValidateTransformer.transform(true),
+
+    // PARSE FUNCTIONS
+    isParse: () => IsParseTransformer.transform,
+    assertParse: () => AssertParseTransformer.transform,
+    validateParse: () => ValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
+    stringify: () => StringifyTransformer.transform,
+    assertStringify: () => AssertStringifyTransformer.transform,
+    isStringify: () => IsStringifyTransformer.transform,
+    validateStringify: () => ValidateStringifyTransformer.transform,
+
+    // MISC
+    application: () => ApplicationTransformer.transform,
+    metadata: () => MetadataTransformer.transform,
+
+    //----
+    // FACTORY FUNCTIONS
+    //----
+    // BASIC VALIDATORS
+    createAssert: () => CreateAssertTransformer.transform(false),
+    createAssertType: () => CreateAssertTransformer.transform(false),
+    createIs: () => CreateIsTransformer.transform(false),
+    createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
+    createAssertEquals: () => CreateAssertTransformer.transform(true),
+    createEquals: () => CreateIsTransformer.transform(true),
+    createValidateEquals: () => CreateValidateTransformer.transform(true),
+
+    // PARSE FUNCTIONS
+    createIsParse: () => CreateIsParseTransformer.transform,
+    createAssertParse: () => CreateAssertParseTransformer.transform,
+    createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
+    createStringify: () => CreateStringifyTransformer.transform,
+    createAssertStringify: () => CreateAssertStringifyTransformer.transform,
+    createIsStringify: () => CreateIsStringifyTransformer.transform,
+    createValidateStringify: () => CreateValidateStringifyTransformer.transform,
+};

package/src/transformers/ExpressionWithArgumentTransformer.ts

@@ -0,0 +1,66 @@
+// import path from "path";
+// import ts from "typescript";
+// import { AssertProgrammer } from "../programmers/AssertProgrammer";
+// import { IsProgrammer } from "../programmers/IsProgrammer";
+// import { StringifyProgrammer } from "../programmers/StringifyProgrammer";
+// import { IProject } from "../structures/IProject";
+
+// export namespace ExpressionWithArgumentTransformer {
+//     export function transform(
+//         project: IProject,
+//         expression: ts.ExpressionWithTypeArguments,
+//     ): ts.Expression {
+//         //----
+//         // VALIDATIONS
+//         //----
+//         // SYMBOL DECLARATION
+//         const symbol: ts.Symbol | undefined =
+//             project.checker.getSymbolAtLocation(expression.expression);
+//         const declaration: ts.Declaration | undefined = symbol?.declarations
+//             ? symbol.declarations[0]
+//             : undefined;
+//         if (!declaration) return expression;
+
+//         // FILE PATH
+//         const file: string = path.resolve(declaration.getSourceFile().fileName);
+//         if (file !== LIB_PATH && file !== SRC_PATH) return expression;
+
+//         // ARGUMENTS
+//         if (expression.typeArguments?.length !== 1) return expression;
+
+//         //----
+//         // TRANSFORMATION
+//         //----
+//         // GET MODULO AND TYPE
+//         const modulo: ts.LeftHandSideExpression = expression.expression;
+//         const type: ts.Type = project.checker.getTypeFromTypeNode(
+//             expression.typeArguments[0]!,
+//         );
+
+//         // FUNCTION NAME
+//         const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+
+//         // FIND TRANSFORMER
+//         const functor: (() => Task) | undefined = FUNCTORS[name];
+//         if (functor === undefined) return expression;
+
+//         // RETURNS WITH TRANSFORMATION
+//         return functor()(project, modulo, type);
+//     }
+// }
+
+// type Task = (
+//     project: IProject,
+//     modulo: ts.LeftHandSideExpression,
+//     type: ts.Type,
+// ) => ts.ArrowFunction;
+
+// const LIB_PATH = path.resolve(path.join(__dirname, "..", "module.d.ts"));
+// const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+
+// const FUNCTORS: Record<string, () => Task> = {
+//     assert: () => AssertProgrammer.generate,
+//     is: () => (project, _modulo, type) => IsProgrammer.generate(project, type),
+//     stringify: () => (project, modulo, type) =>
+//         StringifyProgrammer.generate(modulo)(project, type),
+// };

package/src/transformers/FileTransformer.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+    export function transform(
+        project: IProject,
+        context: ts.TransformationContext,
+        file: ts.SourceFile,
+    ): ts.SourceFile {
+        // DO NOT TRANSFORM D.TS FILE
+        if (file.isDeclarationFile) return file;
+
+        // ITERATE NODES
+        return ts.visitEachChild(
+            file,
+            (node) => iterate_node(project, context, node),
+            context,
+        );
+    }
+
+    function iterate_node(
+        project: IProject,
+        context: ts.TransformationContext,
+        node: ts.Node,
+    ): ts.Node {
+        return ts.visitEachChild(
+            try_transform_node(project, node),
+            (child) => iterate_node(project, context, child),
+            context,
+        );
+    }
+
+    function try_transform_node(project: IProject, node: ts.Node): ts.Node {
+        try {
+            return NodeTransformer.transform(project, node);
+        } catch (exp) {
+            if (!(exp instanceof Error)) throw exp;
+
+            const file: ts.SourceFile = node.getSourceFile();
+            const { line, character } = file.getLineAndCharacterOfPosition(
+                node.pos,
+            );
+            exp.message += ` - ${file.fileName}:${line + 1}:${character + 1}`;
+            throw exp;
+        }
+    }
+}

package/src/transformers/IProject.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+
+import { ITransformOptions } from "./ITransformOptions";
+
+export interface IProject {
+    program: ts.Program;
+    compilerOptions: ts.CompilerOptions;
+    checker: ts.TypeChecker;
+    printer: ts.Printer;
+    options: ITransformOptions;
+}

package/src/transformers/ITransformOptions.ts

@@ -0,0 +1,4 @@
+export interface ITransformOptions {
+    functional?: boolean | "checker" | "stringify";
+    numeric?: boolean | "checker" | "stringify";
+}