@nestia/core 0.1.4 → 0.1.5

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;
+}

package/src/transformers/NodeTransformer.ts

@@ -1,18 +1,18 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { MethodTransformer } from "./MethodTransformer";
-import { ParameterTransformer } from "./ParameterTransformer";
-
-export namespace NodeTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        node: ts.Node,
-    ): ts.Node {
-        if (ts.isMethodDeclaration(node))
-            return MethodTransformer.transform(project, node);
-        else if (ts.isParameter(node))
-            return ParameterTransformer.transform(project, node);
-        return node;
-    }
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { MethodTransformer } from "./MethodTransformer";
+import { ParameterTransformer } from "./ParameterTransformer";
+
+export namespace NodeTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        node: ts.Node,
+    ): ts.Node {
+        if (ts.isMethodDeclaration(node))
+            return MethodTransformer.transform(project, node);
+        else if (ts.isParameter(node))
+            return ParameterTransformer.transform(project, node);
+        return node;
+    }
+}

package/src/transformers/ParameterTransformer.ts

@@ -1,45 +1,45 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { BodyTransformer } from "./BodyTransformer";
-
-export namespace ParameterTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        param: ts.ParameterDeclaration,
-    ): ts.ParameterDeclaration {
-        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-            ? ts.getDecorators(param)
-            : (param as any).decorators;
-        if (!decorators?.length) return param;
-
-        const type: ts.Type = project.checker.getTypeAtLocation(param);
-        if (ts.getDecorators !== undefined)
-            return ts.factory.updateParameterDeclaration(
-                param,
-                (param.modifiers || []).map((mod) =>
-                    ts.isDecorator(mod)
-                        ? BodyTransformer.transform(project, type, mod)
-                        : mod,
-                ),
-                param.dotDotDotToken,
-                param.name,
-                param.questionToken,
-                param.type,
-                param.initializer,
-            );
-        // eslint-disable-next-line
-        return ts.factory.updateParameterDeclaration(
-            param,
-            decorators.map((deco) =>
-                BodyTransformer.transform(project, type, deco),
-            ),
-            (param as any).modifiers,
-            param.dotDotDotToken,
-            param.name,
-            param.questionToken,
-            param.type,
-            param.initializer,
-        );
-    }
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { BodyTransformer } from "./BodyTransformer";
+
+export namespace ParameterTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        param: ts.ParameterDeclaration,
+    ): ts.ParameterDeclaration {
+        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+            ? ts.getDecorators(param)
+            : (param as any).decorators;
+        if (!decorators?.length) return param;
+
+        const type: ts.Type = project.checker.getTypeAtLocation(param);
+        if (ts.getDecorators !== undefined)
+            return ts.factory.updateParameterDeclaration(
+                param,
+                (param.modifiers || []).map((mod) =>
+                    ts.isDecorator(mod)
+                        ? BodyTransformer.transform(project, type, mod)
+                        : mod,
+                ),
+                param.dotDotDotToken,
+                param.name,
+                param.questionToken,
+                param.type,
+                param.initializer,
+            );
+        // eslint-disable-next-line
+        return ts.factory.updateParameterDeclaration(
+            param,
+            decorators.map((deco) =>
+                BodyTransformer.transform(project, type, deco),
+            ),
+            (param as any).modifiers,
+            param.dotDotDotToken,
+            param.name,
+            param.questionToken,
+            param.type,
+            param.initializer,
+        );
+    }
+}