nestia 2.0.5 → 2.0.7-dev.20220414

package/src/NestiaApplication.ts

@@ -1,96 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as tsc from "typescript";
-import { Pair } from "tstl/utility/Pair";
-import { Singleton } from "tstl/thread/Singleton";
-
-import { ControllerAnalyzer } from "./analyses/ControllerAnalyzer";
-import { ReflectAnalyzer } from "./analyses/ReflectAnalyzer";
-import { SourceFinder } from "./analyses/SourceFinder";
-import { SdkGenerator } from "./generates/SdkGenerator";
-
-import { IConfiguration } from "./IConfiguration";
-import { IController } from "./structures/IController";
-import { IRoute } from "./structures/IRoute";
-import { ArrayUtil } from "./utils/ArrayUtil";
-
-export class NestiaApplication
-{
-    private readonly config_: IConfiguration;
-    private readonly bundle_checker_: Singleton<Promise<(str: string) => boolean>>;
-
-    public constructor(config: IConfiguration)
-    {
-        this.config_ = config;
-        this.bundle_checker_ = new Singleton(async () =>
-        {
-            const bundles: string[] = await fs.promises.readdir(`${__dirname}${path.sep}bundle`);
-            const tuples: Pair<string, boolean>[] = await ArrayUtil.asyncMap(bundles, async file =>
-            {
-                const relative: string = `${this.config_.output}${path.sep}${file}`;
-                const stats: fs.Stats = await fs.promises.stat(`${__dirname}${path.sep}bundle${path.sep}${file}`);
-
-                return new Pair(relative, stats.isDirectory());
-            });
-
-            return (file: string): boolean =>
-            {
-                for (const it of tuples)
-                    if (it.second === false && file === it.first)
-                        return true;
-                    else if (it.second === true && file.indexOf(it.first) === 0)
-                        return true;
-                return false;
-            };
-        });
-    }
-
-    public async generate(): Promise<void>
-    {
-        // LOAD CONTROLLER FILES
-        const input: IConfiguration.IInput = this.config_.input instanceof Array
-            ? { include: this.config_.input }
-            : typeof this.config_.input === "string"
-                ? { include: [ this.config_.input ] }
-                : this.config_.input;
-        const fileList: string[] = await ArrayUtil.asyncFilter
-        (
-            await SourceFinder.find(input),
-            file => this.is_not_excluded(file)
-        );
-
-        // ANALYZE REFLECTS
-        const unique: WeakSet<any> = new WeakSet();
-        const controllerList: IController[] = [];
-        
-        for (const file of fileList)
-            controllerList.push(...await ReflectAnalyzer.analyze(unique, file));
-
-        // ANALYZE TYPESCRIPT CODE
-        const program: tsc.Program = tsc.createProgram
-        (
-            controllerList.map(c => c.file), 
-            this.config_.compilerOptions || {}
-        );
-        const checker: tsc.TypeChecker = program.getTypeChecker();
-
-        const routeList: IRoute[] = [];
-        for (const controller of controllerList)
-        {
-            const sourceFile: tsc.SourceFile | undefined = program.getSourceFile(controller.file);
-            if (sourceFile === undefined)
-                continue;
-
-            routeList.push(...ControllerAnalyzer.analyze(checker, sourceFile, controller));
-        }
-
-        // DO GENERATE
-        await SdkGenerator.generate(this.config_, routeList);
-    }
-
-    private async is_not_excluded(file: string): Promise<boolean>
-    {
-        return file.indexOf(`${this.config_.output}${path.sep}functional`) === -1
-            && (await this.bundle_checker_.get())(file) === false;
-    }
-}

package/src/analyses/ControllerAnalyzer.ts

