@nestia/sdk 1.1.1 → 1.2.0-dev.20230504

package/src/executable/internal/NestiaSdkCommand.ts

@@ -11,99 +11,83 @@ import { NestiaSdkConfig } from "./NestiaSdkConfig";
 interface ICommand {
     exclude: string | null;
     out: string | null;
+    e2e: string | null;
 }
 
-interface IOutput {
+interface IProps {
     assign: (config: INestiaConfig, output: string) => void;
     validate: (config: INestiaConfig) => boolean;
     location: (config: INestiaConfig) => string;
 }
 
 export namespace NestiaSdkCommand {
-    export function sdk(
-        elements: string[],
-        pure: boolean = true,
-    ): Promise<void> {
-        return main(
-            (app) => app.sdk(),
-            {
-                assign: (config, output) => (config.output = output),
-                validate: (config) => !!config.output,
-                location: (config) => config.output!,
+    export const sdk = (argv: string[]) =>
+        main({
+            assign: (config, output) => (config.output = output),
+            validate: (config) => !!config.output,
+            location: (config) => config.output!,
+        })(argv)((app) => app.sdk());
+
+    export const swagger = (argv: string[]) =>
+        main({
+            assign: (config, output) => {
+                if (!config.swagger) config.swagger = { output };
+                else config.swagger.output = output;
             },
-            elements,
-            pure,
-        );
-    }
-
-    export function swagger(
-        elements: string[],
-        pure: boolean = true,
-    ): Promise<void> {
-        return main(
-            (app) => app.swagger(),
-            {
-                assign: (config, output) => {
-                    if (!config.swagger) config.swagger = { output };
-                    else config.swagger.output = output;
-                },
-                validate: (config) =>
-                    !!config.swagger && !!config.swagger.output,
-                location: (config) => config.swagger!.output!,
-            },
-            elements,
-            pure,
-        );
-    }
-
-    async function main(
-        task: (app: NestiaSdkApplication) => Promise<void>,
-        output: IOutput,
-        elements: string[],
-        pure: boolean,
-    ): Promise<void> {
-        if (pure === false)
-            cli.setArgv([
-                process.argv[0],
-                process.argv[1],
-                "nestia",
-                ...elements,
-            ]);
-        const command: ICommand = cli.parse({
-            exclude: ["e", "Something to exclude", "string", null],
-            out: ["o", "Output path of the SDK files", "string", null],
-        });
-
-        const inputs: string[] = [];
-        for (const arg of elements) {
-            if (arg[0] === "-") break;
-            inputs.push(arg);
-        }
-        await generate(task, inputs, command, output);
-    }
-
-    async function generate(
-        task: (app: NestiaSdkApplication) => Promise<void>,
-        include: string[],
-        command: ICommand,
-        output: IOutput,
-    ): Promise<void> {
-        // CONFIGURATION
-        const config: INestiaConfig =
-            (await get_nestia_config(output.validate)) ??
-            parse_cli(include, command, output);
-
-        const options = await get_typescript_options();
-
-        config.compilerOptions = {
-            ...options,
-            ...(config.compilerOptions || {}),
+            validate: (config) => !!config.swagger && !!config.swagger.output,
+            location: (config) => config.swagger!.output!,
+        })(argv)((app) => app.swagger());
+
+    export const e2e = (argv: string[]) =>
+        main({
+            assign: (config, output) => (config.output = output),
+            validate: (config) => !!config.output,
+            location: (config) => config.output!,
+        })(argv)((app) => app.sdk());
+
+    const main =
+        (props: IProps) =>
+        (argv: string[]) =>
+        async (task: (app: NestiaSdkApplication) => Promise<void>) => {
+            const command: ICommand = cli.parse({
+                exclude: ["e", "Something to exclude", "string", null],
+                out: ["o", "Output path of the SDK files", "string", null],
+                e2e: [
+                    "e",
+                    "Output path of e2e test function files",
+                    "string",
+                    null,
+                ],
+            });
+
+            const inputs: string[] = [];
+            for (const r of argv) {
+                if (r[0] === "-") break;
+                inputs.push(r);
+            }
+            await generate(props)(command)(inputs)(task);
         };
 
-        // CALL THE APP.GENERATE()
-        const app: NestiaSdkApplication = new NestiaSdkApplication(config);
-        await task(app);
-    }
+    const generate =
+        (props: IProps) =>
+        (command: ICommand) =>
+        (include: string[]) =>
+        async (task: (app: NestiaSdkApplication) => Promise<void>) => {
+            // CONFIGURATION
+            const config: INestiaConfig =
+                (await get_nestia_config(props.validate)) ??
+                parse_cli(props)(command)(include);
+
+            const options = await get_typescript_options();
+            config.compilerOptions = {
+                ...options,
+                ...(config.compilerOptions || {}),
+            };
+
+            // CALL THE APP.GENERATE()
+            const app: NestiaSdkApplication = new NestiaSdkApplication(config);
+            await task(app);
+        };
 
     async function get_typescript_options(): Promise<ts.CompilerOptions | null> {
         const configFileName = ts.findConfigFile(
@@ -111,18 +95,14 @@ export namespace NestiaSdkCommand {
             ts.sys.fileExists,
             "tsconfig.json",
         );
-
         if (!configFileName) return null;
 
         const { tsconfig } = await parseNative(configFileName);
-
         const configFileText = JSON.stringify(tsconfig);
-
         const { config } = ts.parseConfigFileTextToJson(
             configFileName,
             configFileText,
         );
-
         const configParseResult = ts.parseJsonConfigFileContent(
             config,
             ts.sys,
@@ -138,7 +118,9 @@ export namespace NestiaSdkCommand {
         validate: (config: INestiaConfig) => boolean,
     ): Promise<INestiaConfig | null> {
         const connector = new WorkerConnector(null, null, "process");
-        await connector.connect(`${__dirname}/nestia.config.getter.${__filename.substr(-2)}`);
+        await connector.connect(
+            `${__dirname}/nestia.config.getter.${__filename.substr(-2)}`,
+        );
 
         const driver = await connector.getDriver<typeof NestiaSdkConfig>();
         const config: INestiaConfig | null = await driver.get();
@@ -152,23 +134,23 @@ export namespace NestiaSdkCommand {
         return config;
     }
 
-    function parse_cli(
-        include: string[],
-        command: ICommand,
-        output: IOutput,
-    ): INestiaConfig {
-        if (command.out === null)
-            throw new Error(
-                `Error on NestiaCommand.main(): output directory is not specified. Add the "--out <output_directory>" option.`,
-            );
-
-        const config: INestiaConfig = {
-            input: {
-                include,
-                exclude: command.exclude ? [command.exclude] : undefined,
-            },
+    const parse_cli =
+        (props: IProps) =>
+        (command: ICommand) =>
+        (include: string[]): INestiaConfig => {
+            if (command.out === null)
+                throw new Error(
+                    `Error on NestiaCommand.main(): output directory is not specified. Add the "--out <output_directory>" option.`,
+                );
+
+            const config: INestiaConfig = {
+                input: {
+                    include,
+                    exclude: command.exclude ? [command.exclude] : undefined,
+                },
+                e2e: command.e2e ?? undefined,
+            };
+            props.assign(config, command.out);
+            return config;
         };
-        output.assign(config, command.out);
-        return config;
-    }
 }

package/src/executable/sdk.ts

@@ -14,14 +14,9 @@ npx @nestia/sdk [command] [options?]
     - npx @nestia/sdk dependencies
     - npx @nestia/sdk dependencies --manager pnpm
   2. npx @nestia/sdk init
-  3. npx @nestia/sdk sdk <input> --out <output>
-    - npx @nestia/sdk sdk # when "nestia.config.ts" be configured
-    - npx @nestia/sdk sdk src/controllers --out src/api
-    - npx @nestia/sdk sdk src/**/*.controller.ts --out src/api
-  4. npx @nestia/sdk swagger <input> --out <output>
-    - npx @nestia/sdk swagger # when "nestia.config.ts" be configured
-    - npx @nestia/sdk swagger src/controllers --out src/api
-    - npx @nestia/sdk swagger src/**/*.controller.ts --out src/api       
+  3. npx @nestia/sdk sdk
+  4. npx @nestia/sdk swagger
+  5. npx @nestia/sdk e2e
 `;
 
 function halt(desc: string): never {
@@ -66,6 +61,7 @@ async function main() {
     else if (type === "init") await initialize();
     else if (type === "sdk") await execute((c) => c.sdk(argv));
     else if (type === "swagger") await execute((c) => c.swagger(argv));
+    else if (type === "e2e") await execute((c) => c.e2e(argv));
     else halt(USAGE);
 }
 main().catch((exp) => {

package/src/generates/E2eGenerator.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { IRoute } from "../structures/IRoute";
+import { NestiaConfigUtil } from "../utils/NestiaConfigUtil";
+import { E2eFileProgrammer } from "./internal/E2eFileProgrammer";
+
+export namespace E2eGenerator {
+    export const generate =
+        (config: INestiaConfig) =>
+        async (routeList: IRoute[]): Promise<void> => {
+            // PREPARE DIRECTORIES
+            const output: string = path.resolve(config.e2e!);
+            await mkdir(output);
+            await mkdir(path.join(output, "features"));
+            await mkdir(path.join(output, "features", "api"));
+            await mkdir(path.join(output, "features", "api", "automated"));
+
+            // GENERATE TEST INDEX FILE
+            await index(config)(path.join(config.e2e!, "index.ts"));
+
+            // GENERATE EACH TEST FILES
+            for (const route of routeList)
+                await E2eFileProgrammer.generate(config)({
+                    api: path.resolve(config.output!),
+                    current: path.join(output, "features", "api", "automated"),
+                })(route);
+        };
+
+    const index =
+        (config: INestiaConfig) =>
+        async (output: string): Promise<void> => {
+            if (fs.existsSync(output)) return;
+
+            const location: string = path.join(
+                __dirname,
+                "..",
+                "..",
+                "assets",
+                "bundle",
+                "e2e",
+                "index.ts",
+            );
+            const content: string = await fs.promises.readFile(
+                location,
+                "utf8",
+            );
+
+            await fs.promises.writeFile(
+                output,
+                content.replace(
+                    "${input}",
+                    JSON.stringify(NestiaConfigUtil.input(config.input)),
+                ),
+                "utf8",
+            );
+        };
+}
+
+const mkdir = async (location: string): Promise<void> => {
+    try {
+        await fs.promises.mkdir(location);
+    } catch {}
+};

package/src/generates/SdkGenerator.ts

@@ -1,44 +1,42 @@
 import fs from "fs";
 import NodePath from "path";
-import ts from "typescript";
 
 import { INestiaConfig } from "../INestiaConfig";
 import { IRoute } from "../structures/IRoute";
-import { FileGenerator } from "./FileGenerator";
+import { SdkFileProgrammer } from "./internal/SdkFileProgrammer";
 
 export namespace SdkGenerator {
-    export async function generate(
-        _checker: ts.TypeChecker,
-        config: INestiaConfig,
-        routeList: IRoute[],
-    ): Promise<void> {
-        // PREPARE NEW DIRECTORIES
-        try {
-            await fs.promises.mkdir(config.output!);
-        } catch {}
+    export const generate =
+        (config: INestiaConfig) =>
+        async (routes: IRoute[]): Promise<void> => {
+            // PREPARE NEW DIRECTORIES
+            try {
+                await fs.promises.mkdir(config.output!);
+            } catch {}
 
-        // BUNDLING
-        const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
-        for (const file of bundle) {
-            const current: string = `${BUNDLE_PATH}/${file}`;
-            const stats: fs.Stats = await fs.promises.stat(current);
+            // BUNDLING
+            const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
+            for (const file of bundle) {
+                const current: string = `${BUNDLE_PATH}/${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",
-                );
+                if (stats.isFile() === true) {
+                    const content: string = await fs.promises.readFile(
+                        current,
+                        "utf8",
+                    );
+                    if (fs.existsSync(`${config.output}/${file}`) === false)
+                        await fs.promises.writeFile(
+                            `${config.output}/${file}`,
+                            content,
+                            "utf8",
+                        );
+                }
             }
-        }
 
-        // FUNCTIONAL
-        await FileGenerator.generate(config, routeList);
-    }
+            // FUNCTIONAL
+            await SdkFileProgrammer.generate(config)(routes);
+        };
 
     export const BUNDLE_PATH = NodePath.join(
         __dirname,
@@ -46,5 +44,6 @@ export namespace SdkGenerator {
         "..",
         "assets",
         "bundle",
+        "api",
     );
 }

package/src/generates/SwaggerGenerator.ts

@@ -17,72 +17,74 @@ import { ISwaggerDocument } from "../structures/ISwaggerDocument";
 import { MapUtil } from "../utils/MapUtil";
 
 export namespace SwaggerGenerator {
-    export async function generate(
-        checker: ts.TypeChecker,
-        config: INestiaConfig.ISwaggerConfig,
-        routeList: IRoute[],
-    ): Promise<void> {
-        // PREPARE ASSETS
-        const parsed: NodePath.ParsedPath = NodePath.parse(config.output);
-        const location: string = !!parsed.ext
-            ? NodePath.resolve(config.output)
-            : NodePath.join(NodePath.resolve(config.output), "swagger.json");
-
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
-
-        // CONSTRUCT SWAGGER DOCUMENTS
-        const tupleList: Array<ISchemaTuple> = [];
-        const swagger: ISwaggerDocument = await initialize(location);
-        const pathDict: Map<string, ISwaggerDocument.IPath> = new Map();
-
-        for (const route of routeList) {
-            if (route.tags.find((tag) => tag.name === "internal")) continue;
-
-            const path: ISwaggerDocument.IPath = MapUtil.take(
-                pathDict,
-                get_path(route.path, route.parameters),
-                () => ({}),
-            );
-            path[route.method.toLowerCase()] = generate_route(
-                checker,
-                collection,
-                tupleList,
-                route,
+    export const generate =
+        (checker: ts.TypeChecker) =>
+        (config: INestiaConfig.ISwaggerConfig) =>
+        async (routeList: IRoute[]): Promise<void> => {
+            // PREPARE ASSETS
+            const parsed: NodePath.ParsedPath = NodePath.parse(config.output);
+            const location: string = !!parsed.ext
+                ? NodePath.resolve(config.output)
+                : NodePath.join(
+                      NodePath.resolve(config.output),
+                      "swagger.json",
+                  );
+
+            const collection: MetadataCollection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+
+            // CONSTRUCT SWAGGER DOCUMENTS
+            const tupleList: Array<ISchemaTuple> = [];
+            const swagger: ISwaggerDocument = await initialize(location);
+            const pathDict: Map<string, ISwaggerDocument.IPath> = new Map();
+
+            for (const route of routeList) {
+                if (route.tags.find((tag) => tag.name === "internal")) continue;
+
+                const path: ISwaggerDocument.IPath = MapUtil.take(
+                    pathDict,
+                    get_path(route.path, route.parameters),
+                    () => ({}),
+                );
+                path[route.method.toLowerCase()] = generate_route(
+                    checker,
+                    collection,
+                    tupleList,
+                    route,
+                );
+            }
+            swagger.paths = {};
+            for (const [path, routes] of pathDict) {
+                swagger.paths[path] = routes;
+            }
+
+            // FILL JSON-SCHEMAS
+            const application: IJsonApplication = ApplicationProgrammer.write({
+                purpose: "swagger",
+            })(tupleList.map(({ metadata }) => metadata));
+            swagger.components = {
+                ...(swagger.components ?? {}),
+                schemas: application.components.schemas,
+            };
+            tupleList.forEach(({ schema }, index) => {
+                Object.assign(schema, application.schemas[index]!);
+            });
+
+            // CONFIGURE SECURITY
+            if (config.security) fill_security(config.security, swagger);
+
+            // ERASE IJsonComponents.IObject.$id
+            for (const obj of Object.values(swagger.components.schemas))
+                if (obj.$id) delete obj.$id;
+
+            // DO GENERATE
+            await fs.promises.writeFile(
+                location,
+                JSON.stringify(swagger, null, 2),
+                "utf8",
             );
-        }
-        swagger.paths = {};
-        for (const [path, routes] of pathDict) {
-            swagger.paths[path] = routes;
-        }
-
-        // FILL JSON-SCHEMAS
-        const application: IJsonApplication = ApplicationProgrammer.write({
-            purpose: "swagger",
-        })(tupleList.map(({ metadata }) => metadata));
-        swagger.components = {
-            ...(swagger.components ?? {}),
-            schemas: application.components.schemas,
         };
-        tupleList.forEach(({ schema }, index) => {
-            Object.assign(schema, application.schemas[index]!);
-        });
-
-        // CONFIGURE SECURITY
-        if (config.security) fill_security(config.security, swagger);
-
-        // ERASE IJsonComponents.IObject.$id
-        for (const obj of Object.values(swagger.components.schemas))
-            if (obj.$id) delete obj.$id;
-
-        // DO GENERATE
-        await fs.promises.writeFile(
-            location,
-            JSON.stringify(swagger, null, 2),
-            "utf8",
-        );
-    }
 
     /* ---------------------------------------------------------
         INITIALIZERS

package/src/generates/internal/E2eFileProgrammer.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+
+export namespace E2eFileProgrammer {
+    export const generate =
+        (config: INestiaConfig) =>
+        (props: { api: string; current: string }) =>
+        async (route: IRoute): Promise<void> => {
+            const importDict: ImportDictionary = new ImportDictionary();
+            for (const tuple of route.imports)
+                for (const instance of tuple[1])
+                    importDict.emplace(tuple[0], false, instance);
+
+            const uuid: boolean = route.parameters.some(
+                (p) => p.category === "param" && p.meta?.type === "uuid",
+            );
+            const content: string = [
+                config.primitive === false
+                    ? `import typia from "typia";`
+                    : `import typia, { Primitive } from "typia";`,
+                "",
+                `import api from "./${path
+                    .relative(props.current, props.api)
+                    .split("\\")
+                    .join("/")}";`,
+                ...(importDict.empty()
+                    ? []
+                    : [importDict.toScript(props.current)]),
+                "",
+                arrow(config)(route),
+                ...(uuid ? ["", UUID] : []),
+            ].join("\n");
+
+            await fs.promises.writeFile(
+                `${props.current}/${name(route)}.ts`,
+                content,
+                "utf8",
+            );
+        };
+
+    const arrow =
+        (config: INestiaConfig) =>
+        (route: IRoute): string => {
+            const tab: number = route.output.name === "void" ? 2 : 3;
+            const output = [
+                `await ${accessor(route)}(`,
+                `${" ".repeat(tab * 4)}connection,`,
+                ...route.parameters.map(parameter(config)(tab)),
+                `${" ".repeat((tab - 1) * 4)});`,
+            ].join("\n");
+            return [
+                `export const ${name(route)} = async (`,
+                `    connection: api.IConnection`,
+                `): Promise<void> => {`,
+                ...(route.output.name === "void"
+                    ? [`    ${output}`]
+                    : [
+                          `    const output: ${primitive(config)(
+                              route.output.name,
+                          )} = `,
+                          `        ${output}`,
+                          `    typia.assert(output);`,
+                      ]),
+                `};`,
+            ].join("\n");
+        };
+
+    const parameter =
+        (config: INestiaConfig) =>
+        (tab: number) =>
+        (param: IRoute.IParameter): string => {
+            const middle: string =
+                param.category === "param" && param.meta?.type === "uuid"
+                    ? param.meta.nullable
+                        ? `Math.random() < .2 ? null : uuid()`
+                        : `uuid()`
+                    : `typia.random<${primitive(config)(param.type.name)}>()`;
+            return `${" ".repeat(4 * tab)}${middle},`;
+        };
+
+    const name = (route: IRoute): string =>
+        [
+            "test_api",
+            ...route.path
+                .split("/")
+                .filter((str) => str.length && str[0] !== ":")
+                .map(normalize),
+            route.name,
+        ].join("_");
+
+    const accessor = (route: IRoute): string =>
+        [
+            "api.functional",
+            ...route.path
+                .split("/")
+                .filter((str) => str.length && str[0] !== ":")
+                .map(normalize),
+            route.name,
+        ].join(".");
+
+    const normalize = (str: string) =>
+        str.split("-").join("_").split(".").join("_");
+
+    const primitive =
+        (config: INestiaConfig) =>
+        (name: string): string =>
+            config.primitive !== false ? `Primitive<${name}>` : name;
+}
+
+const UUID = `const uuid = (): string =>
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });`;