@nestia/sdk 12.0.0-dev.20260601.1 → 12.0.0-dev.20260612.2

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -1,126 +1,126 @@
-import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
-import {
-  MetadataAliasType,
-  MetadataAtomic,
-  MetadataObjectType,
-} from "../../internal/legacy";
-import { IPointer } from "tstl";
-import { IJsDocTagInfo } from "typia";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { ITypedApplication } from "../../structures/ITypedApplication";
-import { MapUtil } from "../../utils/MapUtil";
-import { StringUtil } from "../../utils/StringUtil";
-import { FilePrinter } from "./FilePrinter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace SdkHttpCloneProgrammer {
-  export interface IModule {
-    name: string;
-    children: Map<string, IModule>;
-    programmer:
-      | null
-      | ((importer: ImportDictionary) => Node);
-  }
-
-  export const write = (app: ITypedApplication): Map<string, IModule> => {
-    // COMPOSE THE DICTIONARY
-    const dict: Map<string, IModule> = new Map();
-    for (const [k, v] of app.collection.objects.entries())
-      if (StringUtil.isImplicit(k) === false)
-        prepare({
-          dict,
-          name: k,
-          programmer: (importer) => writeObject(app.project)(importer)(v),
-        });
-    for (const [k, v] of app.collection.aliases.entries())
-      if (StringUtil.isImplicit(k) === false)
-        prepare({
-          dict,
-          name: k,
-          programmer: (importer) => writeAlias(app.project)(importer)(v),
-        });
-    return dict;
-  };
-
-  const prepare = (props: {
-    dict: Map<string, IModule>;
-    name: string;
-    programmer: (importer: ImportDictionary) => Node;
-  }) => {
-    let next: Map<string, IModule> = props.dict;
-    const accessors: string[] = props.name.split(".");
-    const modulo: IPointer<IModule> = { value: null! };
-
-    accessors.forEach((acc, i) => {
-      modulo.value = MapUtil.take(next, acc, () => ({
-        name: acc,
-        children: new Map(),
-        programmer: null,
-      }));
-      if (i === accessors.length - 1)
-        modulo.value.programmer = props.programmer;
-      next = modulo.value.children;
-    });
-    return modulo!;
-  };
-
-  const writeAlias =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (alias: MetadataAliasType): Node =>
-      FilePrinter.description(
-        TypeScriptFactory.createTypeAliasDeclaration(
-          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
-          alias.name.split(".").at(-1)!,
-          [],
-          SdkTypeProgrammer.write(project)(importer)(alias.value),
-        ),
-        writeComment([])(alias.description, alias.jsDocTags),
-      );
-
-  const writeObject =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (object: MetadataObjectType): Node => {
-      return FilePrinter.description(
-        TypeScriptFactory.createTypeAliasDeclaration(
-          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
-          object.name.split(".").at(-1)!,
-          [],
-          SdkTypeProgrammer.write_object(project)(importer)(object),
-        ),
-        writeComment([])(object.description ?? null, object.jsDocTags),
-      );
-    };
-}
-
-const writeComment =
-  (atomics: MetadataAtomic[]) =>
-  (description: string | null, jsDocTags: IJsDocTagInfo[]): string => {
-    const lines: string[] = [];
-    if (description?.length)
-      lines.push(...description.split("\n").map((s) => `${s}`));
-
-    const filtered: IJsDocTagInfo[] =
-      !!atomics.length && !!jsDocTags?.length
-        ? jsDocTags.filter(
-            (tag) =>
-              !atomics.some((a) =>
-                a.tags.some((r) => r.some((t) => t.kind === tag.name)),
-              ),
-          )
-        : (jsDocTags ?? []);
-
-    if (description?.length && filtered.length) lines.push("");
-    if (filtered.length)
-      lines.push(
-        ...filtered.map((t) =>
-          t.text?.length
-            ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
-            : `@${t.name}`,
-        ),
-      );
-    return lines.join("\n");
-  };
+import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import {
+  MetadataAliasType,
+  MetadataAtomic,
+  MetadataObjectType,
+} from "../../internal/legacy";
+import { IPointer } from "tstl";
+import { IJsDocTagInfo } from "typia";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedApplication } from "../../structures/ITypedApplication";
+import { MapUtil } from "../../utils/MapUtil";
+import { StringUtil } from "../../utils/StringUtil";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkHttpCloneProgrammer {
+  export interface IModule {
+    name: string;
+    children: Map<string, IModule>;
+    programmer:
+      | null
+      | ((importer: ImportDictionary) => Node);
+  }
+
+  export const write = (app: ITypedApplication): Map<string, IModule> => {
+    // COMPOSE THE DICTIONARY
+    const dict: Map<string, IModule> = new Map();
+    for (const [k, v] of app.collection.objects.entries())
+      if (StringUtil.isImplicit(k) === false)
+        prepare({
+          dict,
+          name: k,
+          programmer: (importer) => writeObject(app.project)(importer)(v),
+        });
+    for (const [k, v] of app.collection.aliases.entries())
+      if (StringUtil.isImplicit(k) === false)
+        prepare({
+          dict,
+          name: k,
+          programmer: (importer) => writeAlias(app.project)(importer)(v),
+        });
+    return dict;
+  };
+
+  const prepare = (props: {
+    dict: Map<string, IModule>;
+    name: string;
+    programmer: (importer: ImportDictionary) => Node;
+  }) => {
+    let next: Map<string, IModule> = props.dict;
+    const accessors: string[] = props.name.split(".");
+    const modulo: IPointer<IModule> = { value: null! };
+
+    accessors.forEach((acc, i) => {
+      modulo.value = MapUtil.take(next, acc, () => ({
+        name: acc,
+        children: new Map(),
+        programmer: null,
+      }));
+      if (i === accessors.length - 1)
+        modulo.value.programmer = props.programmer;
+      next = modulo.value.children;
+    });
+    return modulo!;
+  };
+
+  const writeAlias =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (alias: MetadataAliasType): Node =>
+      FilePrinter.description(
+        TypeScriptFactory.createTypeAliasDeclaration(
+          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+          alias.name.split(".").at(-1)!,
+          [],
+          SdkTypeProgrammer.write(project)(importer)(alias.value),
+        ),
+        writeComment([])(alias.description, alias.jsDocTags),
+      );
+
+  const writeObject =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (object: MetadataObjectType): Node => {
+      return FilePrinter.description(
+        TypeScriptFactory.createTypeAliasDeclaration(
+          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+          object.name.split(".").at(-1)!,
+          [],
+          SdkTypeProgrammer.write_object(project)(importer)(object),
+        ),
+        writeComment([])(object.description ?? null, object.jsDocTags),
+      );
+    };
+}
+
+const writeComment =
+  (atomics: MetadataAtomic[]) =>
+  (description: string | null, jsDocTags: IJsDocTagInfo[]): string => {
+    const lines: string[] = [];
+    if (description?.length)
+      lines.push(...description.split("\n").map((s) => `${s}`));
+
+    const filtered: IJsDocTagInfo[] =
+      !!atomics.length && !!jsDocTags?.length
+        ? jsDocTags.filter(
+            (tag) =>
+              !atomics.some((a) =>
+                a.tags.some((r) => r.some((t) => t.kind === tag.name)),
+              ),
+          )
+        : (jsDocTags ?? []);
+
+    if (description?.length && filtered.length) lines.push("");
+    if (filtered.length)
+      lines.push(
+        ...filtered.map((t) =>
+          t.text?.length
+            ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
+            : `@${t.name}`,
+        ),
+      );
+    return lines.join("\n");
+  };

