nestia 2.1.0-dev.20220414 → 2.1.0-dev.20220430

package/src/analyses/ReflectAnalyzer.ts

@@ -1,221 +0,0 @@
-import * as NodePath from "path";
-import { equal } from "tstl/ranges/module";
-
-import { ArrayUtil } from "../utils/ArrayUtil";
-import { StringUtil } from "../utils/StringUtil";
-
-import { IController } from "../structures/IController";
-import { ParamCategory } from "../structures/ParamCategory";
-
-type IModule =
-{
-    [key: string]: any;
-}
-
-export namespace ReflectAnalyzer
-{
-    export async function analyze(unique: WeakSet<any>, file: string): Promise<IController[]>
-    {
-        const module: IModule = await import(file);
-        const ret: IController[] = [];
-
-        for (const tuple of Object.entries(module))
-        {
-            if (unique.has(tuple[1]))
-                continue;
-            else
-                unique.add(tuple[1]);
-
-            const controller: IController | null = _Analyze_controller(file, ...tuple);
-            if (controller !== null)
-                ret.push(controller);
-        }
-        return ret;
-    }
-
-    /* ---------------------------------------------------------
-        CONTROLLER
-    --------------------------------------------------------- */
-    function _Analyze_controller(file: string, name: string, creator: any): IController | null
-    {
-        //----
-        // VALIDATIONS
-        //----
-        // MUST BE TYPE OF A CREATOR WHO HAS THE CONSTRUCTOR
-        if (!(creator instanceof Function && creator.constructor instanceof Function))
-            return null;
-
-        // MUST HAVE THOSE MATADATA
-        else if (ArrayUtil.has(Reflect.getMetadataKeys(creator), "path", "host", "scope:options") === false)
-            return null;
-
-        //----
-        // CONSTRUCTION
-        //----
-        // BASIC INFO
-        const meta: IController = {
-            file,
-            name,
-            path: Reflect.getMetadata("path", creator),
-            functions: []
-        };
-
-        // PARSE CHILDREN DATA
-        for (const tuple of _Get_prototype_entries(creator))
-        {
-            const child: IController.IFunction | null = _Analyze_function(creator.prototype, meta, ...tuple);
-            if (child !== null)
-                meta.functions.push(child);
-        }
-
-        // RETURNS
-        return meta;
-    }
-
-    function _Get_prototype_entries(creator: any): Array<[string, unknown]>
-    {
-        const tuple = Object.entries(creator.prototype);
-        const parent = Object.getPrototypeOf(creator);
-
-        if (parent.prototype !== undefined)
-            tuple.push(..._Get_prototype_entries(parent));
-
-        return tuple;
-    }
-
-    /* ---------------------------------------------------------
-        FUNCTION
-    --------------------------------------------------------- */
-    function _Analyze_function(classProto: any, controller: IController, name: string, proto: any): IController.IFunction | null
-    {
-        //----
-        // VALIDATIONS
-        //----
-        // MUST BE TYPE OF A FUNCTION
-        if (!(proto instanceof Function))
-            return null;
-
-        // MUST HAVE THOSE METADATE
-        else if (ArrayUtil.has(Reflect.getMetadataKeys(proto), "path", "method") === false)
-            return null;
-
-        //----
-        // CONSTRUCTION
-        //----
-        // BASIC INFO
-        const meta: IController.IFunction = {
-            name,
-            method: METHODS[Reflect.getMetadata("method", proto)],
-            path: Reflect.getMetadata("path", proto),
-            parameters: [],
-            encrypted: Reflect.hasMetadata("__interceptors__", proto) 
-                && Reflect.getMetadata("__interceptors__", proto)[0]?.constructor?.name === "EncryptedRouteInterceptor"
-        };
-
-        // PARSE CHILDREN DATA
-        const nestParameters: NestParameters | undefined = Reflect.getMetadata("__routeArguments__", classProto.constructor, name);
-        if (nestParameters === undefined)
-            meta.parameters = [];
-        else
-        {
-            for (const tuple of Object.entries(nestParameters))
-            {
-                const child: IController.IParameter | null = _Analyze_parameter(...tuple);
-                if (child !== null)
-                    meta.parameters.push(child);
-            }
-            meta.parameters = meta.parameters.sort((x, y) => x.index - y.index);
-        }
-
-        // VALIDATE PATH ARGUMENTS
-        const funcPathArguments: string[] = StringUtil.betweens(NodePath.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)
-            throw new Error(`Error on ${controller.name}.${name}(): binded arguments in the "path" between function's decorator and parameters' decorators are different (function: [${funcPathArguments.join(", ")}], parameters: [${paramPathArguments.join(", ")}])`);
-
-        // RETURNS
-        return meta;
-    }
-
-    const METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"];
-
-    /* ---------------------------------------------------------
-        PARAMETER
-    --------------------------------------------------------- */
-    function _Analyze_parameter(key: string, param: INestParam): IController.IParameter | null
-    {
-        const symbol: string = key.split(":")[0];
-        if (symbol.indexOf("__custom") !== -1)
-            return _Analyze_custom_parameter(param);
-
-        const typeIndex: number = Number(symbol[0]);
-        if (isNaN(typeIndex) === true)
-            return null;
-
-        const type: ParamCategory | undefined = NEST_PARAMETER_TYPES[typeIndex];
-        if (type === undefined)
-            return null;
-
-        return {
-            name: key,
-            category: type,
-            index: param.index,
-            field: param.data,
-            encrypted: false
-        }
-    }
-
-    function _Analyze_custom_parameter(param: INestParam): IController.IParameter | null
-    {
-        if (param.factory === undefined)
-            return null;
-        else if (param.factory.name === "EncryptedBody" || param.factory.name === "PlainBody")
-        {
-            return {
-                category: "body",
-                index: param.index,
-                name: param.name,
-                field: param.data,
-                encrypted: param.factory.name === "EncryptedBody"
-            };
-        }
-        else if (param.factory.name === "TypedParam")
-            return {
-                name: param.name,
-                category: "param",
-                index: param.index,
-                field: param.data,
-                encrypted: false
-            };
-        else
-            return null;
-    }
-
-    type NestParameters = {
-        [key: string]: INestParam;
-    }
-
-    interface INestParam
-    {
-        name: string;
-        index: number;
-        factory?: Function;
-        data: string | undefined;
-    }
-
-    const NEST_PARAMETER_TYPES = [
-        undefined, 
-        undefined, 
-        undefined, 
-        "body", 
-        "query",
-        "param",
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-        undefined
-    ] as const;
-}

