@nestia/sdk 2.3.0-dev.20231018-4 → 2.3.0-dev.20231019

package/src/analyses/ControllerAnalyzer.ts

@@ -7,9 +7,11 @@ import { CommentFactory } from "typia/lib/factories/CommentFactory";
 
 import { INestiaConfig } from "../INestiaConfig";
 import { IController } from "../structures/IController";
+import { INormalizedInput } from "../structures/INormalizedInput";
 import { IRoute } from "../structures/IRoute";
 import { ITypeTuple } from "../structures/ITypeTuple";
 import { PathUtil } from "../utils/PathUtil";
+import { ConfigAnalyzer } from "./ConfigAnalyzer";
 import { ExceptionAnalyzer } from "./ExceptionAnalyzer";
 import { GenericAnalyzer } from "./GenericAnalyzer";
 import { ImportAnalyzer } from "./ImportAnalyzer";
@@ -17,14 +19,16 @@ import { PathAnalyzer } from "./PathAnalyzer";
 import { SecurityAnalyzer } from "./SecurityAnalyzer";
 
 export namespace ControllerAnalyzer {
-    export function analyze(
+    export async function analyze(
         config: INestiaConfig,
         checker: ts.TypeChecker,
         sourceFile: ts.SourceFile,
         controller: IController,
-    ): IRoute[] {
+    ): Promise<IRoute[]> {
         // FIND CONTROLLER CLASS
+        const input: INormalizedInput = await ConfigAnalyzer.input(config);
         const ret: IRoute[] = [];
+
         ts.forEachChild(sourceFile, (node) => {
             if (
                 ts.isClassDeclaration(node) &&
@@ -32,7 +36,13 @@ export namespace ControllerAnalyzer {
             ) {
                 // ANALYZE THE CONTROLLER
                 ret.push(
-                    ..._Analyze_controller(config, checker, controller, node),
+                    ..._Analyze_controller(
+                        config,
+                        input,
+                        checker,
+                        controller,
+                        node,
+                    ),
                 );
                 return;
             }
@@ -45,6 +55,7 @@ export namespace ControllerAnalyzer {
     --------------------------------------------------------- */
     function _Analyze_controller(
         config: INestiaConfig,
+        input: INormalizedInput,
         checker: ts.TypeChecker,
         controller: IController,
         classNode: ts.ClassDeclaration,
@@ -77,6 +88,7 @@ export namespace ControllerAnalyzer {
 
             const routes: IRoute[] = _Analyze_function(
                 config,
+                input,
                 checker,
                 controller,
                 genericDict,
@@ -94,6 +106,7 @@ export namespace ControllerAnalyzer {
     --------------------------------------------------------- */
     function _Analyze_function(
         config: INestiaConfig,
+        input: INormalizedInput,
         checker: ts.TypeChecker,
         controller: IController,
         genericDict: GenericAnalyzer.Dictionary,
@@ -115,9 +128,8 @@ export namespace ControllerAnalyzer {
                 `Error on ControllerAnalyzer.analyze(): unable to get the signature from the ${controller.name}.${func.name}().`,
             );
 
-        const importDict: ImportAnalyzer.Dictionary = new HashMap();
-
         // EXPLORE CHILDREN TYPES
+        const importDict: ImportAnalyzer.Dictionary = new HashMap();
         const parameters: IRoute.IParameter[] = func.parameters.map((param) =>
             _Analyze_parameter(
                 checker,
@@ -205,7 +217,7 @@ export namespace ControllerAnalyzer {
             description: CommentFactory.description(symbol),
             operationId: jsDocTags
                 .find(({ name }) => name === "operationId")
-                ?.text!?.[0].text.split(" ")[0]
+                ?.text?.[0].text.split(" ")[0]
                 .trim(),
             jsDocTags: jsDocTags,
             setHeaders: jsDocTags
@@ -232,22 +244,23 @@ export namespace ControllerAnalyzer {
         };
 
         // CONFIGURE PATHS
-        const input: INestiaConfig.IInput =
-            config.input as INestiaConfig.IInput;
         const pathList: Set<string> = new Set();
         const versions: Array<string | null> = _Analyze_versions(
-            func.versions ??
-                controller.versions ??
-                (input.versioning?.defaultVersion !== undefined
-                    ? Array.isArray(input.versioning?.defaultVersion)
-                        ? input.versioning?.defaultVersion
-                        : [input.versioning?.defaultVersion]
-                    : undefined) ??
-                undefined,
+            input.versioning === undefined
+                ? undefined
+                : func.versions ??
+                      controller.versions ??
+                      (input.versioning?.defaultVersion !== undefined
+                          ? Array.isArray(input.versioning?.defaultVersion)
+                              ? input.versioning?.defaultVersion
+                              : [input.versioning?.defaultVersion]
+                          : undefined) ??
+                      undefined,
         );
-        for (const cPath of controller.paths)
-            for (const filePath of func.paths)
-                pathList.add(PathAnalyzer.join(cPath, filePath));
+        for (const prefix of controller.prefixes)
+            for (const cPath of controller.paths)
+                for (const filePath of func.paths)
+                    pathList.add(PathAnalyzer.join(prefix, cPath, filePath));
 
         return [...pathList]
             .map((individual) =>

package/src/analyses/PathAnalyzer.ts

@@ -1,11 +1,12 @@
+import { RequestMethod } from "@nestjs/common";
 import path from "path";
 import { Token, parse } from "path-to-regexp";
 
-import { INestiaConfig } from "../INestiaConfig";
+import { INormalizedInput } from "../structures/INormalizedInput";
 
 export namespace PathAnalyzer {
     export const combinate =
-        (globalPrefix: INestiaConfig.IInput["globalPrefix"]) =>
+        (globalPrefix: INormalizedInput["globalPrefix"]) =>
         (versions: Array<string | null>) =>
         (props: { path: string; method: string }): string[] => {
             const out = (str: string) =>
@@ -18,7 +19,7 @@ export namespace PathAnalyzer {
             return globalPrefix.exclude.some((exclude) =>
                 typeof exclude === "string"
                     ? RegExp(exclude).test(props.path)
-                    : (exclude.method as string) === props.method &&
+                    : METHOD(exclude.method) === props.method &&
                       RegExp(exclude.path).test(props.path),
             )
                 ? out(props.path)
@@ -79,3 +80,21 @@ export namespace PathAnalyzer {
 }
 
 const ERROR_MESSAGE = "nestia supports only string typed parameter on path";
+const METHOD = (value: RequestMethod) =>
+    value === RequestMethod.ALL
+        ? "all"
+        : value === RequestMethod.DELETE
+        ? "delete"
+        : value === RequestMethod.GET
+        ? "get"
+        : value === RequestMethod.HEAD
+        ? "head"
+        : value === RequestMethod.OPTIONS
+        ? "options"
+        : value === RequestMethod.PATCH
+        ? "patch"
+        : value === RequestMethod.POST
+        ? "post"
+        : value === RequestMethod.PUT
+        ? "put"
+        : "unknown";

package/src/analyses/ReflectAnalyzer.ts

@@ -17,6 +17,8 @@ export namespace ReflectAnalyzer {
     export async function analyze(
         unique: WeakSet<any>,
         file: string,
+        prefixes: string[],
+        target?: Function,
     ): Promise<IController[]> {
         const module: IModule = await (async () => {
             try {
@@ -37,14 +39,16 @@ export namespace ReflectAnalyzer {
 
         for (const [key, value] of Object.entries(module)) {
             if (typeof value !== "function" || unique.has(value)) continue;
+            else if ((target ?? value) !== value) continue;
             else unique.add(value);
 
-            const controller: IController | null = _Analyze_controller(
+            const result: IController | null = _Analyze_controller(
                 file,
                 key,
                 value,
+                prefixes,
             );
-            if (controller !== null) ret.push(controller);
+            if (result !== null) ret.push(result);
         }
         return ret;
     }
@@ -56,6 +60,7 @@ export namespace ReflectAnalyzer {
         file: string,
         name: string,
         creator: any,
+        prefixes: string[],
     ): IController | null {
         //----
         // VALIDATIONS
@@ -87,6 +92,7 @@ export namespace ReflectAnalyzer {
             file,
             name,
             functions: [],
+            prefixes,
             paths: _Get_paths(creator),
             versions: _Get_versions(creator),
             security: _Get_securities(creator),

package/src/executable/internal/NestiaConfigLoader.ts

@@ -71,7 +71,9 @@ export namespace NestiaConfigLoader {
     export const project = async (file: string): Promise<string> => {
         const connector = new WorkerConnector(null, null, "process");
         await connector.connect(
-            `${__dirname}/nestia.project.getter.${__filename.substr(-2)}`,
+            `${__dirname}/nestia.project.getter.${__filename.substring(
+                __filename.length - 2,
+            )}`,
         );
 
         const driver = await connector.getDriver<typeof NestiaProjectGetter>();

package/src/generates/E2eGenerator.ts

@@ -53,7 +53,7 @@ export namespace E2eGenerator {
                 output,
                 content.replace(
                     "${input}",
-                    JSON.stringify(await ConfigAnalyzer.input(config.input)),
+                    JSON.stringify(await ConfigAnalyzer.input(config)),
                 ),
                 "utf8",
             );

package/src/generates/SwaggerGenerator.ts

@@ -1,5 +1,4 @@
 import fs from "fs";
-import NodePath from "path";
 import path from "path";
 import { Singleton } from "tstl/thread/Singleton";
 import ts from "typescript";
@@ -41,8 +40,8 @@ export namespace SwaggerGenerator {
             validate_security(config)(routeList);
 
             // PREPARE ASSETS
-            const parsed: NodePath.ParsedPath = NodePath.parse(config.output);
-            const directory: string = NodePath.dirname(parsed.dir);
+            const parsed: path.ParsedPath = path.parse(config.output);
+            const directory: string = path.dirname(parsed.dir);
             if (fs.existsSync(directory) === false)
                 try {
                     await fs.promises.mkdir(directory);
@@ -53,11 +52,8 @@ export namespace SwaggerGenerator {
                 );
 
             const location: string = !!parsed.ext
-                ? NodePath.resolve(config.output)
-                : NodePath.join(
-                      NodePath.resolve(config.output),
-                      "swagger.json",
-                  );
+                ? path.resolve(config.output)
+                : path.join(path.resolve(config.output), "swagger.json");
 
             const collection: MetadataCollection = new MetadataCollection({
                 replace: MetadataCollection.replace,

package/src/structures/IController.ts

@@ -5,6 +5,7 @@ import type { ParamCategory } from "./ParamCategory";
 export interface IController {
     file: string;
     name: string;
+    prefixes: string[];
     paths: string[];
     versions:
         | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>

package/src/structures/INormalizedInput.ts

@@ -0,0 +1,20 @@
+import { RouteInfo, VersionValue } from "@nestjs/common/interfaces";
+
+export interface INormalizedInput {
+    include: INormalizedInput.IInput[];
+    globalPrefix?: {
+        prefix: string;
+        exclude?: Array<string | RouteInfo>;
+    };
+    versioning?: {
+        prefix: string;
+        defaultVersion?: VersionValue;
+    };
+}
+export namespace INormalizedInput {
+    export interface IInput {
+        paths: string[];
+        file: string;
+        controller?: Function;
+    }
+}

package/src/utils/SourceFinder.ts

@@ -3,6 +3,12 @@ import glob from "glob";
 import path from "path";
 
 export namespace SourceFinder {
+    interface IProps {
+        exclude?: string[];
+        include: string[];
+        filter: (location: string) => Promise<boolean>;
+    }
+
     export const find = async (props: IProps): Promise<string[]> => {
         const dict: Set<string> = new Set();
 
@@ -16,7 +22,7 @@ export namespace SourceFinder {
     };
 
     const emplace =
-        (filter: (file: string) => boolean) =>
+        (filter: (file: string) => Promise<boolean>) =>
         (input: string[]) =>
         async (closure: (location: string) => void): Promise<void> => {
             for (const pattern of input) {
@@ -28,13 +34,14 @@ export namespace SourceFinder {
                     const stats: fs.Stats = await fs.promises.stat(file);
                     if (stats.isDirectory() === true)
                         await iterate(filter)(closure)(file);
-                    else if (stats.isFile() && filter(file)) closure(file);
+                    else if (stats.isFile() && (await filter(file)))
+                        closure(file);
                 }
             }
         };
 
     const iterate =
-        (filter: (location: string) => boolean) =>
+        (filter: (location: string) => Promise<boolean>) =>
         (closure: (location: string) => void) =>
         async (location: string): Promise<void> => {
             const directory: string[] = await fs.promises.readdir(location);
@@ -44,7 +51,7 @@ export namespace SourceFinder {
 
                 if (stats.isDirectory() === true)
                     await iterate(filter)(closure)(next);
-                else if (stats.isFile() && filter(next)) closure(next);
+                else if (stats.isFile() && (await filter(next))) closure(next);
             }
         };
 
@@ -61,9 +68,3 @@ export namespace SourceFinder {
         !pattern.endsWith(".d.ts") &&
         fs.existsSync(pattern);
 }
-
-interface IProps {
-    exclude?: string[];
-    include: string[];
-    filter: (location: string) => boolean;
-}