@nestia/sdk 2.6.3-dev.20240328 → 2.6.4-dev.20240401

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,152 +1,152 @@
-import ts from "typescript";
-import typia from "typia";
-
-import { INestiaConfig } from "../../INestiaConfig";
-import { IController } from "../../structures/IController";
-import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace SdkAliasCollection {
-  export const name =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
-      p.metadata
-        ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
-        : ts.factory.createTypeReferenceNode(p.typeName);
-
-  export const headers =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const query =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const input =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.clone === true || config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance:
-            typia.is<IController.IBodyParameter>(param) &&
-            param.contentType === "multipart/form-data"
-              ? "Resolved"
-              : "Primitive",
-        }),
-        [type],
-      );
-    };
-
-  export const output =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): ts.TypeNode => {
-      if (config.propagate !== true) {
-        const node: ts.TypeNode = name(config)(importer)(route.output);
-        const type = checker.getTypeAtLocation(node);
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-
-        if (
-          config.clone === true ||
-          config.primitive === false ||
-          filter(ts.TypeFlags.Undefined) ||
-          filter(ts.TypeFlags.Never) ||
-          filter(ts.TypeFlags.Void) ||
-          filter(ts.TypeFlags.VoidLike)
-        )
-          return node;
-        return ts.factory.createTypeReferenceNode(
-          importer.external({
-            type: true,
-            library: "@nestia/fetcher",
-            instance:
-              route.output.contentType === "application/x-www-form-urlencoded"
-                ? "Resolved"
-                : "Primitive",
-          }),
-          [node],
-        );
-      }
-
-      const branches: IBranch[] = [
-        {
-          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
-          type: name(config)(importer)(route.output),
-        },
-        ...Object.entries(route.exceptions).map(([status, value]) => ({
-          status,
-          type: name(config)(importer)(value),
-        })),
-      ];
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "IPropagation",
-        }),
-        [
-          ts.factory.createTypeLiteralNode(
-            branches.map((b) =>
-              ts.factory.createPropertySignature(
-                undefined,
-                ts.factory.createNumericLiteral(b.status),
-                undefined,
-                b.type,
-              ),
-            ),
-          ),
-          ...(route.status
-            ? [
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createNumericLiteral(route.status),
-                ),
-              ]
-            : []),
-        ],
-      );
-    };
-
-  export const responseBody =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): ts.TypeNode =>
-      output(checker)({ ...config, propagate: false })(importer)(route);
-}
-
-interface IBranch {
-  status: string;
-  type: ts.TypeNode;
-}
+import ts from "typescript";
+import typia from "typia";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IController } from "../../structures/IController";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkAliasCollection {
+  export const name =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
+      p.metadata
+        ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+        : ts.factory.createTypeReferenceNode(p.typeName);
+
+  export const headers =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const query =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const input =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.clone === true || config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance:
+            typia.is<IController.IBodyParameter>(param) &&
+            param.contentType === "multipart/form-data"
+              ? "Resolved"
+              : "Primitive",
+        }),
+        [type],
+      );
+    };
+
+  export const output =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode => {
+      if (config.propagate !== true) {
+        const node: ts.TypeNode = name(config)(importer)(route.output);
+        const type = checker.getTypeAtLocation(node);
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+
+        if (
+          config.clone === true ||
+          config.primitive === false ||
+          filter(ts.TypeFlags.Undefined) ||
+          filter(ts.TypeFlags.Never) ||
+          filter(ts.TypeFlags.Void) ||
+          filter(ts.TypeFlags.VoidLike)
+        )
+          return node;
+        return ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance:
+              route.output.contentType === "application/x-www-form-urlencoded"
+                ? "Resolved"
+                : "Primitive",
+          }),
+          [node],
+        );
+      }
+
+      const branches: IBranch[] = [
+        {
+          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
+          type: name(config)(importer)(route.output),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: name(config)(importer)(value),
+        })),
+      ];
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "IPropagation",
+        }),
+        [
+          ts.factory.createTypeLiteralNode(
+            branches.map((b) =>
+              ts.factory.createPropertySignature(
+                undefined,
+                ts.factory.createNumericLiteral(b.status),
+                undefined,
+                b.type,
+              ),
+            ),
+          ),
+          ...(route.status
+            ? [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createNumericLiteral(route.status),
+                ),
+              ]
+            : []),
+        ],
+      );
+    };
+
+  export const responseBody =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode =>
+      output(checker)({ ...config, propagate: false })(importer)(route);
+}
+
+interface IBranch {
+  status: string;
+  type: ts.TypeNode;
+}

