nestia 2.0.0 → 2.0.1-dev.20220412

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestia",
-  "version": "2.0.0",
+  "version": "2.0.1-dev.20220412",
   "description": "Automatic SDK and Document generator for the NestJS",
   "main": "src/index.ts",
   "bin": {
@@ -37,9 +37,11 @@
     "del": "^6.0.0",
     "glob": "^7.2.0",
     "ts-node": "^9.1.1",
-    "tsconfig-paths": "^3.14.1",
     "tstl": "^2.5.3",
-    "typescript": "^4.6.3"
+    "ttypescript": "^1.5.13",
+    "typescript": "^4.5.3",
+    "typescript-is": "^0.19.0",
+    "typescript-transform-paths": "^3.3.1"
   },
   "devDependencies": {
     "nestia-helper": "^2.0.0",

package/src/IConfiguration.ts

@@ -5,6 +5,7 @@ export interface IConfiguration
     input: string | string[] | IConfiguration.IInput;
     output: string;
     compilerOptions?: tsc.CompilerOptions;
+    assert?: boolean;
 }
 export namespace IConfiguration
 {

package/src/NestiaApplication.ts

@@ -85,7 +85,7 @@ export class NestiaApplication
         }
 
         // DO GENERATE
-        await SdkGenerator.generate(this.config_.output, routeList);
+        await SdkGenerator.generate(this.config_, routeList);
     }
 
     private async is_not_excluded(file: string): Promise<boolean>

package/src/analyses/ReflectAnalyzer.ts

@@ -1,4 +1,4 @@
-import Pather from "path";
+import * as Pather from "path";
 
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { StringUtil } from "../utils/StringUtil";

package/src/analyses/SourceFinder.ts

@@ -1,6 +1,6 @@
-import fs from  "fs";
+import * as fs from  "fs";
 import glob from "glob";
-import path from "path";
+import * as path from "path";
 
 import { IConfiguration } from "../IConfiguration";
 

package/src/bin/nestia.ts

@@ -1,80 +1,123 @@
 #!/usr/bin/env ts-node
 
-import cp from "child_process";
-import fs from "fs";
-import tsc from "typescript";
+import * as cp from "child_process";
+import * as fs from "fs";
+import { CompilerOptions } from "../internal/CompilerOptions";
 
 import { stripJsonComments } from "../utils/stripJsonComments";
 
+interface IConfig
+{
+    compilerOptions?: CompilerOptions;
+}
+
 function install(): void
 {
-    const command: string = "npm install --save nestia-fetcher";
-    cp.execSync(command, { stdio: "inherit" });
+    // INSTALL DEPENDENCIES
+    for (const lib of ["nestia-fetcher", "typescript-is"])
+    {
+        const command: string = `npm install ${lib}`;
+        cp.execSync(command, { stdio: "inherit" });
+    }
 }
 
-function sdk(alias: boolean): void
+function sdk(): void
 {
+    // PREPARE COMMAND
     const parameters: string[] = [
-        alias ? "npx ts-node -r tsconfig-paths/register" : "npx ts-node",
+        "npx ts-node -C ttypescript",
         __dirname + "/../executable/sdk",
         ...process.argv.slice(3)
     ];
     const command: string = parameters.join(" ");
-    cp.execSync(command, { stdio: "inherit" });
+
+    // EXECUTE THE COMMAND, BUT IGNORE WARNINGS
+    cp.execSync
+    (
+        command, 
+        { 
+            stdio: "inherit",
+            env: { "NODE_NO_WARNINGS": "1" } 
+        }
+    );
 }
 
-async function tsconfig(task: (alias: boolean) => void): Promise<void>
+function configure(config: IConfig): boolean
 {
-    // NO TSCONFIG.JSON?
-    if (fs.existsSync("tsconfig.json") === false)
+    if (!config.compilerOptions)
     {
-        task(false);
-        return;
-    }
-
-    const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
-    const json: any = JSON.parse(stripJsonComments(content));
-    const options: tsc.CompilerOptions = json.compilerOptions;
-
-    // NO ALIAS PATHS
-    if (!options.paths || !Object.entries(options.paths).length)
-    {
-        task(false);
-        return;
+        config.compilerOptions = CompilerOptions.DEFAULT;
+        return true;
     }
+    else
+        return CompilerOptions.emend(config.compilerOptions);
+}
 
