nestia 0.3.2 → 0.3.6

package/package.json

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

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[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] = get_path(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,20 @@ export namespace FunctionGenerator
             + "}";
     }
 
-    function get_path(route: IRoute, query: IRoute.IParameter | undefined): string
+    function get_path(route: IRoute, query: IRoute.IParameter | undefined): [IRoute.IParameter[], string]
     {
         const parameters = route.parameters.filter(param => param.category === "param");
-        let path: string = route.path;
 
+        let path: string = route.path;
         for (const param of parameters)
             path = path.replace(`:${param.field}`, `\${${param.name}}`);
-
-        new URLSearchParams()
-        return (query !== undefined)
+        path = (query !== undefined)
             ? `\`${path}?\${new URLSearchParams(${query.name} as any).toString()}\``
-            : `\`${path}\``
+            : `\`${path}\``;
+
+        if (query)
+            parameters.push(query);
+        return [parameters, path];
     }
 
     /* ---------------------------------------------------------
@@ -157,12 +150,28 @@ export namespace FunctionGenerator
         if (route.output !== "void")
             types.push(new Pair("Output", route.output));
         
-        if (types.length === 0)
-            return null;
-        
+        const [parameters, path] = get_path(route, query);
         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"
+                    : ""
+            )
+            + `    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`
             + "}";
     }
 }