@nestia/sdk 2.5.0-dev.20240130-7 → 2.5.0-dev.20240201

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,115 +1,119 @@
-import path from "path";
-import ts from "typescript";
-
-import { IController } from "../structures/IController";
-import { INestiaProject } from "../structures/INestiaProject";
-import { IRoute } from "../structures/IRoute";
-import { ITypeTuple } from "../structures/ITypeTuple";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-
-export namespace ExceptionAnalyzer {
-  export const analyze =
-    (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (
-      declaration: ts.MethodDeclaration,
-    ): Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput> => {
-      const output: Record<
-        number | "2XX" | "3XX" | "4XX" | "5XX",
-        IRoute.IOutput
-      > = {} as any;
-      for (const decorator of declaration.modifiers ?? [])
-        if (ts.isDecorator(decorator))
-          analyzeTyped(project)(genericDict, importDict)(controller, func)(
-            output,
-          )(decorator);
-      return output;
-    };
-
-  const analyzeTyped =
-    (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (output: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>) =>
-    (decorator: ts.Decorator): boolean => {
-      // CHECK DECORATOR
-      if (!ts.isCallExpression(decorator.expression)) return false;
-      else if ((decorator.expression.typeArguments ?? []).length !== 1)
-        return false;
-
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return false;
-      else if (
-        path
-          .resolve(signature.declaration.getSourceFile().fileName)
-          .indexOf(TYPED_EXCEPTION_PATH) === -1
-      )
-        return false;
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = decorator.expression.typeArguments![0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-      if (type.isTypeParameter()) {
-        project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
-          message: "TypedException() without generic argument specification.",
-        });
-        return false;
-      }
-
-      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(
-        project.checker,
-        genericDict,
-        importDict,
-        type,
-      );
-      if (tuple === null || tuple.typeName === "__type") {
-        project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
-          message: "TypeException() with implicit (unnamed) type.",
-        });
-        return false;
-      }
-
-      // DO ASSIGN
-      const matched: IController.IException[] = Object.entries(func.exceptions)
-        .filter(([_key, value]) =>
-          value.type.includes(" | ") && tuple.typeName.includes(" | ")
-            ? value.type.split(" | ").sort().join(" | ") ===
-              tuple.typeName.split(" | ").sort().join(" | ")
-            : value.type === tuple.typeName,
-        )
-        .map(([_key, value]) => value);
-      for (const m of matched)
-        output[m.status] = {
-          type: tuple.type,
-          typeName: tuple.typeName,
-          contentType: "application/json",
-          description: m.description,
-        };
-      return true;
-    };
-}
-
-const TYPED_EXCEPTION_PATH = path.join(
-  "node_modules",
-  "@nestia",
-  "core",
-  "lib",
-  "decorators",
-  "TypedException.d.ts",
-);
+import path from "path";
+import ts from "typescript";
+
+import { IController } from "../structures/IController";
+import { INestiaProject } from "../structures/INestiaProject";
+import { IRoute } from "../structures/IRoute";
+import { ITypeTuple } from "../structures/ITypeTuple";
+import { GenericAnalyzer } from "./GenericAnalyzer";
+import { ImportAnalyzer } from "./ImportAnalyzer";
+
+export namespace ExceptionAnalyzer {
+  export const analyze =
+    (project: INestiaProject) =>
+    (
+      genericDict: GenericAnalyzer.Dictionary,
+      importDict: ImportAnalyzer.Dictionary,
+    ) =>
+    (controller: IController, func: IController.IFunction) =>
+    (
+      declaration: ts.MethodDeclaration,
+    ): Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput> => {
+      const output: Record<
+        number | "2XX" | "3XX" | "4XX" | "5XX",
+        IRoute.IOutput
+      > = {} as any;
+      for (const decorator of declaration.modifiers ?? [])
+        if (ts.isDecorator(decorator))
+          analyzeTyped(project)(genericDict, importDict)(controller, func)(
+            output,
+          )(decorator);
+      return output;
+    };
+
+  const analyzeTyped =
+    (project: INestiaProject) =>
+    (
+      genericDict: GenericAnalyzer.Dictionary,
+      importDict: ImportAnalyzer.Dictionary,
+    ) =>
+    (controller: IController, func: IController.IFunction) =>
+    (output: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>) =>
+    (decorator: ts.Decorator): boolean => {
+      // CHECK DECORATOR
+      if (!ts.isCallExpression(decorator.expression)) return false;
+      else if ((decorator.expression.typeArguments ?? []).length !== 1)
+        return false;
+
+      // CHECK SIGNATURE
+      const signature: ts.Signature | undefined =
+        project.checker.getResolvedSignature(decorator.expression);
+      if (!signature || !signature.declaration) return false;
+      else if (
+        path
+          .resolve(signature.declaration.getSourceFile().fileName)
+          .indexOf(TYPED_EXCEPTION_PATH) === -1
+      )
+        return false;
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = decorator.expression.typeArguments![0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+      if (type.isTypeParameter()) {
+        project.errors.push({
+          file: controller.file,
+          controller: controller.name,
+          function: func.name,
+          message: "TypedException() without generic argument specification.",
+        });
+        return false;
+      }
+
+      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(
+        project.checker,
+        genericDict,
+        importDict,
+        type,
+      );
+      if (
+        tuple === null ||
+        (project.config.clone !== true &&
+          (tuple.typeName === "__type" || tuple.typeName === "__object"))
+      ) {
+        project.errors.push({
+          file: controller.file,
+          controller: controller.name,
+          function: func.name,
+          message: "TypeException() with implicit (unnamed) type.",
+        });
+        return false;
+      }
+
+      // DO ASSIGN
+      const matched: IController.IException[] = Object.entries(func.exceptions)
+        .filter(([_key, value]) =>
+          value.type.includes(" | ") && tuple.typeName.includes(" | ")
+            ? value.type.split(" | ").sort().join(" | ") ===
+              tuple.typeName.split(" | ").sort().join(" | ")
+            : value.type === tuple.typeName,
+        )
+        .map(([_key, value]) => value);
+      for (const m of matched)
+        output[m.status] = {
+          type: tuple.type,
+          typeName: tuple.typeName,
+          contentType: "application/json",
+          description: m.description,
+        };
+      return true;
+    };
+}
+
+const TYPED_EXCEPTION_PATH = path.join(
+  "node_modules",
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  "TypedException.d.ts",
+);

package/src/generates/CloneGenerator.ts

@@ -14,6 +14,7 @@ export namespace SdkCloneProgrammer {
     async (routes: IRoute[]): Promise<void> => {
       const dict: Map<string, SdkInterfaceProgrammer.IModule> =
         SdkInterfaceProgrammer.write(checker)(config)(routes);
+      if (dict.size === 0) return;
       try {
         await fs.promises.mkdir(`${config.output}/structures`);
       } catch {}

package/src/generates/SdkGenerator.ts

@@ -42,18 +42,6 @@ export namespace SdkGenerator {
           }
         }
       }
-      if (
-        config.simulate === true &&
-        routes.some((r) => !!r.parameters.length)
-      ) {
-        try {
-          await fs.promises.mkdir(`${config.output}/utils`);
-        } catch {}
-        await fs.promises.copyFile(
-          `${BUNDLE_PATH}/utils/NestiaSimulator.ts`,
-          `${config.output}/utils/NestiaSimulator.ts`,
-        );
-      }
 
       // STRUCTURES
       if (config.clone) await SdkCloneProgrammer.write(checker)(config)(routes);

package/src/generates/internal/E2eFileProgrammer.ts

@@ -153,7 +153,11 @@ export namespace E2eFileProgrammer {
                 ts.factory.createVariableDeclaration(
                   "output",
                   undefined,
-                  SdkAliasCollection.output(checker)(config)(importer)(route),
+                  config.propagate !== true && route.output.typeName === "void"
+                    ? undefined
+                    : SdkAliasCollection.output(checker)(config)(importer)(
+                        route,
+                      ),
                   ts.factory.createAwaitExpression(caller),
                 ),
               ],

package/src/generates/internal/SdkAliasCollection.ts

@@ -51,7 +51,7 @@ export namespace SdkAliasCollection {
     (importer: ImportDictionary) =>
     (param: IRoute.IParameter): ts.TypeNode => {
       const type: ts.TypeNode = name(config)(importer)(param);
-      if (config.primitive === false) return type;
+      if (config.clone === true || config.primitive === false) return type;
       return ts.factory.createTypeReferenceNode(
         importer.external({
           type: true,
@@ -73,11 +73,12 @@ export namespace SdkAliasCollection {
         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) ||
-          config.primitive === false
+          filter(ts.TypeFlags.VoidLike)
         )
           return node;
         return ts.factory.createTypeReferenceNode(

package/src/generates/internal/SdkCloneProgrammer.ts

@@ -61,7 +61,12 @@ export namespace SdkInterfaceProgrammer {
           write_alias(config)(importer)(alias),
         );
       for (const object of collection.objects())
-        if (object.name !== "__type" && !object.name.startsWith("__type."))
+        if (
+          object.name !== "__type" &&
+          !object.name.startsWith("__type.") &&
+          object.name !== "__object" &&
+          !object.name.startsWith("__object.")
+        )
           prepare(dict)(object.name)((importer) =>
             write_object(config)(importer)(object),
           );

package/src/generates/internal/SdkFileProgrammer.ts

@@ -75,15 +75,6 @@ export namespace SdkFileProgrammer {
       const importer: ImportDictionary = new ImportDictionary(
         `${outDir}/index.ts`,
       );
-      if (
-        config.simulate === true &&
-        directory.routes.some((r) => !!r.parameters.length)
-      )
-        importer.internal({
-          file: `${config.output}/utils/NestiaSimulator.ts`,
-          instance: "NestiaSimulator",
-          type: false,
-        });
       directory.routes.forEach((route, i) => {
         if (config.clone !== true)
           for (const tuple of route.imports)

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -10,7 +10,7 @@ import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkFunctionProgrammer {
-  export const generate =
+  export const write =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (
@@ -66,13 +66,13 @@ export namespace SdkFunctionProgrammer {
           ),
         ]),
         ts.factory.createBlock(
-          generate_body(config)(importer)(route, props),
+          write_body(config)(importer)(route, props),
           true,
         ),
       );
     };
 
-  const generate_body =
+  const write_body =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (

package/src/generates/internal/SdkNamespaceProgrammer.ts

@@ -9,12 +9,12 @@ import { Escaper } from "typia/lib/utils/Escaper";
 import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
+import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkSimulationProgrammer } from "./SdkSimulationProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-import { FilePrinter } from "./FilePrinter";
 
 export namespace SdkNamespaceProgrammer {
   export const write =

package/src/generates/internal/SdkRouteProgrammer.ts

@@ -3,10 +3,10 @@ import { IJsDocTagInfo } from "typia";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
+import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
 import { SdkNamespaceProgrammer } from "./SdkNamespaceProgrammer";
-import { FilePrinter } from "./FilePrinter";
 
 export namespace SdkRouteProgrammer {
   export const generate =
@@ -25,7 +25,7 @@ export namespace SdkRouteProgrammer {
       };
       return [
         FilePrinter.description(
-          SdkFunctionProgrammer.generate(config)(importer)(route, props),
+          SdkFunctionProgrammer.write(config)(importer)(route, props),
           describe(route),
         ),
         SdkNamespaceProgrammer.write(checker)(config)(importer)(route, props),

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -182,10 +182,10 @@ export namespace SdkSimulationProgrammer {
         ts.factory.createCallExpression(
           IdentifierFactory.access(
             ts.factory.createIdentifier(
-              importer.internal({
-                file: `${config.output}/utils/NestiaSimulator.ts`,
-                instance: "NestiaSimulator",
+              importer.external({
                 type: false,
+                library: `@nestia/fetcher/lib/NestiaSimulator`,
+                instance: "NestiaSimulator",
               }),
             ),
           )("assert"),

package/src/generates/internal/SdkTypeProgrammer.ts

@@ -47,7 +47,12 @@ export namespace SdkTypeProgrammer {
       for (const array of meta.arrays)
         union.push(write_array(config)(importer)(array));
       for (const object of meta.objects)
-        if (object.name === "__type" || object.name.startsWith("__type."))
+        if (
+          object.name === "__type" ||
+          object.name.startsWith("__type.") ||
+          object.name === "__object" ||
+          object.name.startsWith("__object.")
+        )
           union.push(write_object(config)(importer)(object));
         else union.push(write_alias(config)(importer)(object));
       for (const alias of meta.aliases)

package/assets/bundle/api/utils/NestiaSimulator.ts

@@ -1,70 +0,0 @@
-import { HttpError } from "@nestia/fetcher";
-
-import typia from "typia";
-
-export namespace NestiaSimulator {
-    export interface IProps {
-        host: string;
-        path: string;
-        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
-        contentType: string;
-    }
-
-    export const assert = (props: IProps) => {
-        return {
-            param: param(props),
-            query: query(props),
-            body: body(props),
-        };
-    };
-    const param =
-        (props: IProps) =>
-        (name: string) =>
-        <T>(task: () => T): void => {
-            validate(
-                (exp) => `URL parameter "${name}" is not ${exp.expected} type.`,
-            )(props)(task);
-        };
-
-    const query =
-        (props: IProps) =>
-        <T>(task: () => T): void =>
-            validate(
-                () =>
-                    "Request query parameters are not following the promised type.",
-            )(props)(task);
-
-    const body =
-        (props: IProps) =>
-        <T>(task: () => T): void =>
-            validate(() => "Request body is not following the promised type.")(
-                props,
-            )(task);
-
-    const validate =
-        (message: (exp: typia.TypeGuardError) => string, path?: string) =>
-        (props: IProps) =>
-        <T>(task: () => T): void => {
-            try {
-                task();
-            } catch (exp) {
-                if (typia.is<typia.TypeGuardError>(exp))
-                    throw new HttpError(
-                        props.method,
-                        props.host + props.path,
-                        400,
-                        {
-                            "Content-Type": props.contentType,
-                        },
-                        JSON.stringify({
-                            method: exp.method,
-                            path: path ?? exp.path,
-                            expected: exp.expected,
-                            value: exp.value,
-                            message: message(exp),
-                        }),
-                    );
-                throw exp;
-            }
-        };
-}