@nestia/sdk 12.0.0 → 12.1.0

package/src/analyses/ReflectControllerAnalyzer.ts

@@ -6,11 +6,11 @@ import {
 
 import { INestiaProject } from "../structures/INestiaProject";
 import { INestiaSdkInput } from "../structures/INestiaSdkInput";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
 import { IReflectMcpOperation } from "../structures/IReflectMcpOperation";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
-import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { ReflectHttpOperationAnalyzer } from "./ReflectHttpOperationAnalyzer";
 import { ReflectMcpOperationAnalyzer } from "./ReflectMcpOperationAnalyzer";
@@ -97,16 +97,25 @@ export namespace ReflectControllerAnalyzer {
   };
 
   function _Get_prototype_entries(creator: any): Array<[string, unknown]> {
-    const keyList = Object.getOwnPropertyNames(creator.prototype);
-    const entries: Array<[string, unknown]> = keyList.map((key) => [
-      key,
-      creator.prototype[key],
-    ]);
+    const visited: Set<string> = new Set();
+    return iterate(creator);
 
-    const parent = Object.getPrototypeOf(creator);
-    if (parent.prototype !== undefined)
-      entries.push(..._Get_prototype_entries(parent));
+    function iterate(target: any): Array<[string, unknown]> {
+      const keyList: string[] = Object.getOwnPropertyNames(
+        target.prototype,
+      ).filter((key) => {
+        if (visited.has(key)) return false;
+        visited.add(key);
+        return true;
+      });
+      const entries: Array<[string, unknown]> = keyList.map((key) => [
+        key,
+        target.prototype[key],
+      ]);
 
-    return entries;
+      const parent: any = Object.getPrototypeOf(target);
+      if (parent.prototype !== undefined) entries.push(...iterate(parent));
+      return entries;
+    }
   }
 }

package/src/analyses/ReflectHttpOperationAnalyzer.ts

