@nestia/sdk 3.0.5 → 3.1.0-dev.20240426

package/src/generates/internal/{SdkFunctionProgrammer.ts → SdkHttpFunctionProgrammer.ts}

@@ -3,23 +3,24 @@ import typia from "typia";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
 import { INestiaConfig } from "../../INestiaConfig";
-import { IController } from "../../structures/IController";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { StringUtil } from "../../utils/StringUtil";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
-export namespace SdkFunctionProgrammer {
+export namespace SdkHttpFunctionProgrammer {
   export const write =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.FunctionDeclaration => {
       return ts.factory.createFunctionDeclaration(
@@ -50,20 +51,20 @@ export namespace SdkFunctionProgrammer {
                 p.optional
                   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                   : undefined,
-                config.primitive !== false &&
+                project.config.primitive !== false &&
                   (p === props.query || p === props.input)
                   ? ts.factory.createTypeReferenceNode(
                       `${route.name}.${p === props.query ? "Query" : "Input"}`,
                     )
-                  : getTypeName(config)(importer)(p),
+                  : getTypeName(project)(importer)(p),
               ),
             ),
         ],
         ts.factory.createTypeReferenceNode("Promise", [
-          getReturnType(config)(route),
+          getReturnType(project.config)(route),
         ]),
         ts.factory.createBlock(
-          write_body(config)(importer)(route, props),
+          write_body(project.config)(importer)(route, props),
           true,
         ),
       );
@@ -73,11 +74,11 @@ export namespace SdkFunctionProgrammer {
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.Statement[] => {
       const encrypted: boolean =
@@ -88,7 +89,7 @@ export namespace SdkFunctionProgrammer {
           props.input.encrypted === true);
       const contentType: string | undefined =
         props.input !== undefined
-          ? typia.is<IController.IBodyParameter>(props.input)
+          ? typia.is<IReflectHttpOperation.IBodyParameter>(props.input)
             ? props.input.contentType
             : "application/json"
           : undefined;
@@ -157,7 +158,7 @@ export namespace SdkFunctionProgrammer {
               ? [ts.factory.createIdentifier(props.input.name)]
               : []),
             ...(config.json &&
-            typia.is<IController.IBodyParameter>(props.input) &&
+            typia.is<IReflectHttpOperation.IBodyParameter>(props.input) &&
             (props.input.contentType === "application/json" ||
               props.input.encrypted === true)
               ? [ts.factory.createIdentifier(`${route.name}.stringify`)]
@@ -215,7 +216,7 @@ export namespace SdkFunctionProgrammer {
 
   const write_set_headers =
     (config: INestiaConfig) =>
-    (route: IRoute) =>
+    (route: ITypedHttpRoute) =>
     (condition: ts.Expression): ts.Statement[] => {
       const accessor = (x: string) => (y: string) =>
         x[0] === "[" ? `${x}${y}` : `${x}.${y}`;
@@ -283,14 +284,14 @@ export namespace SdkFunctionProgrammer {
 }
 
 const getTypeName =
-  (config: INestiaConfig) =>
+  (project: INestiaProject) =>
   (importer: ImportDictionary) =>
-  (p: IRoute.IParameter | IRoute.IOutput) =>
+  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);
 
-const getReturnType = (config: INestiaConfig) => (route: IRoute) =>
+const getReturnType = (config: INestiaConfig) => (route: ITypedHttpRoute) =>
   ts.factory.createTypeReferenceNode(
     config.propagate !== true && route.output.typeName === "void"
       ? "void"

package/src/generates/internal/{SdkNamespaceProgrammer.ts → SdkHttpNamespaceProgrammer.ts}

@@ -6,30 +6,29 @@ import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { Escaper } from "typia/lib/utils/Escaper";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IController } from "../../structures/IController";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkHttpSimulationProgrammer } from "./SdkHttpSimulationProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
-import { SdkSimulationProgrammer } from "./SdkSimulationProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
-export namespace SdkNamespaceProgrammer {
+export namespace SdkHttpNamespaceProgrammer {
   export const write =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.ModuleDeclaration => {
-      const types = write_types(checker)(config)(importer)(route, props);
+      const types = write_types(project)(importer)(route, props);
       return ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier(route.name),
@@ -38,23 +37,21 @@ export namespace SdkNamespaceProgrammer {
           ...(types.length ? [FilePrinter.enter()] : []),
           write_metadata(importer)(route, props),
           FilePrinter.enter(),
-          write_path(config)(importer)(route, props),
-          ...(config.simulate
+          write_path(project)(importer)(route, props),
+          ...(project.config.simulate
             ? [
-                SdkSimulationProgrammer.random(checker)(config)(importer)(
-                  route,
-                ),
-                SdkSimulationProgrammer.simulate(config)(importer)(
+                SdkHttpSimulationProgrammer.random(project)(importer)(route),
+                SdkHttpSimulationProgrammer.simulate(project)(importer)(
                   route,
                   props,
                 ),
               ]
             : []),
-          ...(config.json &&
-          typia.is<IController.IBodyParameter>(props.input) &&
+          ...(project.config.json &&
+          typia.is<IReflectHttpOperation.IBodyParameter>(props.input) &&
           (props.input.contentType === "application/json" ||
             props.input.encrypted === true)
-            ? [write_stringify(config)(importer)]
+            ? [write_stringify(project)(importer)]
             : []),
         ]),
         ts.NodeFlags.Namespace,
@@ -62,15 +59,14 @@ export namespace SdkNamespaceProgrammer {
     };
 
   const write_types =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.TypeAliasDeclaration[] => {
       const array: ts.TypeAliasDeclaration[] = [];
@@ -86,34 +82,31 @@ export namespace SdkNamespaceProgrammer {
       if (props.headers !== undefined)
         declare(
           "Headers",
-          SdkAliasCollection.headers(config)(importer)(props.headers),
+          SdkAliasCollection.headers(project)(importer)(props.headers),
         );
       if (props.query !== undefined)
         declare(
           "Query",
-          SdkAliasCollection.query(config)(importer)(props.query),
+          SdkAliasCollection.query(project)(importer)(props.query),
         );
       if (props.input !== undefined)
         declare(
           "Input",
-          SdkAliasCollection.input(config)(importer)(props.input),
-        );
-      if (config.propagate === true || route.output.typeName !== "void")
-        declare(
-          "Output",
-          SdkAliasCollection.output(checker)(config)(importer)(route),
+          SdkAliasCollection.input(project)(importer)(props.input),
         );
+      if (project.config.propagate === true || route.output.typeName !== "void")
+        declare("Output", SdkAliasCollection.output(project)(importer)(route));
       return array;
     };
 
   const write_metadata =
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.VariableStatement =>
       constant("METADATA")(
@@ -132,7 +125,9 @@ export namespace SdkNamespaceProgrammer {
                 "request",
                 props.input
                   ? LiteralFactory.generate(
-                      typia.is<IController.IBodyParameter>(props.input)
+                      typia.is<IReflectHttpOperation.IBodyParameter>(
+                        props.input,
+                      )
                         ? {
                             type: props.input.contentType,
                             encrypted: !!props.input.encrypted,
@@ -188,12 +183,12 @@ export namespace SdkNamespaceProgrammer {
       );
 
   const write_path =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        query: IRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.VariableStatement => {
       const g = {
@@ -217,7 +212,7 @@ export namespace SdkNamespaceProgrammer {
                 p.name,
                 p === props.query
                   ? ts.factory.createTypeReferenceNode(`${route.name}.Query`)
-                  : getType(config)(importer)(p),
+                  : getType(project)(importer)(p),
               ),
             ),
             undefined,
@@ -444,7 +439,7 @@ export namespace SdkNamespaceProgrammer {
     };
 
   const write_stringify =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary): ts.VariableStatement =>
       constant("stringify")(
         ts.factory.createArrowFunction(
@@ -463,7 +458,7 @@ export namespace SdkNamespaceProgrammer {
               IdentifierFactory.access(
                 ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
               )("json"),
-            )(config.assert ? "stringify" : "assertStringify"),
+            )(project.config.assert ? "stringify" : "assertStringify"),
             undefined,
             [ts.factory.createIdentifier("input")],
           ),
@@ -502,9 +497,9 @@ const constant = (name: string) => (expression: ts.Expression) =>
     ),
   );
 const getType =
-  (config: INestiaConfig) =>
+  (project: INestiaProject) =>
   (importer: ImportDictionary) =>
-  (p: IRoute.IParameter | IRoute.IOutput) =>
+  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/{SdkRouteProgrammer.ts → SdkHttpRouteProgrammer.ts}

@@ -1,19 +1,18 @@
 import ts from "typescript";
 import { IJsDocTagInfo } from "typia";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
-import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
-import { SdkNamespaceProgrammer } from "./SdkNamespaceProgrammer";
+import { SdkHttpFunctionProgrammer } from "./SdkHttpFunctionProgrammer";
+import { SdkHttpNamespaceProgrammer } from "./SdkHttpNamespaceProgrammer";
 
-export namespace SdkRouteProgrammer {
-  export const generate =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+export namespace SdkHttpRouteProgrammer {
+  export const write =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.Statement[] => {
+    (route: ITypedHttpRoute): ts.Statement[] => {
       const props = {
         headers: route.parameters.find(
           (p) => p.category === "headers" && p.field === undefined,
@@ -25,14 +24,14 @@ export namespace SdkRouteProgrammer {
       };
       return [
         FilePrinter.description(
-          SdkFunctionProgrammer.write(config)(importer)(route, props),
+          SdkHttpFunctionProgrammer.write(project)(importer)(route, props),
           describe(route),
         ),
-        SdkNamespaceProgrammer.write(checker)(config)(importer)(route, props),
+        SdkHttpNamespaceProgrammer.write(project)(importer)(route, props),
       ];
     };
 
-  const describe = (route: IRoute): string => {
+  const describe = (route: ITypedHttpRoute): string => {
     // MAIN DESCRIPTION
     const comments: string[] = route.description
       ? route.description.split("\n")
@@ -74,7 +73,7 @@ export namespace SdkRouteProgrammer {
     // POSTFIX
     if (!!comments.length) comments.push("");
     comments.push(
-      `@controller ${route.target.class.name}.${route.target.function.name}`,
+      `@controller ${route.controller.name}.${route.name}`,
       `@path ${route.method} ${route.path}`,
       `@nestia Generated by Nestia - https://github.com/samchon/nestia`,
     );

package/src/generates/internal/{SdkSimulationProgrammer.ts → SdkHttpSimulationProgrammer.ts}

@@ -5,21 +5,19 @@ import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
-export namespace SdkSimulationProgrammer {
+export namespace SdkHttpSimulationProgrammer {
   export const random =
-    (checker: ts.TypeChecker) =>
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.VariableStatement => {
-      const output =
-        SdkAliasCollection.responseBody(checker)(config)(importer)(route);
+    (route: ITypedHttpRoute): ts.VariableStatement => {
+      const output = SdkAliasCollection.responseBody(project)(importer)(route);
       return constant("random")(
         ts.factory.createArrowFunction(
           undefined,
@@ -40,7 +38,7 @@ export namespace SdkSimulationProgrammer {
               ),
             ),
           ],
-          config.primitive === false
+          project.config.primitive === false
             ? output
             : ts.factory.createTypeReferenceNode(
                 SdkImportWizard.Resolved(importer),
@@ -59,18 +57,18 @@ export namespace SdkSimulationProgrammer {
     };
 
   export const simulate =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (
-      route: IRoute,
+      route: ITypedHttpRoute,
       props: {
-        headers: IRoute.IParameter | undefined;
-        query: IRoute.IParameter | undefined;
-        input: IRoute.IParameter | undefined;
+        headers: ITypedHttpRoute.IParameter | undefined;
+        query: ITypedHttpRoute.IParameter | undefined;
+        input: ITypedHttpRoute.IParameter | undefined;
       },
     ): ts.VariableStatement => {
       const output: boolean =
-        config.propagate === true || route.output.typeName !== "void";
+        project.config.propagate === true || route.output.typeName !== "void";
       const caller = () =>
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("random"),
@@ -127,12 +125,12 @@ export namespace SdkSimulationProgrammer {
                   p.optional
                     ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                     : undefined,
-                  config.primitive !== false &&
+                  project.config.primitive !== false &&
                     (p === props.query || p === props.input)
                     ? ts.factory.createTypeReferenceNode(
                         `${route.name}.${p === props.query ? "Query" : "Input"}`,
                       )
-                    : getTypeName(config)(importer)(p),
+                    : getTypeName(project)(importer)(p),
                 ),
               ),
           ],
@@ -140,9 +138,9 @@ export namespace SdkSimulationProgrammer {
           undefined,
           ts.factory.createBlock(
             [
-              ...assert(config)(importer)(route),
+              ...assert(project)(importer)(route),
               ts.factory.createReturnStatement(
-                config.propagate
+                project.config.propagate
                   ? ts.factory.createObjectLiteralExpression(
                       [
                         ts.factory.createPropertyAssignment(
@@ -176,9 +174,9 @@ export namespace SdkSimulationProgrammer {
     };
 
   const assert =
-    (config: INestiaConfig) =>
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): ts.Statement[] => {
+    (route: ITypedHttpRoute): ts.Statement[] => {
       const parameters = route.parameters.filter(
         (p) => p.category !== "headers",
       );
@@ -272,7 +270,7 @@ export namespace SdkSimulationProgrammer {
 
       return [
         validator,
-        ...(config.propagate !== true
+        ...(project.config.propagate !== true
           ? individual
           : [tryAndCatch(importer)(individual)]),
       ];
@@ -357,9 +355,9 @@ const constant = (name: string) => (expression: ts.Expression) =>
   );
 
 const getTypeName =
-  (config: INestiaConfig) =>
+  (project: INestiaProject) =>
   (importer: ImportDictionary) =>
-  (p: IRoute.IParameter | IRoute.IOutput) =>
+  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkRouteDirectory.ts

@@ -1,9 +1,10 @@
-import { IRoute } from "../../structures/IRoute";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
 
 export class SdkRouteDirectory {
   public readonly module: string;
   public readonly children: Map<string, SdkRouteDirectory>;
-  public readonly routes: IRoute[];
+  public readonly routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>;
 
   public constructor(
     readonly parent: SdkRouteDirectory | null,