package/src/analyses/SourceFinder.ts

@@ -1,73 +0,0 @@
-import * as fs from  "fs";
-import glob from "glob";
-import * as path from "path";
-
-import { IConfiguration } from "../IConfiguration";
-
-export namespace SourceFinder
-{
-    export async function find(input: IConfiguration.IInput): Promise<string[]>
-    {
-        const dict: Set<string> = new Set();
-        await decode(input.include, str => dict.add(str));
-        if (input.exclude)
-            await decode(input.exclude, str => dict.delete(str));
-            
-        return [...dict];
-    }
-
-    async function decode
-        (
-            input: string[],
-            closure: (location: string) => void,
-        ): Promise<void>
-    {
-        for (const pattern of input)
-            for (const location of await _Glob(path.resolve(pattern)))
-            {
-                const stats: fs.Stats = await fs.promises.stat(location);
-                if (stats.isDirectory() === true)
-                    await iterate(closure, location);
-                else if (stats.isFile() && _Is_ts_file(location))
-                    closure(location);
-            }
-    }
-
-    async function iterate
-        (
-            closure: (location: string) => void,
-            location: string
-        ): Promise<void>
-    {
-        const directory: string[] = await fs.promises.readdir(location);
-        for (const file of directory)
-        {
-            const next: string = path.resolve(`${location}/${file}`);
-            const stats: fs.Stats = await fs.promises.stat(next);
-
-            if (stats.isDirectory() === true)
-                await iterate(closure, next);
-            else if (stats.isFile() && _Is_ts_file(file))
-                closure(next);
-        }
-    }
-
-    function _Glob(pattern: string): Promise<string[]>
-    {
-        return new Promise((resolve, reject) =>
-        {
-            glob(pattern, (err, matches) =>
-            {
-                if (err)
-                    reject(err);
-                else
-                    resolve(matches.map(str => path.resolve(str)));
-            });
-        });
-    }
-
-    function _Is_ts_file(file: string): boolean
-    {
-        return file.substr(-3) === ".ts" && file.substr(-5) !== ".d.ts";
-    }
-}

package/src/bin/nestia.ts