-    let closer: null | (() => Promise<void>) = null;
-    let error: Error | null = null;
+async function tsconfig(task: () => void): Promise<void>
+{
+    //----
+    // PREPARE ASSETS
+    //----
+    let prepare: null | (() => Promise<void>) = null;
+    let restore: null | (() => Promise<void>) = null;
 
-    if (!options.baseUrl)
+    if (fs.existsSync("tsconfig.json") === false)
     {
-        options.baseUrl = "./";
-        await fs.promises.writeFile
+        // NO TSCONFIG.JSON
+        const config: IConfig = {
+            compilerOptions: CompilerOptions.DEFAULT
+        };
+        prepare = () => fs.promises.writeFile
         (
-            "tsconfig.json", 
-            JSON.stringify(json, null, 2),
+            "tsconfig.json",
+            JSON.stringify(config, null, 2),
             "utf8"
         );
+        restore = () => fs.promises.unlink("tsconfig.json")
+    }
+    else
+    {
+        // HAS TSCONFIG.JSON
+        const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
+        const config: IConfig = JSON.parse(stripJsonComments(content));
+        const changed: boolean = configure(config);
 
-        closer = () => fs.promises.writeFile
-        (
-            "tsconfig.json", 
-            content, 
-            "utf8"
-        );
+        if (changed === true)
+        {
+            // NEED TO ADD TRANSFORM PLUGINS
+            prepare = () => fs.promises.writeFile
+            (
+                "tsconfig.json", 
+                JSON.stringify(config, null, 2),
+                "utf8"
+            );
+            restore = () => fs.promises.writeFile("tsconfig.json", content, "utf8");
+        }
     }
 
+    //----
+    // EXECUTION
+    //----
+    // PREPARE SOMETHING
+    if (prepare !== null)
+        await prepare();
+
+    // EXECUTE THE TASK
+    let error: Error | null = null;
     try
     {
-        task(true);
+        task();
     }
     catch (exp)
     {
         error = exp as Error;
     }
 
-    if (closer)
-        await closer();
+    // RESTORE THE TSCONFIG.JSON
+    if (restore !== null)
+        await restore();
+
+    // THROW ERROR IF EXISTS
     if (error)
         throw error;
 }

package/src/executable/sdk.ts

@@ -1,7 +1,7 @@
-import cli from "cli";
-import fs from "fs";
-import path from "path";
-import tsc from "typescript";
+import * as cli from "cli";
+import * as fs from "fs";
+import * as path from "path";
+import * as tsc from "typescript";
 import { Primitive } from "nestia-fetcher";
 
 import { IConfiguration } from "../IConfiguration";

package/src/generates/FileGenerator.ts

@@ -1,5 +1,6 @@
 import * as fs from "fs";
 import { HashMap } from "tstl/container/HashMap";
+import { IConfiguration } from "../IConfiguration";
 
 import { IRoute } from "../structures/IRoute";
 import { ImportDictionary } from "../utils/ImportDictionary";
@@ -10,7 +11,7 @@ export namespace FileGenerator
     /* ---------------------------------------------------------
         CONSTRUCTOR
     --------------------------------------------------------- */
-    export async function generate(outDir: string, routeList: IRoute[]): Promise<void>
+    export async function generate(config: IConfiguration, routeList: IRoute[]): Promise<void>
     {
         // CONSTRUCT FOLDER TREE
         const root: Directory = new Directory(null, "functional");
@@ -21,7 +22,7 @@ export namespace FileGenerator
         relocate(root);
 
         // ITERATE FILES
-        await iterate(outDir + "/functional", root);
+        await iterate(!!config.assert, config.output + "/functional", root);
     }
 
     function emplace(directory: Directory, route: IRoute): void
@@ -63,7 +64,12 @@ export namespace FileGenerator
     /* ---------------------------------------------------------
         FILE ITERATOR
     --------------------------------------------------------- */
