@nestia/sdk 7.1.1 → 7.2.1

package/src/generates/internal/ImportDictionary.ts

@@ -1,12 +1,21 @@
 import path from "path";
-import { HashMap, HashSet, Pair } from "tstl";
+import { HashMap, TreeSet, hash } from "tstl";
 import ts from "typescript";
 
+import { ImportAnalyzer } from "../../analyses/ImportAnalyzer";
+import { IReflectImport } from "../../structures/IReflectImport";
 import { FilePrinter } from "./FilePrinter";
 
 export class ImportDictionary {
-  private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
-    new HashMap();
+  private readonly components_: HashMap<ICompositeKey, ICompositeValue> =
+    new HashMap(
+      (key) => hash(key.file, key.declaration, key.asterisk, key.default),
+      (a, b) =>
+        a.file === b.file &&
+        a.declaration === b.declaration &&
+        a.asterisk === b.asterisk &&
+        a.default === b.default,
+    );
 
   public constructor(public readonly file: string) {}
 
@@ -14,23 +23,42 @@ export class ImportDictionary {
     return this.components_.empty();
   }
 
-  public external(props: ImportDictionary.IExternalProps): string {
-    const key: string = `node_modules/${props.library}`;
-    const composition: IComposition = this.components_.take(
-      new Pair(key, props.type),
-      () => ({
-        location: key,
-        elements: new HashSet(),
-        default: false,
-        type: props.type,
-      }),
-    );
-    if (props.instance === null) composition.default = true;
-    else composition.elements.insert(props.instance);
-    return props.instance ?? props.library;
+  public declarations(imports: IReflectImport[]): void {
+    imports = ImportAnalyzer.merge(imports);
+    for (const imp of imports) {
+      if (imp.asterisk !== null)
+        this.internal({
+          type: "asterisk",
+          file: imp.file,
+          name: imp.asterisk,
+          declaration: true,
+        });
+      if (imp.default !== null)
+        this.internal({
+          type: "default",
+          file: imp.file,
+          name: imp.default,
+          declaration: true,
+        });
+      for (const elem of imp.elements)
+        this.internal({
+          type: "element",
+          file: imp.file,
+          name: elem,
+          declaration: true,
+        });
+    }
   }
 
-  public internal(props: ImportDictionary.IInternalProps): string {
+  public external(props: ImportDictionary.IProps): string {
+    const file: string = `node_modules/${props.file}`;
+    return this.internal({
+      ...props,
+      file,
+    });
+  }
+
+  public internal(props: ImportDictionary.IProps): string {
     const file: string = normalize(
       (() => {
         if (props.file.substring(props.file.length - 5) === ".d.ts")
@@ -40,27 +68,25 @@ export class ImportDictionary {
         return props.file;
       })(),
     );
-    const composition: IComposition = this.components_.take(
-      new Pair(file, props.type),
-      () => ({
-        location: file,
-        elements: new HashSet(),
-        default: false,
-        type: props.type,
-      }),
-    );
-    if (props.instance === null) {
-      composition.default = true;
-      if (props.name) composition.name = props.name;
-    } else composition.elements.insert(props.instance);
-    return props.instance ?? file;
+    const key: ICompositeKey = {
+      file: file,
+      declaration: props.declaration,
+      asterisk: props.type === "asterisk" ? props.name : null,
+      default: props.type === "default" ? props.name : null,
+    };
+    const value: ICompositeValue = this.components_.take(key, () => ({
+      ...key,
+      elements: new TreeSet<string>(),
+    }));
+    if (props.type === "element") value.elements.insert(props.name);
+    return props.name;
   }
 
   public toStatements(outDir: string): ts.Statement[] {
     outDir = path.resolve(outDir);
+
     const external: ts.ImportDeclaration[] = [];
     const internal: ts.ImportDeclaration[] = [];
-
     const locator = (str: string) => {
       const location: string = path
         .relative(outDir, str)
@@ -76,48 +102,26 @@ export class ImportDictionary {
     const enroll =
       (filter: (str: string) => boolean) =>
       (container: ts.ImportDeclaration[]) => {
-        const compositions: IComposition[] = this.components_
+        const compositions: ICompositeValue[] = this.components_
           .toJSON()
-          .filter((c) => filter(c.second.location))
-          .map((e) => ({
-            ...e.second,
-            location: locator(e.second.location),
-          }))
-          .sort((a, b) => a.location.localeCompare(b.location));
-        for (const c of compositions) {
-          const brackets: string[] = [];
-          if (c.default) brackets.push(c.name ?? c.location);
-          if (c.elements.empty() === false)
-            brackets.push(
-              `{ ${c.elements
-                .toJSON()
-                .sort((a, b) => a.localeCompare(b))
-                .join(", ")} }`,
-            );
+          .filter((c) => filter(c.second.file))
+          .map(
+            (e) =>
+              ({
+                ...e.second,
+                file: locator(e.second.file),
+              }) satisfies ICompositeValue,
+          )
+          .sort((a, b) => a.file.localeCompare(b.file));
+        for (const c of compositions)
           container.push(
             ts.factory.createImportDeclaration(
               undefined,
-              ts.factory.createImportClause(
-                c.type,
-                c.default
-                  ? ts.factory.createIdentifier(c.name ?? c.location)
-                  : undefined,
-                c.elements.empty() === false
-                  ? ts.factory.createNamedImports(
-                      [...c.elements].map((elem) =>
-                        ts.factory.createImportSpecifier(
-                          false,
-                          undefined,
-                          ts.factory.createIdentifier(elem),
-                        ),
-                      ),
-                    )
-                  : undefined,
-              ),
-              ts.factory.createStringLiteral(c.location),
+              this.toImportClaude(c),
+              ts.factory.createStringLiteral(c.file),
+              undefined,
             ),
           );
-        }
       };
 
     enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
@@ -128,27 +132,50 @@ export class ImportDictionary {
       ...internal,
     ];
   }
+
+  private toImportClaude(c: ICompositeValue): ts.ImportClause {
+    if (c.asterisk !== null)
+      return ts.factory.createImportClause(
+        c.declaration,
+        undefined,
+        ts.factory.createNamespaceImport(
+          ts.factory.createIdentifier(c.asterisk),
+        ),
+      );
+    return ts.factory.createImportClause(
+      c.declaration,
+      c.default !== null ? ts.factory.createIdentifier(c.default) : undefined,
+      c.elements.size() !== 0
+        ? ts.factory.createNamedImports(
+            Array.from(c.elements).map((elem) =>
+              ts.factory.createImportSpecifier(
+                false,
+                undefined,
+                ts.factory.createIdentifier(elem),
+              ),
+            ),
+          )
+        : undefined,
+    );
+  }
 }
 export namespace ImportDictionary {
-  export interface IExternalProps {
-    type: boolean;
-    library: string;
-    instance: string | null;
-  }
-  export interface IInternalProps {
-    type: boolean;
+  export interface IProps {
+    type: "default" | "element" | "asterisk";
     file: string;
-    instance: string | null;
-    name?: string | null;
+    name: string;
+    declaration: boolean;
   }
 }
 
-interface IComposition {
-  location: string;
-  type: boolean;
-  default: boolean;
-  name?: string;
-  elements: HashSet<string>;
+interface ICompositeKey {
+  file: string;
+  declaration: boolean;
+  asterisk: string | null;
+  default: string | null;
+}
+interface ICompositeValue extends ICompositeKey {
+  elements: TreeSet<string>;
 }
 
 const NODE_MODULES = "node_modules/";

package/src/generates/internal/SdkAliasCollection.ts

@@ -108,9 +108,10 @@ export namespace SdkAliasCollection {
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
-          type: true,
-          library: "typia",
-          instance: "Resolved",
+          file: "typia",
+          declaration: true,
+          type: "element",
+          name: "Resolved",
         }),
         [type],
       );
@@ -126,9 +127,10 @@ export namespace SdkAliasCollection {
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
-          type: true,
-          library: "typia",
-          instance: "Resolved",
+          file: "typia",
+          declaration: true,
+          type: "element",
+          name: "Resolved",
         }),
         [type],
       );
@@ -150,9 +152,10 @@ export namespace SdkAliasCollection {
       else if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
-          type: true,
-          library: "typia",
-          instance:
+          file: "typia",
+          declaration: true,
+          type: "element",
+          name:
             param.contentType === "application/json" || param.encrypted === true
               ? "Primitive"
               : "Resolved",
@@ -173,9 +176,10 @@ export namespace SdkAliasCollection {
             : project.config.primitive !== false
               ? ts.factory.createTypeReferenceNode(
                   importer.external({
-                    type: true,
-                    library: "typia",
-                    instance:
+                    file: "typia",
+                    declaration: true,
+                    type: "element",
+                    name:
                       route.success.contentType === "application/json" ||
                       route.success.encrypted === true
                         ? "Primitive"
@@ -200,9 +204,10 @@ export namespace SdkAliasCollection {
       ];
       return ts.factory.createTypeReferenceNode(
         importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "IPropagation",
+          file: "@nestia/fetcher",
+          declaration: true,
+          type: "element",
+          name: "IPropagation",
         }),
         [
           ts.factory.createTypeLiteralNode(
@@ -241,9 +246,10 @@ export namespace SdkAliasCollection {
   const formDataInput = (importer: ImportDictionary) => (type: ts.TypeNode) =>
     ts.factory.createTypeReferenceNode(
       importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "FormDataInput",
+        file: "@nestia/fetcher",
+        declaration: true,
+        type: "element",
+        name: "FormDataInput",
       }),
       [type],
     );

package/src/generates/internal/SdkFileProgrammer.ts

@@ -76,13 +76,7 @@ export namespace SdkFileProgrammer {
       );
       directory.routes.forEach((route, i) => {
         if (!(project.config.clone === true && route.protocol === "http"))
-          for (const tuple of route.imports)
-            for (const instance of tuple.instances)
-              importer.internal({
-                file: tuple.file,
-                instance,
-                type: true,
-              });
+          importer.declarations(route.imports);
         statements.push(
           ...(route.protocol === "http"
             ? SdkHttpRouteProgrammer.write(project)(importer)(route)

package/src/generates/internal/SdkHttpCloneReferencer.ts

@@ -47,7 +47,9 @@ export namespace SdkHttpCloneReferencer {
     });
     props.route.imports = Array.from(unique).map((str) => ({
       file: `${props.directory}/${str}`,
-      instances: [str],
+      asterisk: null,
+      default: null,
+      elements: [str],
     }));
   };
 

package/src/generates/internal/SdkHttpSimulationProgrammer.ts

@@ -140,9 +140,10 @@ export namespace SdkHttpSimulationProgrammer {
           IdentifierFactory.access(
             ts.factory.createIdentifier(
               importer.external({
-                type: false,
-                library: `@nestia/fetcher/lib/NestiaSimulator`,
-                instance: "NestiaSimulator",
+                file: `@nestia/fetcher/lib/NestiaSimulator`,
+                declaration: false,
+                type: "element",
+                name: "NestiaSimulator",
               }),
             ),
             "assert",

package/src/generates/internal/SdkImportWizard.ts

@@ -6,50 +6,57 @@ export namespace SdkImportWizard {
 
   export const HttpError = (importer: ImportDictionary) =>
     importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "HttpError",
+      declaration: true,
+      file: "@nestia/fetcher",
+      type: "element",
+      name: "HttpError",
     });
 
   export const IConnection = (importer: ImportDictionary) =>
     importer.external({
-      type: true,
-      library: "@nestia/fetcher",
-      instance: "IConnection",
+      declaration: true,
+      file: "@nestia/fetcher",
+      type: "element",
+      name: "IConnection",
     });
 
   export const Primitive = (importer: ImportDictionary) =>
     importer.external({
-      type: true,
-      library: "typia",
-      instance: "Primitive",
+      declaration: true,
+      file: "typia",
+      type: "element",
+      name: "Primitive",
     });
 
   export const Resolved = (importer: ImportDictionary) =>
     importer.external({
-      type: true,
-      library: "typia",
-      instance: "Resolved",
+      declaration: true,
+      file: "typia",
+      type: "element",
+      name: "Resolved",
     });
 
   export const typia = (importer: ImportDictionary) =>
     importer.external({
-      type: false,
-      library: "typia",
-      instance: null,
+      declaration: false,
+      file: "typia",
+      type: "default",
+      name: "typia",
     });
 }
 
 const PlainFetcher = (importer: ImportDictionary) =>
   importer.external({
-    type: false,
-    library: "@nestia/fetcher/lib/PlainFetcher",
-    instance: "PlainFetcher",
+    declaration: false,
+    file: "@nestia/fetcher/lib/PlainFetcher",
+    type: "element",
+    name: "PlainFetcher",
   });
 
 const EncryptedFetcher = (importer: ImportDictionary) =>
   importer.external({
-    type: false,
-    library: "@nestia/fetcher/lib/EncryptedFetcher",
-    instance: "EncryptedFetcher",
+    declaration: false,
+    file: "@nestia/fetcher/lib/EncryptedFetcher",
+    type: "element",
+    name: "EncryptedFetcher",
   });

package/src/generates/internal/SdkTypeProgrammer.ts

@@ -377,8 +377,9 @@ const importInternalFile =
     if (importer.file === `${project.config.output}/structures/${top}.ts`)
       return;
     importer.internal({
-      type: true,
+      declaration: true,
       file: `${project.config.output}/structures/${name.split(".")[0]}`,
-      instance: top,
+      type: "element",
+      name: top,
     });
   };

package/src/generates/internal/SdkTypeTagProgrammer.ts

@@ -10,13 +10,14 @@ export namespace SdkTypeTagProgrammer {
     from: "object" | "array" | "boolean" | "number" | "bigint" | "string",
     tag: IMetadataTypeTag,
   ) => {
-    const instance: string = tag.name.split("<")[0];
-    if (PREDEFINED[from]?.has(instance) === true)
+    const name: string = tag.name.split("<")[0];
+    if (PREDEFINED[from]?.has(name) === true)
       return ts.factory.createTypeReferenceNode(
         importer.external({
-          type: true,
-          library: `typia/lib/tags/${instance}`,
-          instance,
+          declaration: true,
+          file: `typia/lib/tags/${name}`,
+          type: "element",
+          name: name,
         }),
         [
           ts.factory.createLiteralTypeNode(
@@ -26,9 +27,10 @@ export namespace SdkTypeTagProgrammer {
       );
     return ts.factory.createTypeReferenceNode(
       importer.external({
-        type: true,
-        library: `typia/lib/tags/TagBase`,
-        instance: "TagBase",
+        declaration: true,
+        file: `typia/lib/tags/TagBase`,
+        type: "element",
+        name: "TagBase",
       }),
       [
         ts.factory.createLiteralTypeNode(

package/src/generates/internal/SdkWebSocketNamespaceProgrammer.ts

@@ -52,9 +52,10 @@ export namespace SdkWebSocketNamespaceProgrammer {
             undefined,
             ts.factory.createTypeReferenceNode(
               importer.external({
-                type: false,
-                library: "tgrid",
-                instance: "WebSocketConnector",
+                declaration: false,
+                file: "tgrid",
+                type: "element",
+                name: "WebSocketConnector",
               }),
               [
                 ts.factory.createTypeReferenceNode("Header"),
@@ -69,9 +70,10 @@ export namespace SdkWebSocketNamespaceProgrammer {
             undefined,
             ts.factory.createTypeReferenceNode(
               importer.external({
-                type: true,
-                library: "tgrid",
-                instance: "Driver",
+                declaration: true,
+                file: "tgrid",
+                type: "element",
+                name: "Driver",
               }),
               [ts.factory.createTypeReferenceNode("Listener")],
             ),

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -107,9 +107,10 @@ export namespace SdkWebSocketRouteProgrammer {
         local("connector")(
           ts.factory.createTypeReferenceNode(
             importer.external({
-              type: false,
-              library: "tgrid",
-              instance: "WebSocketConnector",
+              declaration: false,
+              file: "tgrid",
+              type: "element",
+              name: "WebSocketConnector",
             }),
             [
               ts.factory.createTypeReferenceNode(`${route.name}.Header`),
@@ -121,9 +122,10 @@ export namespace SdkWebSocketRouteProgrammer {
           ts.factory.createNewExpression(
             ts.factory.createIdentifier(
               importer.external({
-                type: false,
-                library: "tgrid",
-                instance: "WebSocketConnector",
+                declaration: false,
+                file: "tgrid",
+                type: "element",
+                name: "WebSocketConnector",
               }),
             ),
             undefined,
@@ -178,9 +180,10 @@ export namespace SdkWebSocketRouteProgrammer {
         local("driver")(
           ts.factory.createTypeReferenceNode(
             importer.external({
-              type: true,
-              library: "tgrid",
-              instance: "Driver",
+              declaration: true,
+              file: "tgrid",
+              type: "element",
+              name: "Driver",
             }),
             [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
           ),

package/src/structures/IReflectHttpOperation.ts

@@ -4,7 +4,7 @@ import { IJsDocTagInfo } from "typia";
 import { IReflectHttpOperationException } from "./IReflectHttpOperationException";
 import { IReflectHttpOperationParameter } from "./IReflectHttpOperationParameter";
 import { IReflectHttpOperationSuccess } from "./IReflectHttpOperationSuccess";
-import { IReflectTypeImport } from "./IReflectTypeImport";
+import { IReflectImport } from "./IReflectImport";
 
 export interface IReflectHttpOperation {
   protocol: "http";
@@ -18,7 +18,7 @@ export interface IReflectHttpOperation {
   exceptions: Record<string, IReflectHttpOperationException>;
   security: Record<string, string[]>[];
   tags: string[];
-  imports: IReflectTypeImport[];
+  imports: IReflectImport[];
   operationId: string | undefined;
   description: string | null;
   jsDocTags: IJsDocTagInfo[];

package/src/structures/IReflectHttpOperationParameter.ts

@@ -42,18 +42,14 @@ export namespace IReflectHttpOperationParameter {
     jsDocTags: IJsDocTagInfo[];
   }
 
-  /**
-   * @internal
-   */
+  /** @internal */
   export type IPreconfigured =
     | IPreconfigured.IBody
     | IPreconfigured.IHeaders
     | IPreconfigured.IParam
     | IPreconfigured.IQuery;
 
-  /**
-   * @internal
-   */
+  /** @internal */
   export namespace IPreconfigured {
     export interface IBody extends IBase<"body"> {
       field?: string;

package/src/structures/IReflectImport.ts

@@ -0,0 +1,6 @@
+export interface IReflectImport {
+  file: string;
+  asterisk: string | null;
+  default: string | null;
+  elements: string[];
+}

package/src/structures/IReflectWebSocketOperation.ts

@@ -1,7 +1,7 @@
 import { VERSION_NEUTRAL } from "@nestjs/common";
 import ts from "typescript";
 
-import { IReflectTypeImport } from "./IReflectTypeImport";
+import { IReflectImport } from "./IReflectImport";
 import { IReflectWebSocketOperationParameter } from "./IReflectWebSocketOperationParameter";
 
 export interface IReflectWebSocketOperation {
@@ -11,7 +11,7 @@ export interface IReflectWebSocketOperation {
   function: Function;
   versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
   parameters: IReflectWebSocketOperationParameter[];
-  imports: IReflectTypeImport[];
+  imports: IReflectImport[];
   description: string | null;
   jsDocTags: ts.JSDocTagInfo[];
 }

package/src/structures/IReflectWebSocketOperationParameter.ts

@@ -1,7 +1,7 @@
 import { IJsDocTagInfo } from "typia";
 
+import { IReflectImport } from "./IReflectImport";
 import { IReflectType } from "./IReflectType";
-import { IReflectTypeImport } from "./IReflectTypeImport";
 
 export type IReflectWebSocketOperationParameter =
   | IReflectWebSocketOperationParameter.IAcceptor
@@ -22,14 +22,12 @@ export namespace IReflectWebSocketOperationParameter {
     name: string;
     index: number;
     type: IReflectType;
-    imports: IReflectTypeImport[];
+    imports: IReflectImport[];
     description: string | null;
     jsDocTags: IJsDocTagInfo[];
   }
 
-  /**
-   * @internal
-   */
+  /** @internal */
   export interface IPreconfigured {
     category: "acceptor" | "driver" | "header" | "param" | "query";
     index: number;