package/src/generates/internal/SdkCloneProgrammer.ts

@@ -1,155 +1,155 @@
-import { IPointer } from "tstl";
-import ts from "typescript";
-import { IJsDocTagInfo } from "typia";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { MetadataAlias } from "typia/lib/schemas/metadata/MetadataAlias";
-import { MetadataAtomic } from "typia/lib/schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
-
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { MapUtil } from "../../utils/MapUtil";
-import { FilePrinter } from "./FilePrinter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace SdkCloneProgrammer {
-  export interface IModule {
-    name: string;
-    children: Map<string, IModule>;
-    programmer:
-      | null
-      | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
-  }
-
-  export const write =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
-    (routes: IRoute[]): Map<string, IModule> => {
-      const collection = new MetadataCollection({
-        replace: MetadataCollection.replace,
-      });
-      for (const r of routes) {
-        for (const p of r.parameters) {
-          const res = MetadataFactory.analyze(checker)({
-            escape: false,
-            constant: true,
-            absorb: false,
-          })(collection)(p.type);
-          if (res.success) p.metadata = res.data;
-        }
-        for (const e of Object.values(r.exceptions)) {
-          const res = MetadataFactory.analyze(checker)({
-            escape: true,
-            constant: true,
-            absorb: false,
-          })(collection)(e.type);
-          if (res.success) e.metadata = res.data;
-        }
-        const res = MetadataFactory.analyze(checker)({
-          escape: true,
-          constant: true,
-          absorb: false,
-        })(collection)(r.output.type);
-        if (res.success) r.output.metadata = res.data;
-      }
-
-      const dict: Map<string, IModule> = new Map();
-      for (const alias of collection.aliases())
-        if (isNamedDeclaration(alias.name))
-          prepare(dict)(alias.name)((importer) =>
-            write_alias(config)(importer)(alias),
-          );
-      for (const object of collection.objects())
-        if (isNamedDeclaration(object.name))
-          prepare(dict)(object.name)((importer) =>
-            write_object(config)(importer)(object),
-          );
-      return dict;
-    };
-
-  const prepare =
-    (dict: Map<string, IModule>) =>
-    (name: string) =>
-    (programmer: (importer: ImportDictionary) => ts.TypeAliasDeclaration) => {
-      const accessors: string[] = name.split(".");
-      const modulo: IPointer<IModule> = { value: null! };
-
-      accessors.forEach((acc, i) => {
-        modulo.value = MapUtil.take(dict, acc, () => ({
-          name: acc,
-          children: new Map(),
-          programmer: null,
-        }));
-        if (i === accessors.length - 1) modulo.value.programmer = programmer;
-        dict = modulo.value.children;
-      });
-      return modulo!;
-    };
-
-  const write_alias =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (alias: MetadataAlias): ts.TypeAliasDeclaration =>
-      FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-          alias.name.split(".").at(-1)!,
-          [],
-          SdkTypeProgrammer.write(config)(importer)(alias.value),
-        ),
-        writeComment([])(alias.description, alias.jsDocTags),
-      );
-
-  const write_object =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (object: MetadataObject): ts.TypeAliasDeclaration => {
-      return FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-          object.name.split(".").at(-1)!,
-          [],
-          SdkTypeProgrammer.write_object(config)(importer)(object),
-        ),
-        writeComment([])(object.description ?? null, object.jsDocTags),
-      );
-    };
-}
-
-const isNamedDeclaration = (name: string) =>
-  name !== "object" &&
-  name !== "__type" &&
-  !name.startsWith("__type.") &&
-  name !== "__object" &&
-  !name.startsWith("__object.");
-
-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 { IPointer } from "tstl";
+import ts from "typescript";
+import { IJsDocTagInfo } from "typia";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { MetadataAlias } from "typia/lib/schemas/metadata/MetadataAlias";
+import { MetadataAtomic } from "typia/lib/schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { MapUtil } from "../../utils/MapUtil";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkCloneProgrammer {
+  export interface IModule {
+    name: string;
+    children: Map<string, IModule>;
+    programmer:
+      | null
+      | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
+  }
+
+  export const write =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (routes: IRoute[]): Map<string, IModule> => {
+      const collection = new MetadataCollection({
+        replace: MetadataCollection.replace,
+      });
+      for (const r of routes) {
+        for (const p of r.parameters) {
+          const res = MetadataFactory.analyze(checker)({
+            escape: false,
+            constant: true,
+            absorb: false,
+          })(collection)(p.type);
+          if (res.success) p.metadata = res.data;
+        }
+        for (const e of Object.values(r.exceptions)) {
+          const res = MetadataFactory.analyze(checker)({
+            escape: true,
+            constant: true,
+            absorb: false,
+          })(collection)(e.type);
+          if (res.success) e.metadata = res.data;
+        }
+        const res = MetadataFactory.analyze(checker)({
+          escape: true,
+          constant: true,
+          absorb: false,
+        })(collection)(r.output.type);
+        if (res.success) r.output.metadata = res.data;
+      }
+
+      const dict: Map<string, IModule> = new Map();
+      for (const alias of collection.aliases())
+        if (isNamedDeclaration(alias.name))
+          prepare(dict)(alias.name)((importer) =>
+            write_alias(config)(importer)(alias),
+          );
+      for (const object of collection.objects())
+        if (isNamedDeclaration(object.name))
+          prepare(dict)(object.name)((importer) =>
+            write_object(config)(importer)(object),
+          );
+      return dict;
+    };
+
+  const prepare =
+    (dict: Map<string, IModule>) =>
+    (name: string) =>
+    (programmer: (importer: ImportDictionary) => ts.TypeAliasDeclaration) => {
+      const accessors: string[] = name.split(".");
+      const modulo: IPointer<IModule> = { value: null! };
+
+      accessors.forEach((acc, i) => {
+        modulo.value = MapUtil.take(dict, acc, () => ({
+          name: acc,
+          children: new Map(),
+          programmer: null,
+        }));
+        if (i === accessors.length - 1) modulo.value.programmer = programmer;
+        dict = modulo.value.children;
+      });
+      return modulo!;
+    };
+
+  const write_alias =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (alias: MetadataAlias): ts.TypeAliasDeclaration =>
+      FilePrinter.description(
+        ts.factory.createTypeAliasDeclaration(
+          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+          alias.name.split(".").at(-1)!,
+          [],
+          SdkTypeProgrammer.write(config)(importer)(alias.value),
+        ),
+        writeComment([])(alias.description, alias.jsDocTags),
+      );
+
+  const write_object =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (object: MetadataObject): ts.TypeAliasDeclaration => {
+      return FilePrinter.description(
+        ts.factory.createTypeAliasDeclaration(
+          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+          object.name.split(".").at(-1)!,
+          [],
+          SdkTypeProgrammer.write_object(config)(importer)(object),
+        ),
+        writeComment([])(object.description ?? null, object.jsDocTags),
+      );
+    };
+}
+
+const isNamedDeclaration = (name: string) =>
+  name !== "object" &&
+  name !== "__type" &&
+  !name.startsWith("__type.") &&
+  name !== "__object" &&
+  !name.startsWith("__object.");
+
+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");
+  };