@nestia/core 0.1.5 → 0.1.7

package/src/options/INestiaTransformProject.ts

@@ -1,7 +1,7 @@
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformOptions } from "./INestiaTransformOptions";
-
-export interface INestiaTransformProject extends Omit<IProject, "options"> {
-    options: INestiaTransformOptions;
-}
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformOptions } from "./INestiaTransformOptions";
+
+export interface INestiaTransformProject extends Omit<IProject, "options"> {
+    options: INestiaTransformOptions;
+}

package/src/options/IRequestBodyValidator.ts

@@ -1,20 +1,20 @@
-import { IValidation } from "typia";
-
-export type IRequestBodyValidator<T> =
-    | IRequestBodyValidator.IAssert<T>
-    | IRequestBodyValidator.IIs<T>
-    | IRequestBodyValidator.IValidate<T>;
-export namespace IRequestBodyValidator {
-    export interface IAssert<T> {
-        type: "assert";
-        assert: (input: T) => T;
-    }
-    export interface IIs<T> {
-        type: "is";
-        is: (input: T) => boolean;
-    }
-    export interface IValidate<T> {
-        type: "validate";
-        validate: (input: T) => IValidation<T>;
-    }
-}
+import { IValidation } from "typia";
+
+export type IRequestBodyValidator<T> =
+    | IRequestBodyValidator.IAssert<T>
+    | IRequestBodyValidator.IIs<T>
+    | IRequestBodyValidator.IValidate<T>;
+export namespace IRequestBodyValidator {
+    export interface IAssert<T> {
+        type: "assert";
+        assert: (input: T) => T;
+    }
+    export interface IIs<T> {
+        type: "is";
+        is: (input: T) => boolean;
+    }
+    export interface IValidate<T> {
+        type: "validate";
+        validate: (input: T) => IValidation<T>;
+    }
+}

package/src/options/IResponseBodyStringifier.ts

@@ -1,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-    | IResponseBodyStringifier.IStringify<T>
-    | IResponseBodyStringifier.IIs<T>
-    | IResponseBodyStringifier.IAssert<T>
-    | IResponseBodyStringifier.IValidate<T>;
-export namespace IResponseBodyStringifier {
-    export interface IStringify<T> {
-        type: "stringify";
-        stringify: (input: T) => string;
-    }
-    export interface IIs<T> {
-        type: "is";
-        is: (input: T) => string | null;
-    }
-    export interface IAssert<T> {
-        type: "assert";
-        assert: (input: T) => string;
-    }
-    export interface IValidate<T> {
-        type: "validate";
-        validate: (input: T) => IValidation<string>;
-    }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+    | IResponseBodyStringifier.IStringify<T>
+    | IResponseBodyStringifier.IIs<T>
+    | IResponseBodyStringifier.IAssert<T>
+    | IResponseBodyStringifier.IValidate<T>;
+export namespace IResponseBodyStringifier {
+    export interface IStringify<T> {
+        type: "stringify";
+        stringify: (input: T) => string;
+    }
+    export interface IIs<T> {
+        type: "is";
+        is: (input: T) => string | null;
+    }
+    export interface IAssert<T> {
+        type: "assert";
+        assert: (input: T) => string;
+    }
+    export interface IValidate<T> {
+        type: "validate";
+        validate: (input: T) => IValidation<string>;
+    }
+}

package/src/transform.ts

@@ -1,20 +1,20 @@
-import ts from "typescript";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
-import { FileTransformer } from "./transformers/FileTransformer";
-
-export default function transform(
-    program: ts.Program,
-    options?: INestiaTransformOptions,
-): 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);
-}
+import ts from "typescript";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
+import { FileTransformer } from "./transformers/FileTransformer";
+
+export default function transform(
+    program: ts.Program,
+    options?: INestiaTransformOptions,
+): 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/BodyTransformer.ts

