nestia 2.0.6 → 2.0.7-dev.20220414

package/src/bin/nestia.ts

@@ -1,59 +0,0 @@
-#!/usr/bin/env ts-node
-
-import * as cp from "child_process";
-import * as path from "path";
-import * as process from "process";
-
-import { TsConfig } from "../internal/TsConfig";
-
-function install(): void
-{
-    // INSTALL DEPENDENCIES
-    for (const lib of ["nestia-fetcher", "typescript-is"])
-    {
-        const command: string = `npm install ${lib}`;
-        cp.execSync(command, { stdio: "inherit" });
-    }
-}
-
-async function sdk(): Promise<void>
-{
-    // PREPARE TSCONFIG
-    await TsConfig.fulfill();
-
-    // CONSTRUCT COMMAND
-    const parameters: string[] = [
-        `npx ts-node`,
-        `"${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, 
-                "TS_NODE_COMPILER": "ttypescript",
-                "NODE_NO_WARNINGS": "1" 
-            } 
-        }
-    );
-}
-async function main()
-{
-    if (process.argv[2] === "install")
-        await install();
-    else if (process.argv[2] === "sdk")
-        await sdk();
-    else
-        throw new Error(`nestia supports only two commands; install and sdk, however you've typed the "${process.argv[2]}"`);
-}
-main().catch(exp =>
-{
-    console.log(exp.message);
-    process.exit(-1);
-});

package/src/bundle/HttpError.ts

@@ -1 +0,0 @@
-export { HttpError } from "nestia-fetcher";

package/src/bundle/IConnection.ts

@@ -1 +0,0 @@
-export { IConnection } from "nestia-fetcher";

package/src/bundle/Primitive.ts

@@ -1 +0,0 @@
-export { Primitive } from "nestia-fetcher";

package/src/bundle/__internal/AesPkcs5.ts

@@ -1 +0,0 @@
-export { AesPkcs5 } from "nestia-fetcher";

package/src/bundle/__internal/Fetcher.ts

@@ -1 +0,0 @@
-export { Fetcher } from "nestia-fetcher";

package/src/executable/sdk.ts

@@ -1,84 +0,0 @@
-import * as cli from "cli";
-import * as fs from "fs";
-import * as path from "path";
-import * as tsc from "typescript";
-
-import { IConfiguration } from "../IConfiguration";
-import { NestiaApplication } from "../NestiaApplication";
-import { stripJsonComments } from "../utils/stripJsonComments";
-import { NestiaConfig } from "../internal/NestiaConfig";
-
-interface ICommand
-{
-    exclude: string | null;
-    out: string | null;
-}
-
-async function sdk(include: string[], command: ICommand): Promise<void>
-{
-    // CONFIGURATION
-    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.`);
-        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}`;
-    }
-}

package/src/generates/FunctionGenerator.ts

