@nestia/sdk 7.1.1 → 7.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/sdk",
-  "version": "7.1.1",
+  "version": "7.2.1",
   "description": "Nestia SDK and Swagger generator",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -32,8 +32,8 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@nestia/core": "^7.1.1",
-    "@nestia/fetcher": "^7.1.1",
+    "@nestia/core": "^7.2.1",
+    "@nestia/fetcher": "^7.2.1",
     "@samchon/openapi": "^4.5.0",
     "cli": "^1.0.1",
     "get-function-location": "^2.0.0",
@@ -47,7 +47,7 @@
     "typia": "^9.5.0"
   },
   "peerDependencies": {
-    "@nestia/core": ">=7.1.1"
+    "@nestia/core": ">=7.2.1"
   },
   "devDependencies": {
     "@nestjs/common": "^11.0.13",

package/src/analyses/DtoAnalyzer.ts

@@ -0,0 +1,246 @@
+import ts from "typescript";
+
+import { IReflectImport } from "../structures/IReflectImport";
+import { IReflectType } from "../structures/IReflectType";
+import { ImportAnalyzer } from "./ImportAnalyzer";
+
+export namespace DtoAnalyzer {
+  export interface INodeProps {
+    checker: ts.TypeChecker;
+    imports: IReflectImport[];
+    typeNode: ts.TypeNode;
+  }
+  export interface ITypeProps {
+    checker: ts.TypeChecker;
+    imports: IReflectImport[];
+    type: ts.Type;
+  }
+  export interface IOutput {
+    imports: IReflectImport[];
+    type: IReflectType;
+  }
+
+  export const analyzeNode = (props: INodeProps): IOutput | null => {
+    try {
+      const container: IReflectImport[] = [];
+      const type: IReflectType = exploreNode(
+        {
+          checker: props.checker,
+          imports: props.imports,
+          container,
+        },
+        props.typeNode,
+      );
+      return {
+        type,
+        imports: ImportAnalyzer.merge(container),
+      };
+    } catch {
+      return null;
+    }
+  };
+
+  export const analyzeType = (props: ITypeProps): IOutput | null => {
+    try {
+      const container: IReflectImport[] = [];
+      const type: IReflectType = exploreType(
+        {
+          checker: props.checker,
+          imports: props.imports,
+          container,
+        },
+        props.type,
+      );
+      return {
+        type,
+        imports: ImportAnalyzer.merge(container),
+      };
+    } catch {
+      return null;
+    }
+  };
+
+  type IContext = Omit<INodeProps, "typeNode"> & {
+    container: IReflectImport[];
+  };
+
+  const exploreNode = (ctx: IContext, typeNode: ts.TypeNode): IReflectType => {
+    // Analyze symbol, and take special cares
+    if (ts.isIntersectionTypeNode(typeNode))
+      return {
+        name: typeNode.types
+          .map((child) => exploreNode(ctx, child))
+          .map(getEscapedText)
+          .join(" & "),
+      };
+    else if (ts.isUnionTypeNode(typeNode))
+      return {
+        name: typeNode.types
+          .map((child) => exploreNode(ctx, child))
+          .map(getEscapedText)
+          .join(" | "),
+      };
+    else if (ts.isParenthesizedTypeNode(typeNode))
+      return {
+        name: `(${exploreNode(ctx, typeNode.type).name})`,
+      };
+    else if (ts.isTypeOperatorNode(typeNode)) {
+      const prefix: string | null =
+        typeNode.operator === ts.SyntaxKind.KeyOfKeyword
+          ? "keyof"
+          : typeNode.operator === ts.SyntaxKind.UniqueKeyword
+            ? "unique"
+            : typeNode.operator === ts.SyntaxKind.ReadonlyKeyword
+              ? "readonly"
+              : null;
+      if (prefix === null)
+        return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
+      return {
+        name: `${prefix} ${exploreNode(ctx, typeNode.type).name}`,
+      };
+    } else if (ts.isTypePredicateNode(typeNode) || ts.isTypeQueryNode(typeNode))
+      return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
+    else if (ts.isTypeReferenceNode(typeNode) === false)
+      return {
+        name: typeNode.getText(),
+      };
+
+    // Find matched import statement
+    const name: string = typeNode.typeName.getText();
+    const prefix: string = name.split(".")[0];
+
+    let matched: boolean = false;
+    const insert = (imp: IReflectImport): void => {
+      matched ||= true;
+      ctx.container.push(imp);
+    };
+    for (const imp of ctx.imports)
+      if (prefix === imp.default)
+        insert({
+          file: imp.file,
+          asterisk: null,
+          default: prefix,
+          elements: [],
+        });
+      else if (prefix === imp.asterisk)
+        insert({
+          file: imp.file,
+          asterisk: prefix,
+          default: null,
+          elements: [],
+        });
+      else if (imp.elements.includes(prefix))
+        insert({
+          file: imp.file,
+          asterisk: null,
+          default: null,
+          elements: [prefix],
+        });
+    if (prefix !== "Promise" && matched === false)
+      return exploreType(ctx, ctx.checker.getTypeFromTypeNode(typeNode));
+
+    // Finalize with generic arguments
+    if (!!typeNode.typeArguments?.length) {
+      const top: ts.TypeNode = typeNode.typeArguments[0];
+      if (name === "Promise") return exploreNode(ctx, top);
+      return {
+        name,
+        typeArguments: typeNode.typeArguments.map((child) =>
+          exploreNode(ctx, child),
+        ),
+      };
+    }
+    return { name };
+  };
+
+  const exploreType = (ctx: IContext, type: ts.Type): IReflectType => {
+    // Analyze symbol, and take special cares
+    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.symbol;
+    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+      const joiner: string = type.isIntersection() ? " & " : " | ";
+      return {
+        name: type.types
+          .map((child) => exploreType(ctx, child))
+          .map(getEscapedText)
+          .join(joiner),
+      };
+    } else if (symbol === undefined)
+      return {
+        name: ctx.checker.typeToString(
+          type,
+          undefined,
+          ts.TypeFormatFlags.NoTruncation,
+        ),
+      };
+
+    // Find matched import statement
+    const name: string = getNameOfSymbol(symbol);
+    const prefix: string = name.split(".")[0];
+
+    let matched: boolean = false;
+    const insert = (imp: IReflectImport): void => {
+      matched ||= true;
+      ctx.container.push(imp);
+    };
+    for (const imp of ctx.imports)
+      if (imp.elements.includes(prefix))
+        insert({
+          file: imp.file,
+          asterisk: null,
+          default: null,
+          elements: [prefix],
+        });
+    if (prefix !== "Promise" && matched === false)
+      emplaceSymbol(ctx, symbol, prefix);
+
+    // Finalize with generic arguments
+    const generic: readonly ts.Type[] = type.aliasSymbol
+      ? (type.aliasTypeArguments ?? [])
+      : ctx.checker.getTypeArguments(type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? exploreType(ctx, generic[0])
+        : {
+            name,
+            typeArguments: generic.map((child) => exploreType(ctx, child)),
+          }
+      : { name };
+  };
+
+  const emplaceSymbol = (
+    ctx: IContext,
+    symbol: ts.Symbol,
+    prefix: string,
+  ): void => {
+    // GET SOURCE FILE
+    const sourceFile: ts.SourceFile | undefined =
+      symbol.declarations?.[0]?.getSourceFile();
+    if (sourceFile === undefined) return;
+    if (sourceFile.fileName.indexOf("/typescript/lib") === -1)
+      ctx.container.push({
+        file: sourceFile.fileName,
+        asterisk: null,
+        default: null,
+        elements: [prefix],
+      });
+  };
+}
+
+const getEscapedText = (type: IReflectType): string =>
+  type.typeArguments
+    ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
+    : type.name;
+
+const getNameOfSymbol = (symbol: ts.Symbol): string =>
+  exploreName(
+    symbol.escapedName.toString(),
+    symbol.getDeclarations()?.[0]?.parent,
+  );
+
+const exploreName = (name: string, decl?: ts.Node): string =>
+  decl && ts.isModuleBlock(decl)
+    ? exploreName(
+        `${decl.parent.name.getFullText().trim()}.${name}`,
+        decl.parent.parent,
+      )
+    : name;

package/src/analyses/ImportAnalyzer.ts

@@ -1,171 +1,126 @@
+import path from "path";
 import ts from "typescript";
 
-import { IReflectType } from "../structures/IReflectType";
-import { IReflectTypeImport } from "../structures/IReflectTypeImport";
+import { IReflectImport } from "../structures/IReflectImport";
 import { MapUtil } from "../utils/MapUtil";
 
 export namespace ImportAnalyzer {
-  export interface IOutput {
-    imports: IReflectTypeImport[];
-    type: IReflectType | null;
-  }
-  export const analyze = (
-    checker: ts.TypeChecker,
-    generics: WeakMap<ts.Type, ts.Type>,
-    type: ts.Type,
-  ): IOutput => {
-    const imports: Map<string, Set<string>> = new Map();
-    try {
-      type = escape(checker, type);
-      return {
-        type: explore({
-          checker,
-          generics,
-          imports,
-          type,
-        }),
-        imports: [...imports].map(([file, instances]) => ({
-          file,
-          instances: Array.from(instances),
-        })),
-      };
-    } catch {
-      return {
-        imports: [],
-        type: null,
-      };
-    }
-  };
+  export const analyze = (file: ts.SourceFile): IReflectImport[] =>
+    file.statements
+      .filter(ts.isImportDeclaration)
+      .map((imp) => {
+        const clause: ts.ImportClause | undefined = imp.importClause;
+        if (clause === undefined) return null;
+        try {
+          // no real position
+          // import statement generated by transformer like typia
+          imp.moduleSpecifier.getText();
+        } catch {
+          return null;
+        }
 
-  export const unique = (
-    imports: IReflectTypeImport[],
-  ): IReflectTypeImport[] => {
-    const map: Map<string, Set<string>> = new Map();
-    imports.forEach(({ file, instances }) => {
-      const set: Set<string> = MapUtil.take(map, file, () => new Set());
-      instances.forEach((instance) => set.add(instance));
-    });
-    return [...map].map(([file, instances]) => ({
-      file,
-      instances: Array.from(instances),
-    }));
-  };
+        const reflect: IReflectImport = {
+          file: normalizePath(
+            path.dirname(file.fileName),
+            ts.isStringLiteral(imp.moduleSpecifier)
+              ? imp.moduleSpecifier.text
+              : escapeQuotes(imp.moduleSpecifier.getText()),
+          ),
+          elements: [],
+          default: null,
+          asterisk: null,
+        };
+        if (clause.name) reflect.default = clause.name.getText();
+        if (clause.namedBindings === undefined) return reflect;
+        else if (ts.isNamedImports(clause.namedBindings))
+          reflect.elements = clause.namedBindings.elements.map((e) =>
+            e.name.getText(),
+          );
+        else if (ts.isNamespaceImport(clause.namedBindings))
+          reflect.asterisk = clause.namedBindings.name.getText();
+        return reflect;
+      })
+      .filter((r) => r !== null);
 
-  /* ---------------------------------------------------------
-    TYPE
-  --------------------------------------------------------- */
-  const escape = (checker: ts.TypeChecker, type: ts.Type): ts.Type => {
-    if (type.symbol && getNameOfSymbol(type.symbol) === "Promise") {
-      const generic: readonly ts.Type[] = checker.getTypeArguments(
-        type as ts.TypeReference,
+  export const merge = (imports: IReflectImport[]): IReflectImport[] => {
+    // group by files
+    const fileGroups: Map<string, IReflectImport[]> = new Map();
+    for (const imp of imports) {
+      const array: IReflectImport[] = MapUtil.take(
+        fileGroups,
+        imp.file,
+        () => [],
       );
-      if (generic.length !== 1)
-        throw new Error(
-          "Error on ImportAnalyzer.analyze(): invalid promise type.",
-        );
-      type = generic[0];
+      array.push(imp);
     }
-    return type;
+    return Array.from(fileGroups.entries())
+      .map(([key, value]) => mergeGroup(key, value))
+      .flat();
   };
 
-  const getNameOfSymbol = (symbol: ts.Symbol): string =>
-    exploreName(
-      symbol.escapedName.toString(),
-      symbol.getDeclarations()?.[0]?.parent,
-    );
-
-  /* ---------------------------------------------------------
-    ESCAPED TEXT WITH IMPORT STATEMENTS
-  --------------------------------------------------------- */
-  const explore = (props: {
-    checker: ts.TypeChecker;
-    generics: WeakMap<ts.Type, ts.Type>;
-    imports: Map<string, Set<string>>;
-    type: ts.Type;
-  }): IReflectType => {
-    //----
-    // 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.symbol;
-
-    // UNION OR INTERSECT
-    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-      const joiner: string = type.isIntersection() ? " & " : " | ";
-      return {
-        name: type.types
-          .map((child) =>
-            explore({
-              ...props,
-              type: child,
-            }),
-          )
-          .map(getEscapedText)
-          .join(joiner),
-      };
-    }
-    // NO SYMBOL
-    else if (symbol === undefined)
-      return {
-        name: props.checker.typeToString(
-          type,
-          undefined,
-          ts.TypeFormatFlags.NoTruncation,
-        ),
-      };
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = getNameOfSymbol(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: Set<string> = MapUtil.take(
-        props.imports,
-        sourceFile.fileName,
-        () => new Set(),
+  function mergeGroup(
+    file: string,
+    imports: IReflectImport[],
+  ): IReflectImport[] {
+    const allStarImports: IReflectImport[] = Array.from(
+      new Set(
+        imports
+          .filter((imp) => imp.asterisk !== null)
+          .map((imp) => imp.asterisk!),
+      ),
+    )
+      .sort()
+      .map(
+        (allStarImport) =>
+          ({
+            file,
+            elements: [],
+            default: null,
+            asterisk: allStarImport,
+          }) satisfies IReflectImport,
+      );
+    const defaultImports: IReflectImport[] = Array.from(
+      new Set(
+        imports
+          .filter((imp) => imp.default !== null)
+          .map((imp) => imp.default!),
+      ),
+    )
+      .sort()
+      .map(
+        (defaultImport) =>
+          ({
+            file,
+            elements: [],
+            default: defaultImport,
+            asterisk: null,
+          }) satisfies IReflectImport,
       );
-      set.add(name.split(".")[0]);
+    const instances: Set<string> = new Set(
+      imports.map((imp) => imp.elements).flat(),
+    );
+    if (instances.size !== 0) {
+      if (defaultImports.length !== 0)
+        defaultImports[0].elements = Array.from(instances).sort();
+      else
+        defaultImports.push({
+          file,
+          elements: Array.from(instances).sort(),
+          default: null,
+          asterisk: null,
+        });
     }
+    return [...allStarImports, ...defaultImports];
+  }
 
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = type.aliasSymbol
-      ? type.aliasTypeArguments ?? []
-      : props.checker.getTypeArguments(type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? explore({
-            ...props,
-            type: generic[0],
-          })
-        : {
-            name,
-            typeArguments: generic.map((child) =>
-              explore({
-                ...props,
-                type: child,
-              }),
-            ),
-          }
-      : { name };
-  };
-
-  const exploreName = (name: string, decl?: ts.Node): string =>
-    decl && ts.isModuleBlock(decl)
-      ? exploreName(
-          `${decl.parent.name.getFullText().trim()}.${name}`,
-          decl.parent.parent,
-        )
-      : name;
+  function escapeQuotes(str: string): string {
+    if (str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
+    else if (str.startsWith('"') && str.endsWith('"')) return str.slice(1, -1);
+    return str;
+  }
 
-  const getEscapedText = (type: IReflectType): string =>
-    type.typeArguments
-      ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
-      : type.name;
+  function normalizePath(root: string, str: string): string {
+    if (str.startsWith(".")) return path.resolve(root, str);
+    return `node_modules/${str}`;
+  }
 }

package/src/analyses/ReflectHttpOperationAnalyzer.ts

@@ -101,7 +101,7 @@ export namespace ReflectHttpOperationAnalyzer {
         errors,
       }),
       tags: Reflect.getMetadata("swagger/apiUseTags", props.function) ?? [],
-      imports: ImportAnalyzer.unique(
+      imports: ImportAnalyzer.merge(
         [
           ...props.metadata.parameters
             .filter((x) => parameters.some((y) => x.index === y.index))

package/src/analyses/ReflectWebSocketOperationAnalyzer.ts

@@ -2,7 +2,7 @@ import { ranges } from "tstl";
 
 import { INestiaProject } from "../structures/INestiaProject";
 import { IReflectController } from "../structures/IReflectController";
-import { IReflectTypeImport } from "../structures/IReflectTypeImport";
+import { IReflectImport } from "../structures/IReflectImport";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
 import { IReflectWebSocketOperationParameter } from "../structures/IReflectWebSocketOperationParameter";
 import { IOperationMetadata } from "../transformers/IOperationMetadata";
@@ -50,7 +50,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
         ].join("\n"),
       );
 
-    const imports: IReflectTypeImport[] = [];
+    const imports: IReflectImport[] = [];
     const parameters: IReflectWebSocketOperationParameter[] = preconfigured
       .map((p) => {
         // METADATA INFO
@@ -164,7 +164,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
       function: ctx.function,
       versions: ReflectMetadataAnalyzer.versions(ctx.function),
       parameters,
-      imports: ImportAnalyzer.unique(imports),
+      imports: ImportAnalyzer.merge(imports),
       description: ctx.metadata.description ?? null,
       jsDocTags: ctx.metadata.jsDocTags,
     };

package/src/generates/internal/E2eFileProgrammer.ts

@@ -18,21 +18,13 @@ export namespace E2eFileProgrammer {
       const importer: ImportDictionary = new ImportDictionary(
         `${props.current}/${getFunctionName(route)}.ts`,
       );
-      if (project.config.clone !== true)
-        for (const tuple of route.imports)
-          for (const instance of tuple.instances)
-            importer.internal({
-              file: tuple.file,
-              type: true,
-              instance,
-            });
+      if (project.config.clone !== true) importer.declarations(route.imports);
       importer.internal({
-        type: false,
         file: props.api,
-        instance: null,
+        declaration: false,
+        type: "default",
         name: "api",
       });
-
       const functor: ts.Statement = generateFunctor(project)(importer)(route);
       await FilePrinter.write({
         location: importer.file,