@@ -1,106 +1,106 @@
-import path from "path";
-import ts from "typescript";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace BodyTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        decorator: ts.Decorator,
-    ): ts.Decorator {
-        if (!ts.isCallExpression(decorator.expression)) return decorator;
-        return ts.factory.createDecorator(
-            validate(project, type, decorator.expression),
-        );
-    }
-
-    function validate(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        expression: ts.CallExpression,
-    ): ts.LeftHandSideExpression {
-        // CHECK SIGNATURE
-        const signature: ts.Signature | undefined =
-            project.checker.getResolvedSignature(expression);
-        if (!signature || !signature.declaration) return expression;
-
-        // CHECK TO BE TRANSFORMED
-        const validate: boolean = (() => {
-            // CHECK FILENAME
-            const location: string = path.resolve(
-                signature.declaration.getSourceFile().fileName,
-            );
-            if (
-                LIB_PATHS.every((str) => location.indexOf(str) === -1) &&
-                SRC_PATHS.every((str) => location !== str)
-            )
-                return false;
-
-            // CHECK DUPLICATED TRANSFORMATION
-            return expression.arguments.length === 0;
-        })();
-        if (validate === false) return expression;
-
-        // CHECK TYPE NODE
-        const typeNode: ts.TypeNode | undefined =
-            project.checker.typeToTypeNode(type, undefined, undefined);
-        if (typeNode === undefined) return expression;
-
-        //----
-        // TRANSFORMATION
-        //----
-        // GENERATE VALIDATION PLAN
-        const parameter = (
-            key: string,
-            programmer: (
-                project: IProject,
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type) => ts.ArrowFunction,
-        ) =>
-            ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(
-                    ts.factory.createIdentifier("type"),
-                    ts.factory.createStringLiteral(key),
-                ),
-                ts.factory.createPropertyAssignment(
-                    ts.factory.createIdentifier(key),
-                    programmer(project, expression.expression)(type),
-                ),
-            ]);
-        const validator: ts.ObjectLiteralExpression = (() => {
-            if (project.options.validate === "is")
-                return parameter("is", IsProgrammer.generate);
-            else if (project.options.validate === "validate")
-                return parameter("validate", ValidateProgrammer.generate);
-            return parameter("assert", AssertProgrammer.generate);
-        })();
-
-        // UPDATE DECORATOR FUNCTION CALL
-        return ts.factory.updateCallExpression(
-            expression,
-            expression.expression,
-            expression.typeArguments,
-            [validator],
-        );
-    }
-
-    const CLASSES = ["EncryptedBody", "TypedBody"];
-    const LIB_PATHS = CLASSES.map((cla) =>
-        path.join(
-            "node_modules",
-            "@nestia",
-            "core",
-            "lib",
-            "decorators",
-            `${cla}.d.ts`,
-        ),
-    );
-    const SRC_PATHS = CLASSES.map((cla) =>
-        path.resolve(path.join(__dirname, "..", "decorators", `${cla}.ts`)),
-    );
-}
+import path from "path";
+import ts from "typescript";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace BodyTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        decorator: ts.Decorator,
+    ): ts.Decorator {
+        if (!ts.isCallExpression(decorator.expression)) return decorator;
+        return ts.factory.createDecorator(
+            validate(project, type, decorator.expression),
+        );
+    }
+
+    function validate(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        expression: ts.CallExpression,
+    ): ts.LeftHandSideExpression {
+        // CHECK SIGNATURE
+        const signature: ts.Signature | undefined =
+            project.checker.getResolvedSignature(expression);
+        if (!signature || !signature.declaration) return expression;
+
+        // CHECK TO BE TRANSFORMED
+        const validate: boolean = (() => {
+            // CHECK FILENAME
+            const location: string = path.resolve(
+                signature.declaration.getSourceFile().fileName,
+            );
+            if (
+                LIB_PATHS.every((str) => location.indexOf(str) === -1) &&
+                SRC_PATHS.every((str) => location !== str)
+            )
+                return false;
+
+            // CHECK DUPLICATED TRANSFORMATION
+            return expression.arguments.length === 0;
+        })();
+        if (validate === false) return expression;
+
+        // CHECK TYPE NODE
+        const typeNode: ts.TypeNode | undefined =
+            project.checker.typeToTypeNode(type, undefined, undefined);
+        if (typeNode === undefined) return expression;
+
+        //----
+        // TRANSFORMATION
+        //----
+        // GENERATE VALIDATION PLAN
+        const parameter = (
+            key: string,
+            programmer: (
+                project: IProject,
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type) => ts.ArrowFunction,
+        ) =>
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("type"),
+                    ts.factory.createStringLiteral(key),
+                ),
+                ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier(key),
+                    programmer(project, expression.expression)(type),
+                ),
+            ]);
+        const validator: ts.ObjectLiteralExpression = (() => {
+            if (project.options.validate === "is")
+                return parameter("is", IsProgrammer.generate);
+            else if (project.options.validate === "validate")
+                return parameter("validate", ValidateProgrammer.generate);
+            return parameter("assert", AssertProgrammer.generate);
+        })();
+
+        // UPDATE DECORATOR FUNCTION CALL
+        return ts.factory.updateCallExpression(
+            expression,
+            expression.expression,
+            expression.typeArguments,
+            [validator],
+        );
+    }
+
+    const CLASSES = ["EncryptedBody", "TypedBody"];
+    const LIB_PATHS = CLASSES.map((cla) =>
+        path.join(
+            "node_modules",
+            "@nestia",
+            "core",
+            "lib",
+            "decorators",
+            `${cla}.d.ts`,
+        ),
+    );
+    const SRC_PATHS = CLASSES.map((cla) =>
+        path.resolve(path.join(__dirname, "..", "decorators", `${cla}.ts`)),
+    );
+}