-    async function iterate(outDir: string, directory: Directory): Promise<void>
+    async function iterate
+        (
+            assert: boolean, 
+            outDir: string, 
+            directory: Directory
+        ): Promise<void>
     {
         // CREATE A NEW DIRECTORY
         try
@@ -76,7 +82,7 @@ export namespace FileGenerator
         let content: string = "";
         for (const it of directory.directories)
         {
-            await iterate(`${outDir}/${it.first}`, it.second);
+            await iterate(assert, `${outDir}/${it.first}`, it.second);
             content += `export * as ${it.first} from "./${it.first}";\n`;
         }
         content += "\n";
@@ -88,27 +94,34 @@ export namespace FileGenerator
             for (const tuple of route.imports)
                 for (const instance of tuple[1])
                     importDict.emplace(tuple[0], false, instance);
-            content += FunctionGenerator.generate(route) + "\n\n";
+            content += FunctionGenerator.generate(assert, route) + "\n\n";
         }
 
         // FINALIZE THE CONTENT
         if (directory.routes.length !== 0)
+        {
+            const primitived: boolean = directory.routes.some(route => route.output !== "void" 
+                || route.parameters.some(param => param.category !== "param")
+            );
+            const asserted: boolean = assert 
+                && directory.routes.some(route => route.parameters.length !== 0);
+            
+            const fetcher: string[] = ["Fetcher"];
+            if (primitived) 
+                fetcher.push("Primitive");
+            
             content = ""
-                + `import { AesPkcs5, Fetcher, Primitive } from "nestia-fetcher";\n`
+                + `import { ${fetcher.join(", ")} } from "nestia-fetcher";\n`
                 + `import type { IConnection } from "nestia-fetcher";\n`
+                + (asserted ? `import { assertType } from "typescript-is";\n` : "")
                 + 
                 (
                     importDict.empty()
                         ? ""
                         : "\n" + importDict.toScript(outDir) + "\n"
                 )
-                + content + "\n\n"
-                + "//---------------------------------------------------------\n"
-                + "// TO PREVENT THE UNUSED VARIABLE ERROR\n"
-                + "//---------------------------------------------------------\n"
-                + "AesPkcs5;\n"
-                + "Fetcher;\n"
-                + "Primitive;";
+                + content;
+        }
 
         content = "/**\n"
             + " * @packageDocumentation\n"

package/src/generates/FunctionGenerator.ts

