nestia 0.3.4 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestia",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Automatic SDK and Document generator for the NestJS",
   "main": "src/index.ts",
   "bin": {
@@ -40,7 +40,7 @@
     "typescript": "^4.3.2"
   },
   "devDependencies": {
-    "encrypted-nestjs": "^0.1.5",
+    "encrypted-nestjs": "^0.1.15",
     "rimraf": "^3.0.2"
   }
 }

package/src/analyses/ControllerAnalyzer.ts

@@ -104,6 +104,8 @@ export namespace ControllerAnalyzer
         let path: string = NodePath.join(controller.path, func.path).split("\\").join("/");
         if (path[0] !== "/")
             path = "/" + path;
+        if (path[path.length - 1] === "/" && path !== "/")
+            path = path.substr(0, path.length - 1);
 
         // RETURNS
         return {

package/src/analyses/ReflectAnalyzer.ts

@@ -1,4 +1,4 @@
-import * as path from "path";
+import Pather from "path";
 
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { StringUtil } from "../utils/StringUtil";
@@ -128,7 +128,7 @@ export namespace ReflectAnalyzer
         }
 
         // VALIDATE PATH ARGUMENTS
-        const funcPathArguments: string[] = StringUtil.betweens(path.join(controller.path, meta.path).split("\\").join("/"), ":", "/").sort();
+        const funcPathArguments: string[] = StringUtil.betweens(Pather.join(controller.path, meta.path).split("\\").join("/"), ":", "/").sort();
         const paramPathArguments: string[] = meta.parameters.filter(param => param.category === "param").map(param => param.field!).sort();
 
         if (equal(funcPathArguments, paramPathArguments) === false)