@@ -18,7 +18,8 @@ import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
 
 export namespace ReflectHttpOperationAnalyzer {
   export interface IProps {
-    project: Omit<INestiaProject, "config">;
+    project: Omit<INestiaProject, "config"> &
+      Partial<Pick<INestiaProject, "config">>;
     controller: IReflectController;
     function: Function;
     name: string;
@@ -107,7 +108,9 @@ export namespace ReflectHttpOperationAnalyzer {
             .filter((x) => parameters.some((y) => x.index === y.index))
             .map((x) => x.imports),
           ...(success.binary === true ? [] : props.metadata.success.imports),
-          ...Object.values(props.metadata.exceptions).map((e) => e.imports),
+          ...(props.project.config?.propagate === true
+            ? Object.values(props.metadata.exceptions).map((e) => e.imports)
+            : []),
         ].flat(),
       ),
       description: props.metadata.description,

package/src/analyses/ReflectHttpOperationExceptionAnalyzer.ts

@@ -1,10 +1,10 @@
 import { TypedException } from "@nestia/core";
-import { JsonMetadataFactory } from "../internal/legacy";
 
+import { JsonMetadataFactory } from "../internal/legacy";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationException } from "../structures/IReflectHttpOperationException";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../structures/IOperationMetadata";
 
 export namespace ReflectHttpOperationExceptionAnalyzer {
   export interface IContext {

package/src/analyses/ReflectHttpOperationParameterAnalyzer.ts

@@ -1,6 +1,7 @@
 import { SwaggerExample } from "@nestia/core";
 import { ROUTE_ARGS_METADATA } from "@nestjs/common/constants";
 import { RouteParamtypes } from "@nestjs/common/enums/route-paramtypes.enum";
+
 import {
   HttpFormDataProgrammer,
   HttpHeadersProgrammer,
@@ -8,14 +9,13 @@ import {
   HttpQueryProgrammer,
   JsonMetadataFactory,
 } from "../internal/legacy";
-
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../structures/IOperationMetadata";
-import { TextPlainValidator } from "../validators/TextPlainValidator";
 import { HttpHeadersValidator } from "../validators/HttpHeadersValidator";
 import { HttpQueryValidator } from "../validators/HttpQueryValidator";
+import { TextPlainValidator } from "../validators/TextPlainValidator";
 
 export namespace ReflectHttpOperationParameterAnalyzer {
   export interface IContext {

package/src/analyses/ReflectWebSocketOperationAnalyzer.ts

@@ -1,11 +1,11 @@
 import { ranges } from "tstl";
 
 import { INestiaProject } from "../structures/INestiaProject";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectImport } from "../structures/IReflectImport";
 import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
 import { IReflectWebSocketOperationParameter } from "../structures/IReflectWebSocketOperationParameter";
-import { IOperationMetadata } from "../structures/IOperationMetadata";
 import { StringUtil } from "../utils/StringUtil";
 import { ImportAnalyzer } from "./ImportAnalyzer";
 import { PathAnalyzer } from "./PathAnalyzer";
@@ -53,34 +53,41 @@ export namespace ReflectWebSocketOperationAnalyzer {
     const imports: IReflectImport[] = [];
     const parameters: IReflectWebSocketOperationParameter[] = preconfigured
       .map((p) => {
+        const reject = (message: string): null => {
+          errors.push(message);
+          return null;
+        };
+
         // METADATA INFO
         const matched: IOperationMetadata.IParameter | undefined =
           ctx.metadata.parameters.find((m) => p.index === m.index);
 
         // VALIDATE PARAMETER
         if (matched === undefined)
-          return errors.push(
+          return reject(
             `Unable to find parameter type of the ${p.index} (th).`,
           );
         else if (matched.type === null)
-          return errors.push(
+          return reject(
             `Failed to analyze the parameter type of the ${JSON.stringify(matched.name)}.`,
           );
         else if (
           p.category === "param" &&
           !(p as IReflectWebSocketOperationParameter.IParam).field?.length
         )
-          return errors.push(`@WebSocketRoute.Param() must have a field name.`);
+          return reject(`@WebSocketRoute.Param() must have a field name.`);
         else if (
           p.category === "acceptor" &&
           matched.type?.typeArguments?.length !== 3
         )
-          return `@WebSocketRoute.Acceptor() must have three type arguments.`;
+          return reject(
+            `@WebSocketRoute.Acceptor() must have three type arguments.`,
+          );
         else if (
           p.category === "driver" &&
           matched.type?.typeArguments?.length !== 1
         )
-          return errors.push(
+          return reject(
             `@WebSocketRoute.Driver() must have one type argument.`,
           );
 
@@ -119,7 +126,7 @@ export namespace ReflectWebSocketOperationAnalyzer {
         // UNKNOWN TYPE, MAYBE NEW FEATURE
         else {
           if (p.category !== "header")
-            errors.push(
+            reject(
               `@WebSocketRoute.${StringUtil.capitalize(p.category)}() has not been supported yet. How about upgrading the nestia packages?`,
             );
           return null;

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -1,3 +1,6 @@
+import { NamingConvention } from "@typia/utils";
+import { IMetadataComponents, IMetadataSchema } from "typia";
+
 import {
   IMetadataDictionary,
   MetadataAliasType,
@@ -8,9 +11,6 @@ import {
   MetadataSchema,
   MetadataTupleType,
 } from "../internal/legacy";
-import { NamingConvention } from "@typia/utils";
-import { IMetadataComponents, IMetadataSchema } from "typia";
-
 import { IReflectController } from "../structures/IReflectController";
 import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
 import { IReflectOperationError } from "../structures/IReflectOperationError";
@@ -265,7 +265,8 @@ const renameDuplicateComponents = (routes: ITypedHttpRoute[]): void => {
     }
   }
   for (const route of routes)
-    for (const metadata of routeMetadatas(route)) clearMetadataNameCache(metadata);
+    for (const metadata of routeMetadatas(route))
+      clearMetadataNameCache(metadata);
 };
 
 const routeMetadatas = (route: ITypedHttpRoute): MetadataSchema[] => [
@@ -308,29 +309,49 @@ const collectComponentEntries = (
     collectComponentEntries(entries, route, map.value, visited);
   }
   for (const array of metadata.arrays)
-    if (visited.arrays.has((array.type as MetadataArrayType)) === false) {
-      visited.arrays.add((array.type as MetadataArrayType));
-      entries.push(componentEntry(route, "arrays", (array.type as MetadataArrayType)));
-      collectComponentEntries(entries, route, ((array.type as MetadataArrayType) as MetadataArrayType).value, visited);
+    if (visited.arrays.has(array.type as MetadataArrayType) === false) {
+      visited.arrays.add(array.type as MetadataArrayType);
+      entries.push(
+        componentEntry(route, "arrays", array.type as MetadataArrayType),
+      );
+      collectComponentEntries(
+        entries,
+        route,
+        (array.type as MetadataArrayType as MetadataArrayType).value,
+        visited,
+      );
     }
   for (const tuple of metadata.tuples)
-    if (visited.tuples.has((tuple.type as MetadataTupleType)) === false) {
-      visited.tuples.add((tuple.type as MetadataTupleType));
-      entries.push(componentEntry(route, "tuples", (tuple.type as MetadataTupleType)));
-      for (const elem of ((tuple.type as MetadataTupleType) as MetadataTupleType).elements)
+    if (visited.tuples.has(tuple.type as MetadataTupleType) === false) {
+      visited.tuples.add(tuple.type as MetadataTupleType);
+      entries.push(
+        componentEntry(route, "tuples", tuple.type as MetadataTupleType),
+      );
+      for (const elem of (tuple.type as MetadataTupleType as MetadataTupleType)
+        .elements)
         collectComponentEntries(entries, route, elem, visited);
     }
   for (const alias of metadata.aliases)
-    if (visited.aliases.has((alias.type as MetadataAliasType)) === false) {
-      visited.aliases.add((alias.type as MetadataAliasType));
-      entries.push(componentEntry(route, "aliases", (alias.type as MetadataAliasType)));
-      collectComponentEntries(entries, route, ((alias.type as MetadataAliasType) as MetadataAliasType).value, visited);
+    if (visited.aliases.has(alias.type as MetadataAliasType) === false) {
+      visited.aliases.add(alias.type as MetadataAliasType);
+      entries.push(
+        componentEntry(route, "aliases", alias.type as MetadataAliasType),
+      );
+      collectComponentEntries(
+        entries,
+        route,
+        (alias.type as MetadataAliasType as MetadataAliasType).value,
+        visited,
+      );
     }
   for (const obj of metadata.objects)
-    if (visited.objects.has((obj.type as MetadataObjectType)) === false) {
-      visited.objects.add((obj.type as MetadataObjectType));
-      entries.push(componentEntry(route, "objects", (obj.type as MetadataObjectType)));
-      for (const p of ((obj.type as MetadataObjectType) as MetadataObjectType).properties) {
+    if (visited.objects.has(obj.type as MetadataObjectType) === false) {
+      visited.objects.add(obj.type as MetadataObjectType);
+      entries.push(
+        componentEntry(route, "objects", obj.type as MetadataObjectType),
+      );
+      for (const p of (obj.type as MetadataObjectType as MetadataObjectType)
+        .properties) {
         collectComponentEntries(entries, route, p.key, visited);
         collectComponentEntries(entries, route, p.value, visited);
       }
@@ -393,20 +414,28 @@ const clearMetadataNameCache = (
   }
   for (const array of metadata.arrays) {
     (array as unknown as { name_?: string }).name_ = undefined;
-    clearMetadataNameCache(((array.type as MetadataArrayType) as MetadataArrayType).value, visited);
+    clearMetadataNameCache(
+      (array.type as MetadataArrayType as MetadataArrayType).value,
+      visited,
+    );
   }
   for (const tuple of metadata.tuples) {
     (tuple as unknown as { name_?: string }).name_ = undefined;
-    for (const elem of ((tuple.type as MetadataTupleType) as MetadataTupleType).elements)
+    for (const elem of (tuple.type as MetadataTupleType as MetadataTupleType)
+      .elements)
       clearMetadataNameCache(elem, visited);
   }
   for (const alias of metadata.aliases) {
     (alias as unknown as { name_?: string }).name_ = undefined;
-    clearMetadataNameCache(((alias.type as MetadataAliasType) as MetadataAliasType).value, visited);
+    clearMetadataNameCache(
+      (alias.type as MetadataAliasType as MetadataAliasType).value,
+      visited,
+    );
   }
   for (const obj of metadata.objects) {
     (obj as unknown as { name_?: string }).name_ = undefined;
-    for (const p of ((obj.type as MetadataObjectType) as MetadataObjectType).properties) {
+    for (const p of (obj.type as MetadataObjectType as MetadataObjectType)
+      .properties) {
       clearMetadataNameCache(p.key, visited);
       clearMetadataNameCache(p.value, visited);
     }
@@ -433,8 +462,7 @@ const uniqueComponents = <T extends { name: string }>(input: T[]): T[] => {
   const dict: Record<string, T> = {};
   for (const elem of input) {
     const oldbie: T | undefined = dict[elem.name];
-    if (oldbie === undefined)
-      dict[elem.name] = elem;
+    if (oldbie === undefined) dict[elem.name] = elem;
     else if (
       elem.name.includes(".") ||
       componentScore(oldbie) < componentScore(elem)
@@ -459,7 +487,8 @@ const enrollMetadata = (
   if (visited.schemas.has(metadata)) return;
   visited.schemas.add(metadata);
 
-  if (metadata.rest !== null) enrollMetadata(dictionary, metadata.rest, visited);
+  if (metadata.rest !== null)
+    enrollMetadata(dictionary, metadata.rest, visited);
   if (metadata.escaped !== null) {
     enrollMetadata(dictionary, metadata.escaped.original, visited);
     enrollMetadata(dictionary, metadata.escaped.returns, visited);
@@ -476,18 +505,28 @@ const enrollMetadata = (
     enrollMetadata(dictionary, map.value, visited);
   }
   for (const array of metadata.arrays)
-    if (enroll(dictionary.arrays, (array.type as MetadataArrayType)))
-      enrollMetadata(dictionary, ((array.type as MetadataArrayType) as MetadataArrayType).value, visited);
+    if (enroll(dictionary.arrays, array.type as MetadataArrayType))
+      enrollMetadata(
+        dictionary,
+        (array.type as MetadataArrayType as MetadataArrayType).value,
+        visited,
+      );
   for (const tuple of metadata.tuples)
-    if (enroll(dictionary.tuples, (tuple.type as MetadataTupleType)))
-      for (const elem of ((tuple.type as MetadataTupleType) as MetadataTupleType).elements)
+    if (enroll(dictionary.tuples, tuple.type as MetadataTupleType))
+      for (const elem of (tuple.type as MetadataTupleType as MetadataTupleType)
+        .elements)
         enrollMetadata(dictionary, elem, visited);
   for (const alias of metadata.aliases)
-    if (enroll(dictionary.aliases, (alias.type as MetadataAliasType)))
-      enrollMetadata(dictionary, ((alias.type as MetadataAliasType) as MetadataAliasType).value, visited);
+    if (enroll(dictionary.aliases, alias.type as MetadataAliasType))
+      enrollMetadata(
+        dictionary,
+        (alias.type as MetadataAliasType as MetadataAliasType).value,
+        visited,
+      );
   for (const obj of metadata.objects)
-    if (enroll(dictionary.objects, (obj.type as MetadataObjectType)))
-      for (const p of ((obj.type as MetadataObjectType) as MetadataObjectType).properties) {
+    if (enroll(dictionary.objects, obj.type as MetadataObjectType))
+      for (const p of (obj.type as MetadataObjectType as MetadataObjectType)
+        .properties) {
         enrollMetadata(dictionary, p.key, visited);
         enrollMetadata(dictionary, p.value, visited);
       }

package/src/executable/internal/NestiaSdkCommand.ts

@@ -106,14 +106,17 @@ export namespace NestiaSdkCommand {
     extension: string;
   }): string | null => {
     const argv: string[] = process.argv.slice(3);
-    if (argv.length === 0) return null;
-
     const index: number = argv.findIndex((str) => str === `--${props.type}`);
     if (index === -1) return null;
-    else if (argv.length === 1)
-      throw new Error(`${props.type} file must be provided`);
 
-    const file: string = argv[index + 1]!;
+    // Bound the VALUE position, not the whole argument list. The two only
+    // coincide when the flag is the sole argument, so any preceding token used
+    // to send `undefined` into endsWith() and report a TypeError instead of this
+    // diagnostic. A following flag is a missing value too, not a badly named
+    // file.
+    const file: string | undefined = argv[index + 1];
+    if (file === undefined || file.startsWith("--"))
+      throw new Error(`${props.type} file must be provided`);
     if (file.endsWith(props.extension) === false)
       throw new Error(`${props.type} file must be ${props.extension} file`);
     return file;

package/src/generates/E2eGenerator.ts

@@ -26,7 +26,5 @@ export namespace E2eGenerator {
 }
 
 const mkdir = async (location: string): Promise<void> => {
-  try {
-    await fs.promises.mkdir(location);
-  } catch {}
+  await fs.promises.mkdir(location, { recursive: true });
 };

package/src/generates/SdkGenerator.ts

@@ -19,9 +19,7 @@ export namespace SdkGenerator {
 
     // PREPARE NEW DIRECTORIES
     console.log("Generating SDK Library");
-    try {
-      await fs.promises.mkdir(app.project.config.output);
-    } catch {}
+    await fs.promises.mkdir(app.project.config.output, { recursive: true });
 
     // BUNDLING
     await bundle(app.project.config.output);

package/src/generates/SwaggerGenerator.ts

@@ -35,19 +35,18 @@ export namespace SwaggerGenerator {
 
     // TARGET LOCATION
     const parsed: path.ParsedPath = path.parse(config.output);
-    const directory: string = path.dirname(parsed.dir);
+    const location: string = !!parsed.ext
+      ? path.resolve(config.output)
+      : path.join(path.resolve(config.output), "swagger.json");
+    const directory: string = path.dirname(location);
     if (fs.existsSync(directory) === false)
       try {
-        await fs.promises.mkdir(directory);
+        await fs.promises.mkdir(directory, { recursive: true });
       } catch {}
     if (fs.existsSync(directory) === false)
       throw new Error(
         `Error on NestiaApplication.swagger(): failed to create output directory: ${directory}`,
       );
-    const location: string = !!parsed.ext
-      ? path.resolve(config.output)
-      : path.join(path.resolve(config.output), "swagger.json");
-
     // COMPOSE SWAGGER DOCUMENT
     const document: OpenApi.IDocument = compose({
       config,

package/src/generates/internal/ImportDictionary.ts

@@ -1,4 +1,9 @@
-import { type ImportClause, type Node, factory } from "@ttsc/factory";
+import {
+  type ImportClause,
+  type Node,
+  SyntaxKind,
+  factory,
+} from "@ttsc/factory";
 import path from "path";
 import { HashMap, TreeMap, hash } from "tstl";
 
@@ -42,10 +47,12 @@ export class ImportDictionary {
         });
       for (const elem of imp.elements) {
         if (elem === "WebSocketAcceptor") continue;
+        const imported: string = imp.elementAliases?.[elem] ?? elem;
         this.internal({
           type: "element",
           file: imp.file,
-          name: elem,
+          name: imported,
+          alias: imported === elem ? undefined : elem,
           declaration: true,
         });
       }
@@ -70,10 +77,12 @@ export class ImportDictionary {
     };
     const value: ICompositeValue = this.components_.take(key, () => ({
       ...key,
-      elements: new TreeMap<string, string | null>(),
+      elements: new TreeMap<string, string>(),
     }));
-    if (props.type === "element")
-      value.elements.set(props.name, props.alias ?? null);
+    if (props.type === "element") {
+      const local: string = props.alias ?? props.name;
+      value.elements.set(local, props.name);
+    }
     return props.type === "element" ? (props.alias ?? props.name) : props.name;
   }
 
@@ -132,22 +141,24 @@ export class ImportDictionary {
     // generated SDK code references DTO namespaces only in type positions.
     if (c.asterisk !== null)
       return factory.createImportClause(
-        c.declaration,
+        c.declaration ? SyntaxKind.TypeKeyword : undefined,
         undefined,
         factory.createNamespaceImport(factory.createIdentifier(c.asterisk)),
       );
     // `c.declaration` (type-only) belongs on the import clause, not on each
     // specifier — emitting both produces the invalid `import type { type X }`.
     return factory.createImportClause(
-      c.declaration,
+      c.declaration ? SyntaxKind.TypeKeyword : undefined,
       c.default !== null ? factory.createIdentifier(c.default) : undefined,
       c.elements.size() !== 0
         ? factory.createNamedImports(
-            Array.from(c.elements).map(({ first: name, second: alias }) =>
+            Array.from(c.elements).map(({ first: local, second: imported }) =>
               factory.createImportSpecifier(
                 false,
-                alias !== null ? factory.createIdentifier(name) : undefined,
-                factory.createIdentifier(alias ?? name),
+                imported !== local
+                  ? factory.createIdentifier(imported)
+                  : undefined,
+                factory.createIdentifier(local),
               ),
             ),
           )
@@ -172,7 +183,8 @@ interface ICompositeKey {
   default: string | null;
 }
 interface ICompositeValue extends ICompositeKey {
-  elements: TreeMap<string, string | null>;
+  /** Maps each local named binding to the exported name. */
+  elements: TreeMap<string, string>;
 }
 
 const NODE_MODULES = "node_modules/";

package/src/generates/internal/SdkDistributionComposer.ts

@@ -11,36 +11,38 @@ export namespace SdkDistributionComposer {
     websocket: boolean;
   }) => {
     if (!fs.existsSync(props.config.distribute!))
-      await fs.promises.mkdir(props.config.distribute!);
+      await fs.promises.mkdir(props.config.distribute!, { recursive: true });
 
     const root: string = process.cwd();
     const output: string = path.resolve(props.config.output!);
     process.chdir(props.config.distribute!);
+    try {
+      if (await configured()) return;
 
-    const exit = () => process.chdir(root);
-    if (await configured()) return exit();
+      // COPY FILES
+      console.log("Composing SDK distribution environments...");
+      for (const file of await fs.promises.readdir(BUNDLE))
+        await fs.promises.copyFile(`${BUNDLE}/${file}`, file);
 
-    // COPY FILES
-    console.log("Composing SDK distribution environments...");
-    for (const file of await fs.promises.readdir(BUNDLE))
-      await fs.promises.copyFile(`${BUNDLE}/${file}`, file);
+      // CONFIGURE PATHS
+      for (const file of ["package.json", "tsconfig.json"])
+        await replace({ root, output })(file);
 
-    // CONFIGURE PATHS
-    for (const file of ["package.json", "tsconfig.json"])
-      await replace({ root, output })(file);
-
-    // INSTALL PACKAGES
-    const v: IDependencies = await dependencies({ websocket: props.websocket });
-    execute("npm install --save-dev rimraf");
-    execute(`npm install --save @nestia/fetcher@${v.version}`);
-    execute(`npm install --save typia@${v.typia}`);
-    if (props.mcp && v.mcp !== undefined)
-      execute(`npm install --save @modelcontextprotocol/sdk@${v.mcp}`);
-    if (props.websocket && v.tgrid !== undefined)
-      execute(`npm install --save tgrid@${v.tgrid}`);
-    execute("npx typia setup --manager npm");
-
-    exit();
+      // INSTALL PACKAGES
+      const v: IDependencies = await dependencies({
+        websocket: props.websocket,
+      });
+      execute("npm install --save-dev rimraf");
+      execute(`npm install --save @nestia/fetcher@${v.version}`);
+      execute(`npm install --save typia@${v.typia}`);
+      if (props.mcp && v.mcp !== undefined)
+        execute(`npm install --save @modelcontextprotocol/sdk@${v.mcp}`);
+      if (props.websocket && v.tgrid !== undefined)
+        execute(`npm install --save tgrid@${v.tgrid}`);
+      execute("npx typia setup --manager npm");
+    } finally {
+      process.chdir(root);
+    }
   };
 
   const configured = async (): Promise<boolean> =>

package/src/generates/internal/SdkFileProgrammer.ts

@@ -51,9 +51,7 @@ export namespace SdkFileProgrammer {
     (directory: SdkRouteDirectory) =>
     async (outDir: string): Promise<void> => {
       // CREATE A NEW DIRECTORY
-      try {
-        await fs.promises.mkdir(outDir);
-      } catch {}
+      await fs.promises.mkdir(outDir, { recursive: true });
 
       // ITERATE CHILDREN
       const statements: Node[] = [];

package/src/generates/internal/SdkHttpCloneReferencer.ts

@@ -69,22 +69,24 @@ export namespace SdkHttpCloneReferencer {
     directory: string;
     route: ITypedWebSocketRoute;
   }): void => {
-    const unique: Set<string> = new Set();
+    const unique: Map<string, string> = new Map();
     const keep: ITypedWebSocketRoute["imports"] = [];
     for (const imp of props.route.imports) {
       const cloned: string[] = SdkWebSocketCloneProgrammer.isNodeModulesPath(
         imp.file,
       )
         ? []
-        : imp.elements.filter((elem) =>
-            props.cloned.has(
-              SdkWebSocketCloneProgrammer.importKey(imp.file, elem),
-            ),
-          );
+        : imp.elements.filter((elem) => {
+            const imported: string = imp.elementAliases?.[elem] ?? elem;
+            return props.cloned.has(
+              SdkWebSocketCloneProgrammer.importKey(imp.file, imported),
+            );
+          });
       const remained: string[] = imp.elements.filter(
         (elem) => cloned.includes(elem) === false,
       );
-      for (const elem of cloned) unique.add(elem);
+      for (const elem of cloned)
+        unique.set(elem, imp.elementAliases?.[elem] ?? elem);
       if (
         imp.asterisk !== null ||
         imp.default !== null ||
@@ -98,11 +100,14 @@ export namespace SdkHttpCloneReferencer {
 
     props.route.imports = [
       ...keep,
-      ...Array.from(unique).map((str) => ({
-        file: `${props.directory}/${str}`,
+      ...Array.from(unique).map(([local, imported]) => ({
+        file: `${props.directory}/${imported}`,
         asterisk: null,
         default: null,
-        elements: [str],
+        elements: [local],
+        ...(local === imported
+          ? {}
+          : { elementAliases: { [local]: imported } }),
       })),
     ];
   };

package/src/generates/internal/SdkWebSocketCloneProgrammer.ts

@@ -14,9 +14,10 @@ export namespace SdkWebSocketCloneProgrammer {
     for (const route of app.routes)
       if (route.protocol === "websocket")
         for (const imp of route.imports)
-          for (const name of imp.elements) {
-            if (await clone(ctx)(imp.file, name))
-              cloned.add(importKey(imp.file, name));
+          for (const local of imp.elements) {
+            const imported: string = imp.elementAliases?.[local] ?? local;
+            if (await clone(ctx)(imp.file, imported))
+              cloned.add(importKey(imp.file, imported));
           }
     return cloned;
   };