@@ -1,154 +0,0 @@
-import * as NodePath from "path";
-import * as tsc from "typescript";
-import { HashMap } from "tstl/container/HashMap";
-
-import { IController } from "../structures/IController";
-import { IRoute } from "../structures/IRoute";
-
-import { GenericAnalyzer } from "./GenericAnalyzer";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-
-export namespace ControllerAnalyzer
-{
-    export function analyze(checker: tsc.TypeChecker, sourceFile: tsc.SourceFile, controller: IController): IRoute[]
-    {
-        // FIND CONTROLLER CLASS
-        const ret: IRoute[] = [];
-        tsc.forEachChild(sourceFile, node =>
-        {
-            if (tsc.isClassDeclaration(node) && node.name?.escapedText === controller.name)
-            {
-                // ANALYZE THE CONTROLLER
-                ret.push(..._Analyze_controller(checker, controller, node));
-                return;
-            }
-        });
-        return ret;
-    }
-
-    /* ---------------------------------------------------------
-        CLASS
-    --------------------------------------------------------- */
-    function _Analyze_controller
-        (
-            checker: tsc.TypeChecker, 
-            controller: IController, 
-            classNode: tsc.ClassDeclaration
-        ): IRoute[]
-    {
-        const ret: IRoute[] = [];
-        const classType: tsc.InterfaceType = checker.getTypeAtLocation(classNode) as tsc.InterfaceType;
-        const genericDict: GenericAnalyzer.Dictionary = GenericAnalyzer.analyze(checker, classNode);
-
-        for (const property of classType.getProperties())
-            if (property.declarations)
-                for (const declaration of property.declarations)
-                {
-                    // TARGET ONLY METHOD
-                    if (!tsc.isMethodDeclaration(declaration))
-                        continue;
-                    
-                    // IT MUST BE
-                    const identifier = declaration.name;
-                    if (!tsc.isIdentifier(identifier))
-                        continue;
-                
-                    // ANALYZED WITH THE REFLECTED-FUNCTION
-                    const func: IController.IFunction | undefined = controller.functions.find(f => f.name === identifier.escapedText);
-                    if (func !== undefined)
-                        ret.push(_Analyze_function(checker, controller, genericDict, func, declaration));
-                }
-        return ret;
-    }
-
-    /* ---------------------------------------------------------
-        FUNCTION
-    --------------------------------------------------------- */
-    function _Analyze_function
-        (
-            checker: tsc.TypeChecker, 
-            controller: IController, 
-            genericDict: GenericAnalyzer.Dictionary,
-            func: IController.IFunction, 
-            declaration: tsc.MethodDeclaration
-        ): IRoute
-    {
-        // PREPARE ASSETS
-        const signature: tsc.Signature | undefined = checker.getSignatureFromDeclaration(declaration);
-        if (signature === undefined)
-            throw new Error(`Error on ControllerAnalyzer._Analyze_function(): unable to get the ignature from the ${controller.name}.${func.name}().`);
-        
-        const importDict: ImportAnalyzer.Dictionary = new HashMap();
-
-        // EXPLORE CHILDREN TYPES
-        const parameters: IRoute.IParameter[] = func.parameters.map(param => _Analyze_parameter
-        (
-            checker, 
-            genericDict, 
-            importDict, 
-            controller,
-            func.name,
-            param, 
-            declaration.parameters[param.index]
-        ));
-        const output: string = ImportAnalyzer.analyze
-        (
-            checker,
-            genericDict,
-            importDict,
-            checker.getReturnTypeOfSignature(signature),
-        );
-        const imports: [string, string[]][] = importDict.toJSON().map(pair => [pair.first, pair.second.toJSON()]);
-
-        // CONFIGURE PATH
-        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 {
-            ...func,
-            path,
-            parameters,
-            output,
-            imports,
-
-            symbol: `${controller.name}.${func.name}()`,
-            comments: signature.getDocumentationComment(undefined),
-            tags: signature.getJsDocTags()
-        };
-    }
-
-    /* ---------------------------------------------------------
-        PARAMETER
-    --------------------------------------------------------- */
-    function _Analyze_parameter
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary,
-            importDict: ImportAnalyzer.Dictionary,
-            controller: IController,
-            funcName: string,
-            param: IController.IParameter, 
-            declaration: tsc.ParameterDeclaration
-        ): IRoute.IParameter
-    {
-        const symbol: tsc.Symbol = checker.getSymbolAtLocation(declaration.name)!;
-        const type: tsc.Type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
-        const name: string = symbol.getEscapedName().toString();
-
-        // VALIDATE PARAMETERS
-        if ((param.category === "query" || param.category === "body") && param.field !== undefined)
-            throw new Error(`Error on ${controller.name}.${funcName}(): parameter ${name} is specifying a field ${param.field} of the request ${param.category} message, however, Nestia does not support the field specialization for the request ${param.category} message. Erase the ${controller.name}.${funcName}()#${name} parameter and re-define a new decorator accepting full structured message.`);
-
-        return {
-            name,
-            category: param.category,
-            field: param.field,
-            encrypted: param.encrypted,
-            type: ImportAnalyzer.analyze(checker, genericDict, importDict, type)
-        };
-    }
-}

package/src/analyses/GenericAnalyzer.ts