@@ -1,125 +0,0 @@
-#!/usr/bin/env ts-node
-
-import * as cp from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import * as process from "process";
-
-import { CompilerOptions } from "../internal/CompilerOptions";
-import { stripJsonComments } from "../utils/stripJsonComments";
-
-interface IConfig
-{
-    compilerOptions?: CompilerOptions;
-}
-
-function install(): void
-{
-    // INSTALL DEPENDENCIES
-    for (const lib of ["nestia-fetcher", "typescript-is"])
-    {
-        const command: string = `npm install ${lib}`;
-        cp.execSync(command, { stdio: "inherit" });
-    }
-}
-
-function sdk(file: string): void
-{
-    // PREPARE COMMAND
-    const parameters: string[] = [
-        `npx ts-node -C ttypescript --project "${file}"`,
-        `"${path.relative(process.cwd(), `${__dirname}/../executable/sdk`)}"`,
-        ...process.argv.slice(3)
-    ];
-    const command: string = parameters.join(" ");
-
-    // EXECUTE THE COMMAND, BUT IGNORE WARNINGS
-    cp.execSync
-    (
-        command, 
-        { 
-            stdio: "inherit",
-            env: { 
-                ...process.env, 
-                "NODE_NO_WARNINGS": "1" 
-            } 
-        }
-    );
-}
-
-function configure(config: IConfig): boolean
-{
-    if (!config.compilerOptions)
-    {
-        config.compilerOptions = CompilerOptions.DEFAULT;
-        return true;
-    }
-    else
-        return CompilerOptions.emend(config.compilerOptions);
-}
-
-async function tsconfig(task: (file: string) => void): Promise<void>
-{
-    //----
-    // PREPARE ASSETS
-    //----
-    let prepare: null | (() => Promise<[string, () => Promise<void>]>) = null;
-
-    // NO TSCONFIG.JSON?
-    if (fs.existsSync("tsconfig.json") === false)
-    {
-        const config = { compilerOptions: CompilerOptions.DEFAULT };
-        prepare = CompilerOptions.temporary(config);
-    }
-    else
-    {
-        // HAS TSCONFIG.JSON
-        const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
-        const config = JSON.parse(stripJsonComments(content));
-        
-        // NEED TO ADD TRANSFORM PLUGINS
-        const changed: boolean = configure(config);
-        if (changed === true)
-            prepare = CompilerOptions.temporary(config);
-    }
-
-    //----
-    // EXECUTION
-    //----
-    // CREATE TEMPORARY TSCONFIG
-    const [file, erasure] = prepare ? await prepare() : ["tsconfig.json", null];
-
-    // EXECUTE THE TASK
-    let error: Error | null = null;
-    try
-    {
-        task(file);
-    }
-    catch (exp)
-    {
-        error = exp as Error;
-    }
-
-    // REMOVE THE TEMPORARY TSCONFIG
-    if (erasure)
-        await erasure();
-
-    // THROW ERROR IF EXISTS
-    if (error)
-        throw error;
-}
-
-async function main()
-{
-    if (process.argv[2] === "install")
-        await install();
-    else if (process.argv[2] === "sdk")
-        await tsconfig(sdk);
-    else
-        throw new Error(`nestia supports only two commands; install and sdk, however you typed ${process.argv[2]}`);
-}
-main().catch(exp =>
-{
-    console.log(exp.message);
-    process.exit(-1);
-});

package/src/executable/sdk.ts

@@ -1,89 +0,0 @@
-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";
-
-interface ICommand
-{
-    exclude: string | null;
-    out: string | null;
-}
-
-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
-    {
-        if (command.out === null)
-            throw new Error(`Output directory is not specified. Add the "--out <output_directory>" option.`);
-        config = {
-            input: {
-                include,
-                exclude: command.exclude
-                    ? [command.exclude]
-                    : undefined
-            },
-            output: command.out
-        };
-    }
-    
-    // VALIDATE OUTPUT DIRECTORY
-    const parentPath: string = path.resolve(config.output + "/..");
-    const parentStats: fs.Stats = await fs.promises.stat(parentPath);
-
-    if (parentStats.isDirectory() === false)
-        throw new Error(`Unable to find parent directory of the output path: "${parentPath}".`);
-
-    // GENERATION
-    if (fs.existsSync("tsconfig.json") === true)
-    {
-        const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
-        const options: tsc.CompilerOptions = JSON.parse(stripJsonComments(content)).compilerOptions;
-
-        config.compilerOptions = {
-            ...options,
-            ...(config.compilerOptions || {})
-        };
-    }
-
-    // CALL THE APP.GENERATE()
-    const app: NestiaApplication = new NestiaApplication(config);
-    await app.generate();
-}
-
-async function main(): Promise<void>
-{
-    const command: ICommand = cli.parse({
-        exclude: ["e", "Something to exclude", "string", null],
-        out: ["o", "Output path of the SDK files", "string", null],
-    });
-
-    try
-    {
-        const inputs: string[] = [];
-        for (const arg of process.argv.slice(2))
-        {
-            if (arg[0] === "-")
-                break;
-            inputs.push(arg);
-        }
-        await sdk(inputs, command);
-    }
-    catch (exp)
-    {
-        console.log(exp);
-        process.exit(-1);
-    }
-}
-main();

