@nestia/sdk 3.0.5-dev.20240418 → 3.1.0-dev.20240426

package/src/NestiaSdkApplication.ts

@@ -5,15 +5,16 @@ import ts from "typescript";
 import { INestiaConfig } from "./INestiaConfig";
 import { AccessorAnalyzer } from "./analyses/AccessorAnalyzer";
 import { ConfigAnalyzer } from "./analyses/ConfigAnalyzer";
-import { ControllerAnalyzer } from "./analyses/ControllerAnalyzer";
-import { ReflectAnalyzer } from "./analyses/ReflectAnalyzer";
+import { ReflectControllerAnalyzer } from "./analyses/ReflectControllerAnalyzer";
+import { TypedControllerAnalyzer } from "./analyses/TypedControllerAnalyzer";
 import { E2eGenerator } from "./generates/E2eGenerator";
 import { SdkGenerator } from "./generates/SdkGenerator";
 import { SwaggerGenerator } from "./generates/SwaggerGenerator";
-import { IController } from "./structures/IController";
 import { IErrorReport } from "./structures/IErrorReport";
 import { INestiaProject } from "./structures/INestiaProject";
-import { IRoute } from "./structures/IRoute";
+import { IReflectController } from "./structures/IReflectController";
+import { ITypedHttpRoute } from "./structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "./structures/ITypedWebSocketRoute";
 import { MapUtil } from "./utils/MapUtil";
 
 export class NestiaSdkApplication {
@@ -46,14 +47,12 @@ export class NestiaSdkApplication {
     await validate("e2e")(this.config.e2e);
 
     print_title("Nestia E2E Generator");
-    await this.generate(
-      "e2e",
-      (config) => config,
-      (checker) => (config) => async (routes) => {
-        await SdkGenerator.generate(checker)(config)(routes);
-        await E2eGenerator.generate(checker)(config)(routes);
-      },
-    );
+    await this.generate("e2e", (project) => async (routes) => {
+      await SdkGenerator.generate(project)(routes);
+      await E2eGenerator.generate(project)(
+        routes.filter((r) => r.protocol === "http") as ITypedHttpRoute[],
+      );
+    });
   }
 
   public async sdk(): Promise<void> {
@@ -70,7 +69,7 @@ export class NestiaSdkApplication {
       );
 
     print_title("Nestia SDK Generator");
-    await this.generate("sdk", (config) => config, SdkGenerator.generate);
+    await this.generate("sdk", SdkGenerator.generate);
   }
 
   public async swagger(): Promise<void> {
@@ -90,25 +89,22 @@ export class NestiaSdkApplication {
       );
 
     print_title("Nestia Swagger Generator");
-    await this.generate(
-      "swagger",
-      (config) => config.swagger!,
-      SwaggerGenerator.generate,
-    );
+    await this.generate("swagger", SwaggerGenerator.generate);
   }
 
-  private async generate<Config>(
+  private async generate(
     method: string,
-    config: (entire: INestiaConfig) => Config,
     archiver: (
-      checker: ts.TypeChecker,
-    ) => (config: Config) => (routes: IRoute[]) => Promise<void>,
+      project: INestiaProject,
+    ) => (
+      routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+    ) => Promise<void>,
   ): Promise<void> {
     //----
     // ANALYZE REFLECTS
     //----
     const unique: WeakSet<any> = new WeakSet();
-    const controllers: IController[] = [];
+    const controllers: IReflectController[] = [];
     const project: INestiaProject = {
       config: this.config,
       input: await ConfigAnalyzer.input(this.config),
@@ -120,7 +116,7 @@ export class NestiaSdkApplication {
     console.log("Analyzing reflections");
     for (const include of (await ConfigAnalyzer.input(this.config)).include)
       controllers.push(
-        ...(await ReflectAnalyzer.analyze(project)(
+        ...(await ReflectControllerAnalyzer.analyze(project)(
           unique,
           include.file,
           include.paths,
@@ -132,9 +128,11 @@ export class NestiaSdkApplication {
       const set: Set<string> = new Set();
       for (const c of controllers)
         for (const cPath of c.paths)
-          for (const f of c.functions)
-            for (const fPath of f.paths)
-              set.add(`${f.method}::${cPath}/${fPath}`);
+          for (const op of c.operations)
+            for (const fPath of op.paths)
+              set.add(
+                `${op.protocol === "http" ? `${op.method}::` : ""}${cPath}/${fPath}`,
+              );
       return set.size;
     })();
 
@@ -145,7 +143,7 @@ export class NestiaSdkApplication {
         .map(
           (c) =>
             c.paths.length *
-            c.functions.map((f) => f.paths.length).reduce((a, b) => a + b, 0),
+            c.operations.map((f) => f.paths.length).reduce((a, b) => a + b, 0),
         )
         .reduce((a, b) => a + b, 0)}`,
     );
@@ -161,11 +159,13 @@ export class NestiaSdkApplication {
     );
     project.checker = program.getTypeChecker();
 
-    const routeList: IRoute[] = [];
+    const routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute> = [];
     for (const c of controllers) {
       const file: ts.SourceFile | undefined = program.getSourceFile(c.file);
       if (file === undefined) continue;
-      routeList.push(...(await ControllerAnalyzer.analyze(project)(file, c)));
+      routeList.push(
+        ...(await TypedControllerAnalyzer.analyze(project)(file, c)),
+      );
     }
 
     // REPORT ERRORS
@@ -177,7 +177,9 @@ export class NestiaSdkApplication {
 
     // FIND IMPLICIT TYPES
     if (this.config.clone !== true) {
-      const implicit: IRoute[] = routeList.filter(is_implicit_return_typed);
+      const implicit: ITypedHttpRoute[] = routeList.filter(
+        (r) => r.protocol === "http" && is_implicit_return_typed(r),
+      ) as ITypedHttpRoute[];
       if (implicit.length > 0)
         throw new Error(
           `NestiaApplication.${method}(): implicit return type is not allowed.\n` +
@@ -186,7 +188,7 @@ export class NestiaSdkApplication {
             implicit
               .map(
                 (it) =>
-                  `  - ${it.target.class.name}.${it.target.function.name} at "${it.location}"`,
+                  `  - ${it.controller.name}.${it.name} at "${it.location}"`,
               )
               .join("\n"),
         );
@@ -194,7 +196,7 @@ export class NestiaSdkApplication {
 
     // DO GENERATE
     AccessorAnalyzer.analyze(routeList);
-    await archiver(project.checker)(config(this.config))(routeList);
+    await archiver(project)(routeList);
   }
 }
 
@@ -204,7 +206,7 @@ const print_title = (str: string): void => {
   console.log("-----------------------------------------------------------");
 };
 
-const is_implicit_return_typed = (route: IRoute): boolean => {
+const is_implicit_return_typed = (route: ITypedHttpRoute): boolean => {
   const name: string = route.output.typeName;
   if (name === "void") return false;
   else if (name.indexOf("readonly [") !== -1) return true;

package/src/analyses/AccessorAnalyzer.ts

@@ -1,16 +1,21 @@
 import { Escaper } from "typia/lib/utils/Escaper";
 
-import { IRoute } from "../structures/IRoute";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
 
 export namespace AccessorAnalyzer {
-  export const analyze = (routes: IRoute[]) => {
+  export const analyze = (
+    routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+  ) => {
     shrink(routes);
     variable(routes);
     shrink(routes);
     for (const r of routes) r.name = r.accessors.at(-1) ?? r.name;
   };
 
-  const prepare = (routeList: IRoute[]): Map<string, number> => {
+  const prepare = (
+    routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+  ): Map<string, number> => {
     const dict: Map<string, number> = new Map();
     for (const route of routeList)
       route.accessors.forEach((_a, i) => {
@@ -20,7 +25,9 @@ export namespace AccessorAnalyzer {
     return dict;
   };
 
-  const variable = (routeList: IRoute[]) => {
+  const variable = (
+    routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+  ) => {
     const dict: Map<string, number> = prepare(routeList);
     for (const route of routeList) {
       const emended: string[] = route.accessors.slice();
@@ -42,7 +49,7 @@ export namespace AccessorAnalyzer {
     }
   };
 
-  const shrink = (routeList: IRoute[]) => {
+  const shrink = (routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>) => {
     const dict: Map<string, number> = prepare(routeList);
     for (const route of routeList) {
       if (

package/src/analyses/ExceptionAnalyzer.ts

@@ -4,53 +4,62 @@ import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
-import { IController } from "../structures/IController";
 import { INestiaProject } from "../structures/INestiaProject";
-import { IRoute } from "../structures/IRoute";
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
 import { ITypeTuple } from "../structures/ITypeTuple";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
 import { GenericAnalyzer } from "./GenericAnalyzer";
 import { ImportAnalyzer } from "./ImportAnalyzer";
 
 export namespace ExceptionAnalyzer {
   export const analyze =
     (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (
-      declaration: ts.MethodDeclaration,
-    ): Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput> => {
+    (props: {
+      generics: GenericAnalyzer.Dictionary;
+      imports: ImportAnalyzer.Dictionary;
+      controller: IReflectController;
+      operation: IReflectHttpOperation;
+      declaration: ts.MethodDeclaration;
+    }): Record<
+      number | "2XX" | "3XX" | "4XX" | "5XX",
+      ITypedHttpRoute.IOutput
+    > => {
       const output: Record<
         number | "2XX" | "3XX" | "4XX" | "5XX",
-        IRoute.IOutput
+        ITypedHttpRoute.IOutput
       > = {} as any;
-      for (const decorator of declaration.modifiers ?? [])
+      for (const decorator of props.declaration.modifiers ?? [])
         if (ts.isDecorator(decorator))
-          analyzeTyped(project)(genericDict, importDict)(controller, func)(
+          analyzeTyped(project)({
+            ...props,
             output,
-          )(decorator);
+            decorator,
+          });
       return output;
     };
 
   const analyzeTyped =
     (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (output: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>) =>
-    (decorator: ts.Decorator): boolean => {
+    (props: {
+      generics: GenericAnalyzer.Dictionary;
+      imports: ImportAnalyzer.Dictionary;
+      controller: IReflectController;
+      operation: IReflectHttpOperation;
+      output: Record<
+        number | "2XX" | "3XX" | "4XX" | "5XX",
+        ITypedHttpRoute.IOutput
+      >;
+      decorator: ts.Decorator;
+    }): boolean => {
       // CHECK DECORATOR
-      if (!ts.isCallExpression(decorator.expression)) return false;
-      else if ((decorator.expression.typeArguments ?? []).length !== 1)
+      if (!ts.isCallExpression(props.decorator.expression)) return false;
+      else if ((props.decorator.expression.typeArguments ?? []).length !== 1)
         return false;
 
       // CHECK SIGNATURE
       const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
+        project.checker.getResolvedSignature(props.decorator.expression);
       if (!signature || !signature.declaration) return false;
       else if (
         path
@@ -61,48 +70,49 @@ export namespace ExceptionAnalyzer {
 
       // GET TYPE INFO
       const status: string | null = getStatus(project.checker)(
-        decorator.expression.arguments[0] ?? null,
+        props.decorator.expression.arguments[0] ?? null,
       );
       if (status === null) return false;
 
-      const node: ts.TypeNode = decorator.expression.typeArguments![0];
+      const node: ts.TypeNode = props.decorator.expression.typeArguments![0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
       if (type.isTypeParameter()) {
         project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
+          file: props.controller.file,
+          controller: props.controller.name,
+          function: props.operation.name,
           message: "TypedException() without generic argument specification.",
         });
         return false;
       }
 
-      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(
-        project.checker,
-        genericDict,
-        importDict,
+      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(project.checker)({
+        generics: props.generics,
+        imports: props.imports,
         type,
-      );
+      });
       if (
         tuple === null ||
         (project.config.clone !== true &&
           (tuple.typeName === "__type" || tuple.typeName === "__object"))
       ) {
         project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
+          file: props.controller.file,
+          controller: props.controller.name,
+          function: props.operation.name,
           message: "TypeException() with implicit (unnamed) type.",
         });
         return false;
       }
 
       // DO ASSIGN
-      const matched: IController.IException[] = Object.entries(func.exceptions)
+      const matched: IReflectHttpOperation.IException[] = Object.entries(
+        props.operation.exceptions,
+      )
         .filter(([key]) => status === key)
         .map(([_key, value]) => value);
       for (const m of matched)
-        output[m.status] = {
+        props.output[m.status] = {
           type: tuple.type,
           typeName: tuple.typeName,
           contentType: "application/json",

package/src/analyses/ImportAnalyzer.ts

@@ -12,126 +12,145 @@ export namespace ImportAnalyzer {
 
   export type Dictionary = HashMap<string, HashSet<string>>;
 
-  export function analyze(
-    checker: ts.TypeChecker,
-    genericDict: GenericAnalyzer.Dictionary,
-    importDict: Dictionary,
-    type: ts.Type,
-  ): ITypeTuple | null {
-    type = get_type(checker, type);
-    explore_escaped_name(checker, genericDict, importDict, type);
-
-    try {
-      return {
+  export const analyze =
+    (checker: ts.TypeChecker) =>
+    (props: {
+      generics: GenericAnalyzer.Dictionary;
+      imports: Dictionary;
+      type: ts.Type;
+    }): ITypeTuple | null => {
+      const type: ts.Type = get_type(checker)(props.type);
+      explore_escaped_name(checker)({
+        ...props,
         type,
-        typeName: explore_escaped_name(checker, genericDict, importDict, type),
-      };
-    } catch {
-      return null;
-    }
-  }
+      });
+      try {
+        return {
+          type,
+          typeName: explore_escaped_name(checker)({
+            ...props,
+            type,
+          }),
+        };
+      } catch {
+        return null;
+      }
+    };
 
   /* ---------------------------------------------------------
         TYPE
     --------------------------------------------------------- */
-  function get_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-    const symbol: ts.Symbol | undefined = type.getSymbol();
-    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.",
+  const get_type =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type): ts.Type => {
+      const symbol: ts.Symbol | undefined = type.getSymbol();
+      return symbol && get_name(symbol) === "Promise"
+        ? escape_promise(checker)(type)
+        : type;
+    };
+
+  const escape_promise =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type): ts.Type => {
+      const generic: readonly ts.Type[] = checker.getTypeArguments(
+        type as ts.TypeReference,
       );
-    return generic[0];
-  }
-
-  function get_name(symbol: ts.Symbol): string {
-    return explore_name(
+      if (generic.length !== 1)
+        throw new Error(
+          "Error on ImportAnalyzer.analyze(): invalid promise type.",
+        );
+      return generic[0];
+    };
+
+  const get_name = (symbol: ts.Symbol): string =>
+    explore_name(
       symbol.escapedName.toString(),
       symbol.getDeclarations()?.[0]?.parent,
     );
-  }
 
   /* ---------------------------------------------------------
         ESCAPED TEXT WITH IMPORT STATEMENTS
     --------------------------------------------------------- */
-  function explore_escaped_name(
-    checker: ts.TypeChecker,
-    genericDict: GenericAnalyzer.Dictionary,
-    importDict: Dictionary,
-    type: ts.Type,
-  ): string {
-    //----
-    // CONDITIONAL BRANCHES
-    //----
-    // DECOMPOSE GENERIC ARGUMENT
-    while (genericDict.has(type) === true) type = genericDict.get(type)!;
-
-    // PRIMITIVE
-    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.getSymbol();
-
-    // UNION OR INTERSECT
-    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-      const joiner: string = type.isIntersection() ? " & " : " | ";
-      return type.types
-        .map((child) =>
-          explore_escaped_name(checker, genericDict, importDict, child),
-        )
-        .join(joiner);
-    }
-
-    // NO SYMBOL
-    else if (symbol === undefined)
-      return checker.typeToString(
-        type,
-        undefined,
-        ts.TypeFormatFlags.NoTruncation,
-      );
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = get_name(symbol);
-    const sourceFile: ts.SourceFile | undefined =
-      symbol.declarations?.[0]?.getSourceFile();
-    if (sourceFile === undefined) return name;
-
-    if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
-      const set: HashSet<string> = importDict.take(
-        sourceFile.fileName,
-        () => new HashSet(),
-      );
-      set.insert(name.split(".")[0]);
-    }
-
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = type.aliasSymbol
-      ? type.aliasTypeArguments || []
-      : checker.getTypeArguments(type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? explore_escaped_name(checker, genericDict, importDict, generic[0])
-        : `${name}<${generic
-            .map((child) =>
-              explore_escaped_name(checker, genericDict, importDict, child),
-            )
-            .join(", ")}>`
-      : name;
-  }
-
-  function explore_name(name: string, decl?: ts.Node): string {
-    return decl && ts.isModuleBlock(decl)
+  const explore_escaped_name =
+    (checker: ts.TypeChecker) =>
+    (props: {
+      generics: GenericAnalyzer.Dictionary;
+      imports: Dictionary;
+      type: ts.Type;
+    }): string => {
+      //----
+      // CONDITIONAL BRANCHES
+      //----
+      // DECOMPOSE GENERIC ARGUMENT
+      let type: ts.Type = props.type;
+      while (props.generics.has(type) === true)
+        type = props.generics.get(type)!;
+
+      // PRIMITIVE
+      const symbol: ts.Symbol | undefined =
+        type.aliasSymbol ?? type.getSymbol();
+
+      // UNION OR INTERSECT
+      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+        const joiner: string = type.isIntersection() ? " & " : " | ";
+        return type.types
+          .map((child) =>
+            explore_escaped_name(checker)({
+              ...props,
+              type: child,
+            }),
+          )
+          .join(joiner);
+      }
+      // NO SYMBOL
+      else if (symbol === undefined)
+        return checker.typeToString(
+          type,
+          undefined,
+          ts.TypeFormatFlags.NoTruncation,
+        );
+
+      //----
+      // SPECIALIZATION
+      //----
+      const name: string = get_name(symbol);
+      const sourceFile: ts.SourceFile | undefined =
+        symbol.declarations?.[0]?.getSourceFile();
+      if (sourceFile === undefined) return name;
+      else if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
+        const set: HashSet<string> = props.imports.take(
+          sourceFile.fileName,
+          () => new HashSet(),
+        );
+        set.insert(name.split(".")[0]);
+      }
+
+      // CHECK GENERIC
+      const generic: readonly ts.Type[] = type.aliasSymbol
+        ? type.aliasTypeArguments ?? []
+        : checker.getTypeArguments(type as ts.TypeReference);
+      return generic.length
+        ? name === "Promise"
+          ? explore_escaped_name(checker)({
+              ...props,
+              type: generic[0],
+            })
+          : `${name}<${generic
+              .map((child) =>
+                explore_escaped_name(checker)({
+                  ...props,
+                  type: child,
+                }),
+              )
+              .join(", ")}>`
+        : name;
+    };
+
+  const explore_name = (name: string, decl?: ts.Node): string =>
+    decl && ts.isModuleBlock(decl)
       ? explore_name(
           `${decl.parent.name.getFullText().trim()}.${name}`,
           decl.parent.parent,
         )
       : name;
-  }
 }

package/src/analyses/PathAnalyzer.ts

@@ -1,29 +1,7 @@
-import { RequestMethod } from "@nestjs/common";
 import path from "path";
 import { Token, parse } from "path-to-regexp";
 
-import { INormalizedInput } from "../structures/INormalizedInput";
-
 export namespace PathAnalyzer {
-  export const combinate =
-    (globalPrefix: INormalizedInput["globalPrefix"]) =>
-    (versions: Array<string | null>) =>
-    (props: { path: string; method: string }): string[] => {
-      const out = (str: string) =>
-        versions.map((v) => (v === null ? str : join(v, str)));
-      if (!globalPrefix?.prefix.length) return out(props.path);
-      else if (!globalPrefix.exclude?.length)
-        return out(props.path).map((str) => join(globalPrefix.prefix, str));
-      return globalPrefix.exclude.some((exclude) =>
-        typeof exclude === "string"
-          ? RegExp(exclude).test(props.path)
-          : METHOD(exclude.method) === props.method &&
-            RegExp(exclude.path).test(props.path),
-      )
-        ? out(props.path)
-        : out(props.path).map((str) => join(globalPrefix.prefix, str));
-    };
-
   export const join = (...args: string[]) =>
     "/" +
     _Trim(
@@ -89,22 +67,3 @@ export namespace PathAnalyzer {
     value: string;
   }
 }
-
-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";