@@ -158,6 +158,7 @@ export namespace ReflectAnalyzer
             return null;
 
         return {
+            name: key,
             category: type,
             index: param.index,
             field: param.data,
@@ -169,15 +170,19 @@ export namespace ReflectAnalyzer
     {
         if (param.factory === undefined)
             return null;
-        else if (param.factory.name === "EncryptedBody")
+        else if (param.factory.name === "EncryptedBody" || param.factory.name === "PlainBody")
+        {
             return {
                 category: "body",
                 index: param.index,
+                name: param.name,
                 field: param.data,
-                encrypted: true
+                encrypted: param.factory.name === "EncryptedBody"
             };
+        }
         else if (param.factory.name === "TypedParam")
             return {
+                name: param.name,
                 category: "param",
                 index: param.index,
                 field: param.data,
@@ -193,6 +198,7 @@ export namespace ReflectAnalyzer
 
     interface INestParam
     {
+        name: string;
         index: number;
         factory?: Function;
         data: string | undefined;

package/src/bundle/IConnection.ts

@@ -8,7 +8,7 @@ export interface IConnection
     host: string;
     headers?: Record<string, string>;
     encryption?: IConnection.IEncyptionPassword | IConnection.EncryptionClosure;
-    enforcePath?: string;
+    path?: (path: string) => string;
 }
 
 export namespace IConnection

package/src/bundle/__internal/Fetcher.ts

@@ -64,11 +64,16 @@ export class Fetcher
         //----
         // RESPONSE MESSAGE
         //----
-        // DO FETCH
-        if (connection.enforcePath)
-            path = connection.enforcePath;
+        // URL SPECIFICATION
+        if (connection.host[connection.host.length - 1] !== "/" && path[0] !== "/")
+            path = "/" + path;
+        if (connection.path)
+            path = connection.path(path);
+        
+        const url: URL = new URL(`${connection.host}${path}`);
 
-        const response: Response = await fetch(`${connection.host}${path}`, init);
+        // DO FETCH
+        const response: Response = await fetch(url.href, init);
         let content: string = await response.text();
 
         if (!content)

package/src/generates/FunctionGenerator.ts

@@ -2,7 +2,6 @@ import type * as tsc from "typescript";
 import { Pair } from "tstl/utility/Pair";
 import { Vector } from "tstl/container/Vector";
 
-import { Fetcher } from "../bundle/__internal/Fetcher";
 import { IRoute } from "../structures/IRoute";
 
 export namespace FunctionGenerator
@@ -23,25 +22,17 @@ export namespace FunctionGenerator
     --------------------------------------------------------- */
     function body(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string
     {
-        // PATH WITH ENCRYPTION
-        const path: string = get_path(route, query);
-        const config: Fetcher.IConfig = {
-            input_encrypted: input !== undefined && input.encrypted,
-            output_encrypted: route.encrypted
-        };
-
         // FETCH ARGUMENTS WITH REQUST BODY
+        const parameters = filter_parameters(route, query);
         const fetchArguments: string[] = 
         [
             "connection",
-            JSON.stringify(config, null, 4)
-                .split('"').join("")
-                .split("\n").join("\n" + " ".repeat(8)),
-            `"${route.method}"`,
-            path
+            `${route.name}.CONFIG`,
+            `${route.name}.METHOD`,
+            `${route.name}.path(${parameters.map(p => p.name).join(", ")})`
         ];
         if (input !== undefined)
-            fetchArguments.push("input");
+            fetchArguments.push(input.name);
 
         // RETURNS WITH FINALIZATION
         return "{\n"
@@ -52,18 +43,12 @@ export namespace FunctionGenerator
             + "}";
     }
 
-    function get_path(route: IRoute, query: IRoute.IParameter | undefined): string
+    function filter_parameters(route: IRoute, query: IRoute.IParameter | undefined): IRoute.IParameter[]
     {
         const parameters = route.parameters.filter(param => param.category === "param");
-        let path: string = route.path;
-
-        for (const param of parameters)
-            path = path.replace(`:${param.field}`, `\${${param.name}}`);
-
-        new URLSearchParams()
-        return (query !== undefined)
-            ? `\`${path}?\${new URLSearchParams(${query.name} as any).toString()}\``
-            : `\`${path}\``
+        if (query)
+            parameters.push(query);
+        return parameters;
     }
 
     /* ---------------------------------------------------------
@@ -149,6 +134,7 @@ export namespace FunctionGenerator
 
     function tail(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string | null
     {
+        // LIST UP TYPES
         const types: Pair<string, string>[] = [];
         if (query !== undefined)
             types.push(new Pair("Query", query.type));
@@ -157,12 +143,36 @@ export namespace FunctionGenerator
         if (route.output !== "void")
             types.push(new Pair("Output", route.output));
         
-        if (types.length === 0)
-            return null;
-        
+        // PATH WITH PARAMETERS
+        const parameters = filter_parameters(route, query);
+        let path: string = route.path;
+        for (const param of parameters)
+            if (param.category === "param")
+                path = path.replace(`:${param.field}`, `\${${param.name}}`);
+        path = (query !== undefined)
+            ? `\`${path}?\${new URLSearchParams(${query.name} as any).toString()}\``
+            : `\`${path}\``;
+
         return `export namespace ${route.name}\n`
             + "{\n"
-            + (types.map(tuple => `    export type ${tuple.first} = Primitive<${tuple.second}>;`).join("\n")) + "\n"
+            + 
+            (
+                types.length !== 0
+                    ? types.map(tuple => `    export type ${tuple.first} = Primitive<${tuple.second}>;`).join("\n") + "\n\n"
+                    : ""
+            )
+            + "\n"
+            + `    export const METHOD = "${route.method}" as const;\n`
+            + `    export const PATH: string = "${route.path}";\n`
+            + `    export const CONFIG = {\n`
+            + `        input_encrypted: ${input !== undefined && input.encrypted},\n`
+            + `        output_encrypted: ${route.encrypted},\n`
+            + `    };\n`
+            + "\n"
+            + `    export function path(${parameters.map(param => `${param.name}: ${param.type}`).join(", ")}): string\n`
+            + `    {\n`
+            + `        return ${path};\n`
+            + `    }\n`
             + "}";
     }
 }

package/src/structures/IController.ts

@@ -22,6 +22,7 @@ export namespace IController
 
     export interface IParameter
     {
+        name: string;
         index: number;
         field: string | undefined;
         category: ParamCategory;