@@ -1,201 +0,0 @@
-import * as tsc from "typescript";
-import { Pair } from "tstl/utility/Pair";
-import { Vector } from "tstl/container/Vector";
-
-import { IRoute } from "../structures/IRoute";
-
-export namespace FunctionGenerator
-{
-    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, assert))
-            .filter(str => !!str)
-            .join("\n");
-    }
-
-    /* ---------------------------------------------------------
-        BODY
-    --------------------------------------------------------- */
-    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);
-        const fetchArguments: string[] = 
-        [
-            "connection",
-            `${route.name}.ENCRYPTED`,
-            `${route.name}.METHOD`,
-            `${route.name}.path(${parameters.map(p => p.name).join(", ")})`
-        ];
-        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"
-            + "    );\n"
-            + "}";
-    }
-
-    function filter_parameters(route: IRoute, query: IRoute.IParameter | undefined): IRoute.IParameter[]
-    {
-        const parameters = route.parameters.filter(param => param.category === "param");
-        if (query)
-            parameters.push(query);
-        return parameters;
-    }
-
-    /* ---------------------------------------------------------
-        HEAD & TAIL
-    --------------------------------------------------------- */
-    function head
-        (
-            route: IRoute, 
-            query: IRoute.IParameter | undefined, 
-            input: IRoute.IParameter | undefined
-        ): string
-    {
-        //----
-        // CONSTRUCT COMMENT
-        //----
-        // MAIN DESCRIPTION
-        let comment: string = route.comments.map(comment => `${comment.kind === "linkText" ? " " : ""}${comment.text}`).join("");
-        if (comment !== "")
-            comment += "\n\n";
-
-        // FILTER TAGS (VULNERABLE PARAMETERS WOULD BE REMOVED)
-        const tagList: tsc.JSDocTagInfo[] = route.tags.filter(tag => tag.text !== undefined);
-        if (tagList.length !== 0)
-        {
-            const index: number = tagList.findIndex(t => t.name === "param");
-            if (index !== -1)
-            {
-                const capsule: Vector<tsc.JSDocTagInfo> = Vector.wrap(tagList);
-                capsule.insert(capsule.nth(index), {
-                    name: "param",
-                    text: [
-                        {
-                            kind: "parameterName",
-                            text: "connection"
-                        },
-                        {
-                            kind: "space",
-                            text: " "
-                        },
-                        { 
-                            kind: "text",
-                            text: "connection Information of the remote HTTP(s) server with headers (+encryption password)" 
-                        }
-                    ]
-                });
-            }
-            comment += tagList
-                .map(tag => `@${tag.name} ${tag.text!.map(elem => elem.text).join("")}`)
-                .join("\n") + "\n\n";
-        }
-        
-        // COMPLETE THE COMMENT
-        comment += `@nestia Generated by Nestia - https://github.com/samchon/nestia\n`;
-        comment += `@controller ${route.symbol}\n`;
-        comment += `@path ${route.method} ${route.path}`;
-
-        //----
-        // FINALIZATION
-        //----
-        // REFORM PARAMETERS TEXT
-        const parameters: string[] = 
-        [
-            "connection: IConnection",
-            ...route.parameters.map(param => 
-            {
-                const type: string = (param === query || param === input)
-                    ? `Primitive<${route.name}.${param === query ? "Query" : "Input"}>`
-                    : param.type
-                return `${param.name}: ${type}`;
-            })
-        ];
-
-        // OUTPUT TYPE
-        const output: string = route.output === "void"
-            ? "void"
-            : `${route.name}.Output`;
-
-        // RETURNS WITH CONSTRUCTION
-        return ""
-            + "/**\n"
-            + comment.split("\r\n").join("\n").split("\n").map(str => ` * ${str}`).join("\n") + "\n"
-            + " */\n"
-            + `export function ${route.name}\n` 
-            + `    (\n` 
-            + `${parameters.map(str => `        ${str}`).join(",\n")}\n`
-            + `    ): Promise<${output}>`;
-    }
-
-    function tail
-        (
-            route: IRoute, 
-            query: IRoute.IParameter | undefined, 
-            input: IRoute.IParameter | undefined
-        ): string | null
-    {
-        // LIST UP TYPES
-        const types: Pair<string, string>[] = [];
-        if (query !== undefined)
-            types.push(new Pair("Query", query.type));
-        if (input !== undefined)
-            types.push(new Pair("Input", input.type));
-        if (route.output !== "void")
-            types.push(new Pair("Output", route.output));
-        
-        // PATH WITH PARAMETERS
-        const parameters = filter_parameters(route, query);
-        let path: string = route.path;
-        for (const param of parameters)
-            if (param.category === "param")
-                path = path.replace(`:${param.field}`, `\${${param.name}}`);
-        path = (query !== undefined)
-            ? `\`${path}?\${new URLSearchParams(${query.name} as any).toString()}\``
-            : `\`${path}\``;
-
-        return `export namespace ${route.name}\n`
-            + "{\n"
-            + 
-            (
-                types.length !== 0
-                    ? types.map(tuple => `    export type ${tuple.first} = Primitive<${tuple.second}>;`).join("\n") + "\n"
-                    : ""
-            )
-            + "\n"
-            + `    export const METHOD = "${route.method}" as const;\n`
-            + `    export const PATH: string = "${route.path}";\n`
-            + `    export const ENCRYPTED: Fetcher.IEncrypted = {\n`
-            + `        request: ${input !== undefined && input.encrypted},\n`
-            + `        response: ${route.encrypted},\n`
-            + `    };\n`
-            + "\n"
-            + `    export function path(${parameters.map(param => `${param.name}: ${param.type}`).join(", ")}): string\n`
-            + `    {\n`
-            + `        return ${path};\n`
-            + `    }\n`
-            + "}";
-    }
-}

package/src/generates/SdkGenerator.ts

@@ -1,39 +0,0 @@
-import * as fs from "fs";
-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
-        (
-            config: IConfiguration,
-            routeList: IRoute[],
-        ): Promise<void>
-    {
-        // PREPARE NEW DIRECTORIES
-        try { await fs.promises.mkdir(config.output); } catch {}
-
-        // BUNDLING
-        const bundle: string[] = await fs.promises.readdir(BUNDLE);
-        for (const file of bundle)
-        {
-            const current: string = `${BUNDLE}/${file}`;
-            const stats: fs.Stats = await fs.promises.stat(current);
-
-            if (stats.isFile() === true)
-            {
-                const content: string = await fs.promises.readFile(current, "utf8");
-                await fs.promises.writeFile(`${config.output}/${file}`, content, "utf8");
-            }
-        }
-        await DirectoryUtil.copy(BUNDLE + "/__internal", config.output + "/__internal");
-        
-        // FUNCTIONAL
-        await FileGenerator.generate(config, routeList);
-    }
-}
-
-const BUNDLE = __dirname + "/../bundle";

package/src/internal/NestiaConfig.ts

@@ -1,36 +0,0 @@
-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));
-    });
-}