package/src/transformers/FileTransformer.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { NodeTransformer } from "./NodeTransformer";
-
-export namespace FileTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        context: ts.TransformationContext,
-        file: ts.SourceFile,
-    ): ts.SourceFile {
-        // ITERATE NODES
-        return ts.visitEachChild(
-            file,
-            (node) => iterate_node(project, context, node),
-            context,
-        );
-    }
-
-    function iterate_node(
-        project: INestiaTransformProject,
-        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: INestiaTransformProject,
-        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;
-        }
-    }
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        context: ts.TransformationContext,
+        file: ts.SourceFile,
+    ): ts.SourceFile {
+        // ITERATE NODES
+        return ts.visitEachChild(
+            file,
+            (node) => iterate_node(project, context, node),
+            context,
+        );
+    }
+
+    function iterate_node(
+        project: INestiaTransformProject,
+        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: INestiaTransformProject,
+        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/MethodTransformer.ts

@@ -1,91 +1,91 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { RouteTransformer } from "./RouteTransformer";
-
-export namespace MethodTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        method: ts.MethodDeclaration,
-    ): ts.MethodDeclaration {
-        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-            ? ts.getDecorators(method)
-            : (method as any).decorators;
-        if (!decorators?.length) return method;
-
-        const signature: ts.Signature | undefined =
-            project.checker.getSignatureFromDeclaration(method);
-        const original: ts.Type | undefined =
-            signature && project.checker.getReturnTypeOfSignature(signature);
-        const escaped: ts.Type | undefined =
-            original && get_escaped_type(project.checker, original);
-
-        if (escaped === undefined) return method;
-
-        if (ts.getDecorators !== undefined)
-            return ts.factory.updateMethodDeclaration(
-                method,
-                (method.modifiers || []).map((mod) =>
-                    ts.isDecorator(mod)
-                        ? RouteTransformer.transform(project, escaped, mod)
-                        : mod,
-                ),
-                method.asteriskToken,
-                method.name,
-                method.questionToken,
-                method.typeParameters,
-                method.parameters,
-                method.type,
-                method.body,
-            );
-        // eslint-disable-next-line
-        return ts.factory.updateMethodDeclaration(
-            method,
-            decorators.map((deco) =>
-                RouteTransformer.transform(project, escaped, deco),
-            ),
-            (method as any).modifiers,
-            method.asteriskToken,
-            method.name,
-            method.questionToken,
-            method.typeParameters,
-            method.parameters,
-            method.type,
-            method.body,
-        );
-    }
-}
-
-function get_escaped_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
-    return symbol && get_name(symbol) === "Promise"
-        ? escape_promise(checker, type)
-        : type;
-}
-
-function escape_promise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-    const generic: readonly ts.Type[] = checker.getTypeArguments(
-        type as ts.TypeReference,
-    );
-    if (generic.length !== 1)
-        throw new Error(
-            "Error on ImportAnalyzer.analyze(): invalid promise type.",
-        );
-    return generic[0];
-}
-
-function get_name(symbol: ts.Symbol): string {
-    return explore_name(
-        symbol.escapedName.toString(),
-        symbol.getDeclarations()![0].parent,
-    );
-}
-
-function explore_name(name: string, decl: ts.Node): string {
-    return ts.isModuleBlock(decl)
-        ? explore_name(
-              `${decl.parent.name.getText()}.${name}`,
-              decl.parent.parent,
-          )
-        : name;
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { RouteTransformer } from "./RouteTransformer";
+
+export namespace MethodTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        method: ts.MethodDeclaration,
+    ): ts.MethodDeclaration {
+        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+            ? ts.getDecorators(method)
+            : (method as any).decorators;
+        if (!decorators?.length) return method;
+
+        const signature: ts.Signature | undefined =
+            project.checker.getSignatureFromDeclaration(method);
+        const original: ts.Type | undefined =
+            signature && project.checker.getReturnTypeOfSignature(signature);
+        const escaped: ts.Type | undefined =
+            original && get_escaped_type(project.checker, original);
+
+        if (escaped === undefined) return method;
+
+        if (ts.getDecorators !== undefined)
+            return ts.factory.updateMethodDeclaration(
+                method,
+                (method.modifiers || []).map((mod) =>
+                    ts.isDecorator(mod)
+                        ? RouteTransformer.transform(project, escaped, mod)
+                        : mod,
+                ),
+                method.asteriskToken,
+                method.name,
+                method.questionToken,
+                method.typeParameters,
+                method.parameters,
+                method.type,
+                method.body,
+            );
+        // eslint-disable-next-line
+        return ts.factory.updateMethodDeclaration(
+            method,
+            decorators.map((deco) =>
+                RouteTransformer.transform(project, escaped, deco),
+            ),
+            (method as any).modifiers,
+            method.asteriskToken,
+            method.name,
+            method.questionToken,
+            method.typeParameters,
+            method.parameters,
+            method.type,
+            method.body,
+        );
+    }
+}
+
+function get_escaped_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
+    return symbol && get_name(symbol) === "Promise"
+        ? escape_promise(checker, type)
+        : type;
+}
+
+function escape_promise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const generic: readonly ts.Type[] = checker.getTypeArguments(
+        type as ts.TypeReference,
+    );
+    if (generic.length !== 1)
+        throw new Error(
+            "Error on ImportAnalyzer.analyze(): invalid promise type.",
+        );
+    return generic[0];
+}
+
+function get_name(symbol: ts.Symbol): string {
+    return explore_name(
+        symbol.escapedName.toString(),
+        symbol.getDeclarations()![0].parent,
+    );
+}
+
+function explore_name(name: string, decl: ts.Node): string {
+    return ts.isModuleBlock(decl)
+        ? explore_name(
+              `${decl.parent.name.getText()}.${name}`,
+              decl.parent.parent,
+          )
+        : name;
+}