@nestia/sdk 3.11.0-dev.20240813-10 → 3.11.0-dev.20240814

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 import typia from "typia";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { IReflectHttpOperationParameter } from "../../structures/IReflectHttpOperationParameter";
@@ -7,18 +9,29 @@ 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 = (type: IReflectType): ts.TypeNode =>
+  export const name = ({ type }: { type: IReflectType }): ts.TypeNode =>
     ts.factory.createTypeReferenceNode(
       type.name,
-      type.typeArguments ? type.typeArguments.map(name) : undefined,
+      type.typeArguments
+        ? type.typeArguments.map((a) => name({ type: a }))
+        : undefined,
     );
 
+  export const from =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (metadata: Metadata) =>
+      SdkTypeProgrammer.write(project)(importer)(metadata);
+
   export const headers =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (param: ITypedHttpRouteParameter.IHeaders): ts.TypeNode => {
+      if (project.config.clone === true)
+        return from(project)(importer)(param.metadata);
       const type: ts.TypeNode = name(param);
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
@@ -35,6 +48,8 @@ export namespace SdkAliasCollection {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (param: ITypedHttpRouteParameter.IQuery): ts.TypeNode => {
+      if (project.config.clone === true)
+        return from(project)(importer)(param.metadata);
       const type: ts.TypeNode = name(param);
       if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
@@ -51,9 +66,10 @@ export namespace SdkAliasCollection {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (param: ITypedHttpRouteParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(param.type);
-      if (project.config.clone === true || project.config.primitive === false)
-        return type;
+      if (project.config.clone === true)
+        return from(project)(importer)(param.metadata);
+      const type: ts.TypeNode = name(param);
+      if (project.config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
           type: true,
@@ -73,9 +89,15 @@ export namespace SdkAliasCollection {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute): ts.TypeNode => {
+      const schema = (p: { metadata: Metadata; type: IReflectType }) =>
+        project.config.clone === true
+          ? from(project)(importer)(p.metadata)
+          : name(p);
       if (project.config.propagate !== true) {
-        if (project.config.clone === true || project.config.primitive === false)
-          return name(route.success.type);
+        if (route.success.metadata.size() === 0)
+          return TypeFactory.keyword("void");
+        else if (project.config.primitive === false)
+          return schema(route.success);
         return ts.factory.createTypeReferenceNode(
           importer.external({
             type: true,
@@ -86,7 +108,7 @@ export namespace SdkAliasCollection {
                 ? "Primitive"
                 : "Resolved",
           }),
-          [name(route.success.type)],
+          [schema(route.success)],
         );
       }
 
@@ -95,11 +117,11 @@ export namespace SdkAliasCollection {
           status: String(
             route.success.status ?? (route.method === "POST" ? 201 : 200),
           ),
-          type: name(route.success.type),
+          type: schema(route.success),
         },
         ...Object.entries(route.exceptions).map(([status, value]) => ({
           status,
-          type: name(value.type),
+          type: schema(value),
         })),
       ];
       return ts.factory.createTypeReferenceNode(

package/src/generates/internal/SdkFileProgrammer.ts

@@ -75,7 +75,7 @@ export namespace SdkFileProgrammer {
         `${outDir}/index.ts`,
       );
       directory.routes.forEach((route, i) => {
-        if (project.config.clone !== true || route.protocol === "websocket")
+        if (!(project.config.clone === true && route.protocol === "http"))
           for (const tuple of route.imports)
             for (const instance of tuple.instances)
               importer.internal({

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -1,154 +1,128 @@
-// 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 { 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 { 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) => 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.success.metadata = res.data;
-//       }
+  export const write = (app: ITypedApplication): Map<string, IModule> => {
+    // console.log({
+    //   objects: Array.from(app.collection.objects.keys()).sort(),
+    //   aliases: Array.from(app.collection.aliases.keys()).sort(),
+    // });
+    // 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) => write_object(app.project)(importer)(v),
+        });
+    for (const [k, v] of app.collection.aliases.entries())
+      if (StringUtil.isImplicit(k) === false)
+        prepare({
+          dict,
+          name: k,
+          programmer: (importer) => write_alias(app.project)(importer)(v),
+        });
+    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 = (props: {
+    dict: Map<string, IModule>;
+    name: string;
+    programmer: (importer: ImportDictionary) => ts.TypeAliasDeclaration;
+  }) => {
+    let next: Map<string, IModule> = props.dict;
+    const accessors: string[] = props.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(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!;
+  };
 
-//       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 writeComment =
+  (atomics: MetadataAtomic[]) =>
+  (description: string | null, jsDocTags: IJsDocTagInfo[]): string => {
+    const lines: string[] = [];
+    if (description?.length)
+      lines.push(...description.split("\n").map((s) => `${s}`));
 
-// const isNamedDeclaration = (name: string) =>
-//   name !== "object" &&
-//   name !== "__type" &&
-//   !name.startsWith("__type.") &&
-//   name !== "__object" &&
-//   !name.startsWith("__object.");
+    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 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");
-//   };
+    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

@@ -0,0 +1,71 @@
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IReflectType } from "../../structures/IReflectType";
+import { ITypedApplication } from "../../structures/ITypedApplication";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { StringUtil } from "../../utils/StringUtil";
+
+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 props.route.parameters)
+      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}`,
+      instances: [str],
+    }));
+  };
+
+  const visitType = (p: {
+    unique: Set<string>;
+    metadata: Metadata;
+    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.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.name);
+    p.name(p.metadata.getName());
+  };
+}
+
+const getFullText = (type: IReflectType): string =>
+  type.typeArguments === undefined
+    ? type.name
+    : `${type.name}<${type.typeArguments.map(getFullText).join(", ")}>`;

package/src/generates/internal/SdkHttpFunctionProgrammer.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { INestiaConfig } from "../../INestiaConfig";
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
@@ -55,21 +55,26 @@ export namespace SdkHttpFunctionProgrammer {
                   ? ts.factory.createTypeReferenceNode(
                       `${route.name}.${p === props.query ? "Query" : "Input"}`,
                     )
-                  : SdkAliasCollection.name(p.type),
+                  : project.config.clone === true
+                    ? SdkAliasCollection.from(project)(importer)(p.metadata)
+                    : SdkAliasCollection.name(p),
               ),
             ),
         ],
         ts.factory.createTypeReferenceNode("Promise", [
-          SdkAliasCollection.name(route.success.type),
+          project.config.propagate === true ||
+          route.success.metadata.size() !== 0
+            ? ts.factory.createTypeReferenceNode(`${route.name}.Output`)
+            : ts.factory.createTypeReferenceNode("void"),
         ]),
         ts.factory.createBlock(
-          write_body(project.config)(importer)(route, props),
+          write_body(project)(importer)(route, props),
           true,
         ),
       );
 
   const write_body =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
       route: ITypedHttpRoute,
@@ -83,10 +88,17 @@ export namespace SdkHttpFunctionProgrammer {
         ts.factory.createCallExpression(
           IdentifierFactory.access(
             ts.factory.createIdentifier(
-              SdkImportWizard.Fetcher(!!props.input?.encrypted)(importer),
+              SdkImportWizard.Fetcher(
+                !!props.input?.encrypted || route.success.encrypted,
+              )(importer),
             ),
-          )(config.propagate ? "propagate" : "fetch"),
-          undefined,
+          )(project.config.propagate ? "propagate" : "fetch"),
+          project.config.propagate
+            ? route.method.toLowerCase() === "get" ||
+              route.method.toLowerCase() === "head"
+              ? [TypeFactory.keyword("any")]
+              : [TypeFactory.keyword("any"), TypeFactory.keyword("any")]
+            : undefined,
           [
             props.input?.contentType !== "multipart/form-data"
               ? ts.factory.createObjectLiteralExpression(
@@ -152,7 +164,7 @@ export namespace SdkHttpFunctionProgrammer {
             ...(props.input
               ? [ts.factory.createIdentifier(props.input.name)]
               : []),
-            ...(config.json &&
+            ...(project.config.json &&
             props.input !== undefined &&
             (props.input.contentType === "application/json" ||
               props.input.encrypted === true)
@@ -161,7 +173,7 @@ export namespace SdkHttpFunctionProgrammer {
           ],
         );
       const output = (awaiter: boolean) =>
-        config.simulate
+        project.config.simulate
           ? ts.factory.createConditionalExpression(
               ts.factory.createIdentifier("!!connection.simulate"),
               undefined,
@@ -182,7 +194,7 @@ export namespace SdkHttpFunctionProgrammer {
             ? ts.factory.createAwaitExpression(caller())
             : caller();
       return [
-        ...(config.assert
+        ...(project.config.assert
           ? route.parameters
               .filter((p) => p.category !== "headers")
               .map((p) =>
@@ -205,12 +217,13 @@ export namespace SdkHttpFunctionProgrammer {
           : []),
         ...(route.success.setHeaders.length === 0
           ? [ts.factory.createReturnStatement(output(false))]
-          : write_set_headers(config)(route)(output(true))),
+          : write_set_headers(project)(importer)(route)(output(true))),
       ];
     };
 
   const write_set_headers =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) =>
     (condition: ts.Expression): ts.Statement[] => {
       const accessor = (x: string) => (y: string) =>
@@ -220,7 +233,9 @@ export namespace SdkHttpFunctionProgrammer {
         ...route.parameters.map((p) => p.name),
       ])("output");
       const headers: string = accessor("connection")("headers");
-      const data: string = config.propagate ? accessor(output)("data") : output;
+      const data: string = project.config.propagate
+        ? accessor(output)("data")
+        : output;
 
       const assigners: ts.ExpressionStatement[] = [
         ts.factory.createBinaryExpression(
@@ -255,14 +270,14 @@ export namespace SdkHttpFunctionProgrammer {
               ts.factory.createVariableDeclaration(
                 output,
                 undefined,
-                SdkAliasCollection.name(route.success.type),
+                SdkAliasCollection.output(project)(importer)(route),
                 condition,
               ),
             ],
             ts.NodeFlags.Const,
           ),
         ),
-        ...(config.propagate
+        ...(project.config.propagate
           ? [
               ts.factory.createIfStatement(
                 ts.factory.createIdentifier(accessor(output)("success")),