@@ -6,13 +6,13 @@ import { IRoute } from "../structures/IRoute";
 
 export namespace FunctionGenerator
 {
-    export function generate(route: IRoute): string
+    export function generate(assert: boolean, route: IRoute): string
     {
         const query: IRoute.IParameter | undefined = route.parameters.find(param => param.category === "query");
         const input: IRoute.IParameter | undefined = route.parameters.find(param => param.category === "body");
 
         return [head, body, tail]
-            .map(closure => closure(route, query, input))
+            .map(closure => closure(route, query, input, assert))
             .filter(str => !!str)
             .join("\n");
     }
@@ -20,7 +20,13 @@ export namespace FunctionGenerator
     /* ---------------------------------------------------------
         BODY
     --------------------------------------------------------- */
-    function body(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string
+    function body
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined,
+            assert: boolean
+        ): string
     {
         // FETCH ARGUMENTS WITH REQUST BODY
         const parameters = filter_parameters(route, query);
@@ -34,8 +40,15 @@ export namespace FunctionGenerator
         if (input !== undefined)
             fetchArguments.push(input.name);
 
+        const assertions: string = assert === true && route.parameters.length !== 0
+            ? route.parameters
+                .map(param => `    assertType<typeof ${param.name}>(${param.name});`)
+                .join("\n") + "\n\n"
+            : "";
+
         // RETURNS WITH FINALIZATION
         return "{\n"
+            + assertions
             + "    return Fetcher.fetch\n"
             + "    (\n"
             + fetchArguments.map(param => `        ${param}`).join(",\n") + "\n"
@@ -54,7 +67,12 @@ export namespace FunctionGenerator
     /* ---------------------------------------------------------
         HEAD & TAIL
     --------------------------------------------------------- */
-    function head(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string
+    function head
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined
+        ): string
     {
         //----
         // CONSTRUCT COMMENT
@@ -132,7 +150,12 @@ export namespace FunctionGenerator
             + `    ): Promise<${output}>`;
     }
 
-    function tail(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string | null
+    function tail
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined
+        ): string | null
     {
         // LIST UP TYPES
         const types: Pair<string, string>[] = [];

package/src/generates/SdkGenerator.ts

@@ -3,13 +3,18 @@ import { DirectoryUtil } from "../utils/DirectoryUtil";
 
 import { IRoute } from "../structures/IRoute";
 import { FileGenerator } from "./FileGenerator";
+import { IConfiguration } from "../IConfiguration";
 
 export namespace SdkGenerator
 {
-    export async function generate(outDir: string, routeList: IRoute[]): Promise<void>
+    export async function generate
+        (
+            config: IConfiguration,
+            routeList: IRoute[],
+        ): Promise<void>
     {
         // PREPARE NEW DIRECTORIES
-        try { await fs.promises.mkdir(outDir); } catch {}
+        try { await fs.promises.mkdir(config.output); } catch {}
 
         // BUNDLING
         const bundle: string[] = await fs.promises.readdir(BUNDLE);
@@ -21,13 +26,13 @@ export namespace SdkGenerator
             if (stats.isFile() === true)
             {
                 const content: string = await fs.promises.readFile(current, "utf8");
-                await fs.promises.writeFile(`${outDir}/${file}`, content, "utf8");
+                await fs.promises.writeFile(`${config.output}/${file}`, content, "utf8");
             }
         }
-        await DirectoryUtil.copy(BUNDLE + "/__internal", outDir + "/__internal");
+        await DirectoryUtil.copy(BUNDLE + "/__internal", config.output + "/__internal");
         
         // FUNCTIONAL
-        await FileGenerator.generate(outDir, routeList);
+        await FileGenerator.generate(config, routeList);
     }
 }
 

package/src/internal/CompilerOptions.ts

@@ -0,0 +1,113 @@
+export interface CompilerOptions
+{
+    target: string;
+    module: string;
+    lib: string[];
+    strict: boolean;
+    downlevelIteration: boolean;
+    esModuleInterop?: boolean;
+    plugins?: Array<{ 
+        transform?: string 
+    }>;
+    types?: string[];
+    experimentalDecorators?: boolean;
+    emitDecoratorMetadata?: boolean;
+}
+export namespace CompilerOptions
+{   
+    export const DEPENDENCIES: string[] = [
+        "nestia-fetcher", 
+        "typescript-is"
+    ];
+
+    export const TRANSFORMERS: string[] = [
+        "typescript-is/lib/transform-inline/transformer", 
+        "typescript-transform-paths"
+    ];
+
+    export const TYPES: string[] = []
+
+    export const DEFAULT = {
+        target: "es5",
+        module: "commonjs",
+        lib: [
+            "DOM", 
+            "ES2015"
+        ],
+        strict: true,
+        downlevelIteration: true,
+        esModuleInterop: true,
+        plugins: TRANSFORMERS.map(transform => ({ transform })),
+        types: [
+            "node",
+            "reflect-metadata"
+        ],
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+    };
+
+    export function emend(options: CompilerOptions): boolean
+    {
+        // FILL ARRAY DATA
+        if (!options.plugins)
+            options.plugins = [];
+        if (!options.types)
+            options.types = [];
+        
+        // CONSTRUCT CHECKERS
+        const emended: Required<CompilerOptions> = options as Required<CompilerOptions>;
+        const checkers: Array<() => boolean> = [
+            () => 
+            {
+                let changed: boolean = false;
+                for (const transform of CompilerOptions.TRANSFORMERS)
+                {
+                    if (emended.plugins.find(elem => elem.transform === transform) !== undefined)
+                        continue;
+    
+                    changed = true;
+                    emended.plugins.push({ transform });
+                }
+                return changed;
+            },
+            () =>
+            {
+                let changed: boolean = false;
+                for (const type of CompilerOptions.TYPES)
+                {
+                    if (emended.types.find(elem => elem === type) !== undefined)
+                        continue;
+    
+                    changed = true;
+                    emended.types.push(type);
+                }
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.experimentalDecorators !== true;
+                if (changed)
+                    emended.experimentalDecorators = true;
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.emitDecoratorMetadata !== true;
+                if (changed)
+                    emended.emitDecoratorMetadata = true;
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.esModuleInterop !== true;
+                if (changed)
+                    emended.esModuleInterop = true;
+                return changed;
+            }
+        ];
+
+        // DO CHECK IT
+        const checks: boolean[] = checkers.map(func => func());
+        return checks.some(flag => flag);
+    }
+}

package/tsconfig.json

@@ -72,7 +72,11 @@
 
     /* Advanced Options */
     "skipLibCheck": true,                     /* Skip type checking of declaration files. */
-    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "plugins": [
+      { "transform": "typescript-is/lib/transform-inline/transformer" },
+      { "transform": "typescript-transform-paths" }
+    ]
   },
   "include": ["src"]
 }