@nestia/sdk 3.10.0 → 3.11.0-dev.20240812

package/src/generates/internal/SdkAliasCollection.ts

@@ -2,25 +2,24 @@ import ts from "typescript";
 import typia from "typia";
 
 import { INestiaProject } from "../../structures/INestiaProject";
-import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
+import { IReflectHttpOperationParameter } from "../../structures/IReflectHttpOperationParameter";
+import { IReflectType } from "../../structures/IReflectType";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
 import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
-  export const name =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput): ts.TypeNode =>
-      p.metadata
-        ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
-        : ts.factory.createTypeReferenceNode(p.typeName);
+  export const name = (type: IReflectType): ts.TypeNode =>
+    ts.factory.createTypeReferenceNode(
+      type.name,
+      type.typeArguments ? type.typeArguments.map(name) : undefined,
+    );
 
   export const headers =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
+    (param: ITypedHttpRouteParameter.IHeaders): ts.TypeNode => {
+      const type: ts.TypeNode = name(param);
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
@@ -35,8 +34,8 @@ export namespace SdkAliasCollection {
   export const query =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
+    (param: ITypedHttpRouteParameter.IQuery): ts.TypeNode => {
+      const type: ts.TypeNode = name(param);
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
@@ -51,8 +50,8 @@ export namespace SdkAliasCollection {
   export const input =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
+    (param: ITypedHttpRouteParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(param.type);
       if (project.config.clone === true || project.config.primitive === false)
         return type;
       return ts.factory.createTypeReferenceNode(
@@ -60,10 +59,11 @@ export namespace SdkAliasCollection {
           type: true,
           library: "@nestia/fetcher",
           instance:
-            typia.is<IReflectHttpOperation.IBodyParameter>(param) &&
-            param.contentType === "multipart/form-data"
-              ? "Resolved"
-              : "Primitive",
+            typia.is<IReflectHttpOperationParameter.IBody>(param) &&
+            (param.contentType === "application/json" ||
+              param.encrypted === true)
+              ? "Primitive"
+              : "Resolved",
         }),
         [type],
       );
@@ -74,40 +74,32 @@ export namespace SdkAliasCollection {
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute): ts.TypeNode => {
       if (project.config.propagate !== true) {
-        const node: ts.TypeNode = name(project)(importer)(route.output);
-        const type = project.checker.getTypeAtLocation(node);
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-
-        if (
-          project.config.clone === true ||
-          project.config.primitive === false ||
-          filter(ts.TypeFlags.Undefined) ||
-          filter(ts.TypeFlags.Never) ||
-          filter(ts.TypeFlags.Void) ||
-          filter(ts.TypeFlags.VoidLike)
-        )
-          return node;
+        if (project.config.clone === true || project.config.primitive === false)
+          return name(route.success.type);
         return ts.factory.createTypeReferenceNode(
           importer.external({
             type: true,
             library: "@nestia/fetcher",
             instance:
-              route.output.contentType === "application/x-www-form-urlencoded"
-                ? "Resolved"
-                : "Primitive",
+              route.success.contentType === "application/json" ||
+              route.success.encrypted === true
+                ? "Primitive"
+                : "Resolved",
           }),
-          [node],
+          [name(route.success.type)],
         );
       }
 
       const branches: IBranch[] = [
         {
-          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
-          type: name(project)(importer)(route.output),
+          status: String(
+            route.success.status ?? (route.method === "POST" ? 201 : 200),
+          ),
+          type: name(route.success.type),
         },
         ...Object.entries(route.exceptions).map(([status, value]) => ({
           status,
-          type: name(project)(importer)(value),
+          type: name(value.type),
         })),
       ];
       return ts.factory.createTypeReferenceNode(
@@ -127,10 +119,10 @@ export namespace SdkAliasCollection {
               ),
             ),
           ),
-          ...(route.status
+          ...(route.success.status
             ? [
                 ts.factory.createLiteralTypeNode(
-                  ts.factory.createNumericLiteral(route.status),
+                  ts.factory.createNumericLiteral(route.success.status),
                 ),
               ]
             : []),

package/src/generates/internal/SdkDistributionComposer.ts

@@ -6,13 +6,16 @@ import typia from "typia";
 import { INestiaConfig } from "../../INestiaConfig";
 
 export namespace SdkDistributionComposer {
-  export const compose = async (config: INestiaConfig, websocket: boolean) => {
-    if (!fs.existsSync(config.distribute!))
-      await fs.promises.mkdir(config.distribute!);
+  export const compose = async (props: {
+    config: INestiaConfig;
+    websocket: boolean;
+  }) => {
+    if (!fs.existsSync(props.config.distribute!))
+      await fs.promises.mkdir(props.config.distribute!);
 
     const root: string = process.cwd();
-    const output: string = path.resolve(config.output!);
-    process.chdir(config.distribute!);
+    const output: string = path.resolve(props.config.output!);
+    process.chdir(props.config.distribute!);
 
     const exit = () => process.chdir(root);
     if (await configured()) return exit();
@@ -31,7 +34,7 @@ export namespace SdkDistributionComposer {
     execute("npm install --save-dev rimraf");
     execute(`npm install --save @nestia/fetcher@${v.version}`);
     execute(`npm install --save typia@${v.typia}`);
-    if (websocket) execute(`npm install --save tgrid@${v.tgrid}`);
+    if (props.websocket) execute(`npm install --save tgrid@${v.tgrid}`);
     execute("npx typia setup --manager npm");
 
     exit();

package/src/generates/internal/SdkFileProgrammer.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import ts from "typescript";
 
 import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedApplication } from "../../structures/ITypedApplication";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
 import { MapUtil } from "../../utils/MapUtil";
@@ -15,18 +16,14 @@ export namespace SdkFileProgrammer {
   /* ---------------------------------------------------------
         CONSTRUCTOR
     --------------------------------------------------------- */
-  export const generate =
-    (project: INestiaProject) =>
-    async (
-      routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
-    ): Promise<void> => {
-      // CONSTRUCT FOLDER TREE
-      const root: SdkRouteDirectory = new SdkRouteDirectory(null, "functional");
-      for (const route of routeList) emplace(root)(route);
+  export const generate = async (app: ITypedApplication): Promise<void> => {
+    // CONSTRUCT FOLDER TREE
+    const root: SdkRouteDirectory = new SdkRouteDirectory(null, "functional");
+    for (const route of app.routes) emplace(root)(route);
 
-      // ITERATE FILES
-      await iterate(project)(root)(project.config.output + "/functional");
-    };
+    // ITERATE FILES
+    await iterate(app.project)(root)(`${app.project.config.output}/functional`);
+  };
 
   const emplace =
     (directory: SdkRouteDirectory) =>
@@ -80,16 +77,16 @@ export namespace SdkFileProgrammer {
       directory.routes.forEach((route, i) => {
         if (project.config.clone !== true || route.protocol === "websocket")
           for (const tuple of route.imports)
-            for (const instance of tuple[1])
+            for (const instance of tuple.instances)
               importer.internal({
-                file: tuple[0],
+                file: tuple.file,
                 instance,
                 type: true,
               });
         statements.push(
           ...(route.protocol === "http"
             ? SdkHttpRouteProgrammer.write(project)(importer)(route)
-            : SdkWebSocketRouteProgrammer.write(project)(importer)(route)),
+            : SdkWebSocketRouteProgrammer.write(importer)(route)),
         );
         if (i !== directory.routes.length - 1)
           statements.push(FilePrinter.enter());

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -1,154 +1,154 @@
-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 { 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 { INestiaProject } from "../../structures/INestiaProject";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { MapUtil } from "../../utils/MapUtil";
-import { FilePrinter } from "./FilePrinter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+// import { INestiaProject } from "../../structures/INestiaProject";
+// import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+// import { MapUtil } from "../../utils/MapUtil";
+// 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) => ts.TypeAliasDeclaration);
-  }
+// export namespace SdkHttpCloneProgrammer {
+//   export interface IModule {
+//     name: string;
+//     children: Map<string, IModule>;
+//     programmer:
+//       | null
+//       | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
+//   }
 
-  export const write =
-    (project: INestiaProject) =>
-    (routes: ITypedHttpRoute[]): 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(project.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(project.checker)({
-            escape: true,
-            constant: true,
-            absorb: false,
-          })(collection)(e.type);
-          if (res.success) e.metadata = res.data;
-        }
-        const res = MetadataFactory.analyze(project.checker)({
-          escape: true,
-          constant: true,
-          absorb: false,
-        })(collection)(r.output.type);
-        if (res.success) r.output.metadata = res.data;
-      }
+//   export const write =
+//     (project: INestiaProject) =>
+//     (routes: ITypedHttpRoute[]): 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(project.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(project.checker)({
+//             escape: true,
+//             constant: true,
+//             absorb: false,
+//           })(collection)(e.type);
+//           if (res.success) e.metadata = res.data;
+//         }
+//         const res = MetadataFactory.analyze(project.checker)({
+//           escape: true,
+//           constant: true,
+//           absorb: false,
+//         })(collection)(r.output.type);
+//         if (res.success) r.success.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(project)(importer)(alias),
-          );
-      for (const object of collection.objects())
-        if (isNamedDeclaration(object.name))
-          prepare(dict)(object.name)((importer) =>
-            write_object(project)(importer)(object),
-          );
-      return dict;
-    };
+//       const dict: Map<string, IModule> = new Map();
+//       for (const alias of collection.aliases())
+//         if (isNamedDeclaration(alias.name))
+//           prepare(dict)(alias.name)((importer) =>
+//             write_alias(project)(importer)(alias),
+//           );
+//       for (const object of collection.objects())
+//         if (isNamedDeclaration(object.name))
+//           prepare(dict)(object.name)((importer) =>
+//             write_object(project)(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! };
+//   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!;
-    };
+//       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 =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (alias: MetadataAlias): ts.TypeAliasDeclaration =>
-      FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-          alias.name.split(".").at(-1)!,
-          [],
-          SdkTypeProgrammer.write(project)(importer)(alias.value),
-        ),
-        writeComment([])(alias.description, alias.jsDocTags),
-      );
+//   const write_alias =
+//     (project: INestiaProject) =>
+//     (importer: ImportDictionary) =>
+//     (alias: MetadataAlias): ts.TypeAliasDeclaration =>
+//       FilePrinter.description(
+//         ts.factory.createTypeAliasDeclaration(
+//           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+//           alias.name.split(".").at(-1)!,
+//           [],
+//           SdkTypeProgrammer.write(project)(importer)(alias.value),
+//         ),
+//         writeComment([])(alias.description, alias.jsDocTags),
+//       );
 
-  const write_object =
-    (project: INestiaProject) =>
-    (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(project)(importer)(object),
-        ),
-        writeComment([])(object.description ?? null, object.jsDocTags),
-      );
-    };
-}
+//   const write_object =
+//     (project: INestiaProject) =>
+//     (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(project)(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 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 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 ?? [];
+//     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");
-  };
+//     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");
+//   };