@@ -1,52 +0,0 @@
-import * as tsc from "typescript";
-
-export namespace GenericAnalyzer
-{
-    export type Dictionary = WeakMap<tsc.Type, tsc.Type>;
-
-    export function analyze(checker: tsc.TypeChecker, classNode: tsc.ClassDeclaration): Dictionary
-    {
-        const dict: Dictionary = new WeakMap();
-        explore(checker, dict, classNode);
-        return dict;
-    }
-
-    function explore(checker: tsc.TypeChecker, dict: Dictionary, classNode: tsc.ClassDeclaration): void
-    {
-        if (classNode.heritageClauses === undefined)
-            return;
-
-        for (const heritage of classNode.heritageClauses)
-            for (const hType of heritage.types)
-            {
-                // MUST BE CLASS
-                const expression: tsc.Type = checker.getTypeAtLocation(hType.expression);
-                const superNode: tsc.Declaration = expression.symbol.getDeclarations()![0];
-
-                if (!tsc.isClassDeclaration(superNode))
-                    continue;
-
-                // SPECIFY GENERICS
-                const usages: ReadonlyArray<tsc.TypeNode> = if_undefined_array(hType.typeArguments);                
-                const parameters: ReadonlyArray<tsc.TypeParameterDeclaration> = if_undefined_array(superNode.typeParameters);
-
-                parameters.forEach((param, index) =>
-                {
-                    const paramType: tsc.Type = checker.getTypeAtLocation(param);
-                    const usageType: tsc.Type = (usages[index] !== undefined)
-                        ? checker.getTypeAtLocation(usages[index])
-                        : checker.getTypeAtLocation(param.default!);
-
-                    dict.set(paramType, usageType);
-                });
-
-                // RECUSRIVE EXPLORATION
-                explore(checker, dict, superNode);
-            }
-    }
-
-    function if_undefined_array<T>(array: ReadonlyArray<T> | undefined): ReadonlyArray<T>
-    {
-        return array !== undefined ? array : [];
-    }
-}

package/src/analyses/ImportAnalyzer.ts

@@ -1,93 +0,0 @@
-import * as tsc from "typescript";
-
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-
-export namespace ImportAnalyzer
-{
-    export interface IOutput
-    {
-        features: [string, string[]][];
-        alias: string;
-    }
-
-    export type Dictionary = HashMap<string, HashSet<string>>;
-
-    export function analyze
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary, 
-            importDict: Dictionary, 
-            type: tsc.Type
-        ): string
-    {
-        return explore(checker, genericDict, importDict, type);
-    }
-
-    function explore
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary, 
-            importDict: Dictionary, 
-            type: tsc.Type
-        ): string
-    {
-        //----
-        // CONDITIONAL BRANCHES
-        //----
-        // DECOMPOSE GENERIC ARGUMENT
-        while (genericDict.has(type) === true)
-            type = genericDict.get(type)!;
-
-        // PRIMITIVE
-        const symbol: tsc.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
-        if (symbol === undefined)
-            return checker.typeToString(type, undefined, undefined);
-        
-        // UNION OR INTERSECT
-        else if (type.aliasSymbol === undefined && type.isUnionOrIntersection())
-        {
-            const joiner: string = type.isIntersection() ? " & " : " | ";
-            return type.types.map(child => explore(checker, genericDict, importDict, child)).join(joiner);
-        }
-
-        //----
-        // SPECIALIZATION
-        //----
-        const name: string = get_name(symbol);
-        const sourceFile: tsc.SourceFile = symbol.declarations![0].getSourceFile();
-
-        if (sourceFile.fileName.indexOf("typescript/lib") === -1)
-        {
-            let it: HashMap.Iterator<string, HashSet<string>> = importDict.find(sourceFile.fileName);
-            if (it.equals(importDict.end()) === true)
-                it = importDict.emplace(sourceFile.fileName, new HashSet()).first;
-            it.second.insert(name.split(".")[0]);
-        }
-
-        // CHECK GENERIC
-        const generic: readonly tsc.Type[] = checker.getTypeArguments(type as tsc.TypeReference);
-        if (generic.length)
-        {
-            return name === "Promise"
-                ? explore(checker, genericDict, importDict, generic[0])
-                : `${name}<${generic.map(child => explore(checker, genericDict, importDict, child)).join(", ")}>`;
-        }
-        else
-            return name;
-    }
-
-    function get_name(symbol: tsc.Symbol): string
-    {
-        let name: string = symbol.escapedName.toString();
-        let decl: tsc.Node = symbol.getDeclarations()![0].parent;
-
-        while (tsc.isModuleBlock(decl))
-        {
-            name = `${decl.parent.name.getText()}.${name}`;
-            decl = decl.parent.parent;
-        }
-        return name;
-    }
-}

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";
-    }
-}