nestia 0.3.3 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestia",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Automatic SDK and Document generator for the NestJS",
   "main": "src/index.ts",
   "bin": {

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)

package/src/bundle/IConnection.ts

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

package/src/bundle/__internal/Fetcher.ts

@@ -20,7 +20,14 @@ export class Fetcher
     public static fetch<Output>(connection: IConnection, config: Fetcher.IConfig, method: "GET" | "DELETE", path: string): Promise<Primitive<Output>>;
     public static fetch<Input, Output>(connection: IConnection, config: Fetcher.IConfig, method: "POST" | "PUT" | "PATCH", path: string, input: Input): Promise<Primitive<Output>>;
 
-    public static async fetch<Output>(connection: IConnection, config: Fetcher.IConfig, method: string, path: string, input?: object): Promise<Primitive<Output>>
+    public static async fetch<Output>
+        (
+            connection: IConnection, 
+            config: Fetcher.IConfig, 
+            method: string, 
+            path: string, 
+            input?: object
+        ): Promise<Primitive<Output>>
     {
         if (config.input_encrypted === true || config.output_encrypted === true)
             if (connection.encryption === undefined)
@@ -57,12 +64,16 @@ export class Fetcher
         //----
         // RESPONSE MESSAGE
         //----
-        // NORMALIZE PATH
-        if (path !== "" && path[0] !== "/")
-            path = `/${path}`;
+        // 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}`);
 
         // DO FETCH
-        const response: Response = await fetch(`${connection.host}${path}`, init);
+        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,22 +22,14 @@ 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");
@@ -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}";\n`
+            + `    export const PATH = "${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`
             + "}";
     }
 }