nestia 2.0.5 → 2.0.6-dev.20220414

package/package.json

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

package/src/bin/nestia.ts

@@ -50,7 +50,7 @@ async function main()
     else if (process.argv[2] === "sdk")
         await sdk();
     else
-        throw new Error(`nestia supports only two commands; install and sdk, however you typed ${process.argv[2]}`);
+        throw new Error(`nestia supports only two commands; install and sdk, however you've typed the "${process.argv[2]}"`);
 }
 main().catch(exp =>
 {

package/src/executable/sdk.ts

@@ -2,11 +2,11 @@ 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";
 import { NestiaApplication } from "../NestiaApplication";
 import { stripJsonComments } from "../utils/stripJsonComments";
+import { NestiaConfig } from "../internal/NestiaConfig";
 
 interface ICommand
 {
@@ -17,13 +17,8 @@ interface ICommand
 async function sdk(include: string[], command: ICommand): Promise<void>
 {
     // CONFIGURATION
-    let config: IConfiguration;
-    if (fs.existsSync("nestia.config.ts") === true)
-        config = Primitive.clone
-        (
-            await import(path.resolve("nestia.config.ts"))
-        );
-    else
+    let config: IConfiguration | null = await NestiaConfig.get();
+    if (config === null)
     {
         if (command.out === null)
             throw new Error(`Output directory is not specified. Add the "--out <output_directory>" option.`);

package/src/internal/NestiaConfig.ts

@@ -0,0 +1,36 @@
+import * as fs from "fs";
+import * as path from "path";
+import { InvalidArgument } from "tstl/exception/InvalidArgument";
+import { Primitive } from "nestia-fetcher";
+import { Singleton } from "tstl/thread/Singleton";
+import { assertType, is } from "typescript-is";
+
+import { IConfiguration } from "../IConfiguration";
+
+export namespace NestiaConfig
+{
+    export function get(): Promise<IConfiguration | null>
+    {
+        return singleton.get();
+    }
+
+    function assert(config: IConfiguration): IConfiguration
+    {
+        assertType<Omit<typeof config, "input"|"compilerOptions">>(config);
+        if (is<string>(config.input) === false
+            && is<string[]>(config.input) === false
+            && is<IConfiguration.IInput>(config.input) === false)
+            throw new InvalidArgument("Error on NestiaConfig.get(): invalid input type.");
+
+        return config;
+    }
+
+    const singleton = new Singleton(async () =>
+    {
+        if (fs.existsSync("nestia.config.ts") === false)
+            return null;
+
+        const config: IConfiguration = await import(path.resolve("nestia.config.ts"));
+        return assert(Primitive.clone(config));
+    });
+}

package/src/internal/TsConfig.ts

@@ -25,7 +25,7 @@ export namespace TsConfig
         emitDecoratorMetadata: true,
         plugins: [
             { transform: "typescript-is/lib/transform-inline/transformer" }, 
-            { transform: "typescript-transform-paths" }
+            // { transform: "typescript-transform-paths" }
         ]
     };
 
@@ -65,51 +65,59 @@ export namespace TsConfig
                 "utf8"
             );
         }
-        else
+        else if (emend(config.compilerOptions as CSON.CommentObject) === true)
         {
-            // FILL ESSENTIAL PROPS
-            const options: CSON.CommentObject = config.compilerOptions as CSON.CommentObject;
-            for (const [key, value] of Object.entries(DEFAULT_OPTIONS))
+            // OVERWRITE THE CONTENT
+            await fs.promises.writeFile
+            (
+                "tsconfig.json",
+                CSON.stringify(config, null, 2),
+                "utf8"
+            );
+        }
+    }
+
+    function emend(options: CSON.CommentObject): boolean
+    {
+        if (options.paths && Object.entries(options.paths).length !== 0)
+            DEFAULT_OPTIONS.plugins.push({ transform: "typescript-transform-paths" });
+
+        let changed: boolean = false;
+        for (const [key, value] of Object.entries(DEFAULT_OPTIONS))
+            if (options[key] instanceof Array && value instanceof Array)
             {
-                if (!options[key])
-                    CSON.assign(config.compilerOptions, { [key]: value });
-                else if (options[key] instanceof Array && value instanceof Array && key !== "plugins")
-                    CSON.assign
-                    (
-                        config.compilerOptions,
-                        { 
-                            [key]: 
-                            [
-                                ...new Set
-                                ([
-                                    ...value, 
-                                    ...options[key] as string[]
-                                ])
-                            ]
-                        }
-                    );
+                merge<any>(options[key] as Array<any>, value,
+                    key !== "plugins"
+                        ? (x, y) => x === y
+                        : (x, y) => x.transform === y.transform
+                );
+                changed ||= true;
             }
-
-            if (!options.plugins)
-                CSON.assign(options.plugins, { plugins: DEFAULT_OPTIONS.plugins });
-            else
+            else if (options[key] !== value)
             {
-                const optionPlugins: CSON.CommentArray<CSON.CommentObject> = options.plugins as CSON.CommentArray<CSON.CommentObject>;
-                for (const plugin of DEFAULT_OPTIONS.plugins)
-                {
-                    const found = optionPlugins.find(elem => elem.transform === plugin.transform);
-                    if (!found)
-                        optionPlugins.push(plugin);
-                }
+                CSON.assign(options, { [key]: value });
+                changed ||= true;
             }
-        }
+        return changed;
+    }
 
-        // OVERWRITE THE CONTENT
-        await fs.promises.writeFile
+    function merge<T>
         (
-            "tsconfig.json",
-            CSON.stringify(config, null, 2),
-            "utf8"
-        );
+            origin: T[], 
+            must: T[], 
+            pred: (a: T, b: T) => boolean
+        ): boolean
+    {
+        let changed: boolean = false;
+        for (const m of must)
+        {
+            const found: T | undefined = origin.find(elem => pred(elem, m));
+            if (found !== undefined)
+                continue;
+
+            origin.push(m);
+            changed ||= true;
+        }
+        return changed;
     }
 }