package/src/generates/internal/SdkHttpCloneReferencer.ts

@@ -1,77 +1,131 @@
-import { MetadataSchema, nameOf } from "../../internal/legacy";
-
-import { IReflectType } from "../../structures/IReflectType";
-import { ITypedApplication } from "../../structures/ITypedApplication";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { StringUtil } from "../../utils/StringUtil";
-import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
-
-export namespace SdkHttpCloneReferencer {
-  export const replace = (app: ITypedApplication): void => {
-    const directory: string = `${app.project.config.output}/structures`;
-    for (const route of app.routes)
-      if (route.protocol === "http")
-        visitRoute({
-          directory,
-          route,
-        });
-  };
-
-  const visitRoute = (props: {
-    directory: string;
-    route: ITypedHttpRoute;
-  }): void => {
-    const unique: Set<string> = new Set();
-    for (const p of SdkHttpParameterProgrammer.getSignificant(
-      props.route,
-      true,
-    ))
-      visitType({
-        unique,
-        metadata: p.metadata,
-        type: p.type,
-        name: (name) => (p.type = { name }),
-      });
-    for (const v of Object.values(props.route.exceptions))
-      visitType({
-        unique,
-        metadata: v.metadata,
-        type: v.type,
-        name: (name) => (v.type = { name }),
-      });
-    visitType({
-      unique,
-      metadata: props.route.success.metadata,
-      type: props.route.success.type,
-      name: (name) => (props.route.success.type = { name }),
-    });
-    props.route.imports = Array.from(unique).map((str) => ({
-      file: `${props.directory}/${str}`,
-      asterisk: null,
-      default: null,
-      elements: [str],
-    }));
-  };
-
-  const visitType = (p: {
-    unique: Set<string>;
-    metadata: MetadataSchema;
-    type: IReflectType;
-    name: (key: string) => void;
-  }): void => {
-    const enroll = (key: string) => {
-      if (key.length && StringUtil.isImplicit(key) === false)
-        p.unique.add(key.split(".")[0]!);
-    };
-    for (const alias of p.metadata.aliases) enroll(alias.type!.name);
-    for (const array of p.metadata.arrays) enroll(array.type!.name);
-    for (const tuple of p.metadata.tuples) enroll(tuple.type!.name);
-    for (const object of p.metadata.objects) enroll(object.type!.name);
-    p.name(nameOf(p.metadata));
-  };
-}
-
-const getFullText = (type: IReflectType): string =>
-  type.typeArguments === undefined
-    ? type.name
-    : `${type.name}<${type.typeArguments.map(getFullText).join(", ")}>`;
+import { MetadataSchema, nameOf } from "../../internal/legacy";
+import { IReflectType } from "../../structures/IReflectType";
+import { ITypedApplication } from "../../structures/ITypedApplication";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+import { StringUtil } from "../../utils/StringUtil";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
+import { SdkWebSocketCloneProgrammer } from "./SdkWebSocketCloneProgrammer";
+
+export namespace SdkHttpCloneReferencer {
+  export const replace = (
+    app: ITypedApplication,
+    websocket: Set<string> = new Set(),
+  ): void => {
+    const directory: string = `${app.project.config.output}/structures`;
+    for (const route of app.routes)
+      if (route.protocol === "http")
+        visitHttpRoute({
+          directory,
+          route,
+        });
+      else if (route.protocol === "websocket")
+        visitWebSocketRoute({
+          cloned: websocket,
+          directory,
+          route,
+        });
+  };
+
+  const visitHttpRoute = (props: {
+    directory: string;
+    route: ITypedHttpRoute;
+  }): void => {
+    const unique: Set<string> = new Set();
+    for (const p of SdkHttpParameterProgrammer.getSignificant(
+      props.route,
+      true,
+    ))
+      visitType({
+        unique,
+        metadata: p.metadata,
+        type: p.type,
+        name: (name) => (p.type = { name }),
+      });
+    for (const v of Object.values(props.route.exceptions))
+      visitType({
+        unique,
+        metadata: v.metadata,
+        type: v.type,
+        name: (name) => (v.type = { name }),
+      });
+    if (props.route.success.binary === false)
+      visitType({
+        unique,
+        metadata: props.route.success.metadata,
+        type: props.route.success.type,
+        name: (name) => (props.route.success.type = { name }),
+      });
+    props.route.imports = Array.from(unique).map((str) => ({
+      file: `${props.directory}/${str}`,
+      asterisk: null,
+      default: null,
+      elements: [str],
+    }));
+  };
+
+  const visitWebSocketRoute = (props: {
+    cloned: Set<string>;
+    directory: string;
+    route: ITypedWebSocketRoute;
+  }): void => {
+    const unique: Set<string> = new Set();
+    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),
+            ),
+          );
+      const remained: string[] = imp.elements.filter(
+        (elem) => cloned.includes(elem) === false,
+      );
+      for (const elem of cloned) unique.add(elem);
+      if (
+        imp.asterisk !== null ||
+        imp.default !== null ||
+        remained.length !== 0
+      )
+        keep.push({
+          ...imp,
+          elements: remained,
+        });
+    }
+
+    props.route.imports = [
+      ...keep,
+      ...Array.from(unique).map((str) => ({
+        file: `${props.directory}/${str}`,
+        asterisk: null,
+        default: null,
+        elements: [str],
+      })),
+    ];
+  };
+
+  const visitType = (p: {
+    unique: Set<string>;
+    metadata: MetadataSchema;
+    type: IReflectType;
+    name: (key: string) => void;
+  }): void => {
+    const enroll = (key: string) => {
+      if (key.length && StringUtil.isImplicit(key) === false)
+        p.unique.add(key.split(".")[0]!);
+    };
+    for (const alias of p.metadata.aliases) enroll(alias.type!.name);
+    for (const array of p.metadata.arrays) enroll(array.type!.name);
+    for (const tuple of p.metadata.tuples) enroll(tuple.type!.name);
+    for (const object of p.metadata.objects) enroll(object.type!.name);
+    p.name(nameOf(p.metadata));
+  };
+}
+
+const getFullText = (type: IReflectType): string =>
+  type.typeArguments === undefined
+    ? type.name
+    : `${type.name}<${type.typeArguments.map(getFullText).join(", ")}>`;