package/src/generates/FileGenerator.ts

@@ -1,150 +0,0 @@
-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";
-import { FunctionGenerator } from "./FunctionGenerator";
-
-export namespace FileGenerator
-{
-    /* ---------------------------------------------------------
-        CONSTRUCTOR
-    --------------------------------------------------------- */
-    export async function generate(config: IConfiguration, routeList: IRoute[]): Promise<void>
-    {
-        // CONSTRUCT FOLDER TREE
-        const root: Directory = new Directory(null, "functional");
-        for (const route of routeList)
-            emplace(root, route);
-
-        // RELOCATE FOR ONLY ONE CONTROLLER METHOD IN AN URL CASE
-        relocate(root);
-
-        // ITERATE FILES
-        await iterate(!!config.assert, config.output + "/functional", root);
-    }
-
-    function emplace(directory: Directory, route: IRoute): void
-    {
-        // SEPARATE IDENTIFIERS
-        const identifiers: string[] = route.path
-            .split("/")
-            .filter(str => str[0] !== ":" && str.length !== 0)
-            .map(str => str.split("-").join("_").split(".").join("_"));
-
-        for (const key of identifiers)
-        {
-            // EMPLACE IF REQUIRED
-            let it: HashMap.Iterator<string, Directory> = directory.directories.find(key);
-            if (it.equals(directory.directories.end()) === true)
-                it = directory.directories.emplace(key, new Directory(directory, key)).first;
-
-            // FOR THE NEXT STEP
-            directory = it.second;
-        }
-        directory.routes.push(route);
-    }
-
-    function relocate(directory: Directory): void
-    {
-        if (directory.parent !== null 
-            && directory.directories.empty() 
-            && directory.routes.length === 1
-            && directory.name === directory.routes[0].name)
-        {
-            directory.parent.routes.push(directory.routes[0]);
-            directory.parent.directories.erase(directory.name);
-        }
-        else if (directory.directories.empty() === false)
-            for (const it of directory.directories)
-                relocate(it.second);
-    }
-
-    /* ---------------------------------------------------------
-        FILE ITERATOR
-    --------------------------------------------------------- */
-    async function iterate
-        (
-            assert: boolean, 
-            outDir: string, 
-            directory: Directory
-        ): Promise<void>
-    {
-        // CREATE A NEW DIRECTORY
-        try
-        {
-            await fs.promises.mkdir(outDir);
-        }
-        catch {}
-        
-        // ITERATE CHILDREN
-        let content: string = "";
-        for (const it of directory.directories)
-        {
-            await iterate(assert, `${outDir}/${it.first}`, it.second);
-            content += `export * as ${it.first} from "./${it.first}";\n`;
-        }
-        content += "\n";
-
-        // ITERATE ROUTES
-        const importDict: ImportDictionary = new ImportDictionary();
-        for (const route of directory.routes)
-        {
-            for (const tuple of route.imports)
-                for (const instance of tuple[1])
-                    importDict.emplace(tuple[0], false, instance);
-            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 { ${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;
-        }
-
-        content = "/**\n"
-            + " * @packageDocumentation\n"
-            + ` * @module ${directory.module}\n`
-            + " */\n"
-            + "//================================================================\n"
-            + content;
-        await fs.promises.writeFile(`${outDir}/index.ts`, content, "utf8");
-    }
-}
-
-class Directory
-{
-    public readonly module: string;
-    public readonly directories: HashMap<string, Directory>;
-    public readonly routes: IRoute[];
-
-    public constructor(readonly parent: Directory | null, readonly name: string)
-    {
-        this.directories = new HashMap();
-        this.routes = [];
-        this.module = (this.parent !== null)
-            ? `${this.parent.module}.${name}`
-            : `api.${name}`;
-    }
-}