@nestia/migrate 0.6.2 → 0.7.0-dev.20240201

package/src/executable/migrate.ts

@@ -1,59 +1,7 @@
 #!/usr/bin/env node
-import fs from "fs";
-import path from "path";
+import { MigrateCommander } from "../internal/MigrateCommander";
 
-import { MigrateApplication } from "../MigrateApplication";
-import { ISwagger } from "../structures/ISwagger";
-import { SetupWizard } from "../utils/SetupWizard";
-
-const USAGE = `Wrong command has been detected. Use like below:
-
-npx @nestia/migrate [input] [output]
-
-  ex) npx @nestia/migrate swagger.json my-new-project
-`;
-
-function halt(desc: string): never {
-  console.error(desc);
-  process.exit(-1);
-}
-
-const main = async (argv: string[]): Promise<void> => {
-  const resolve = (str: string | undefined) =>
-    str ? path.resolve(str).split("\\").join("/") : undefined;
-  const input: string | undefined = resolve(argv[0]);
-  const output: string | undefined = resolve(argv[1]);
-
-  // VALIDATE ARGUMENTS
-  if (input === undefined || output === undefined) halt(USAGE);
-
-  // VALIDATE OUTPUT DIRECTORY
-  const parent: string = resolve(output + "/..")!;
-  if (fs.existsSync(output)) halt("Output directory alreay exists.");
-  else if (fs.existsSync(parent) === false)
-    halt("Output directory's parent directory does not exist.");
-  else if (fs.statSync(parent).isDirectory() === false)
-    halt("Output directory's parent is not a directory.");
-
-  // READ SWAGGER
-  const swagger: ISwagger = (() => {
-    if (fs.existsSync(input) === false)
-      halt("Unable to find the input swagger.json file.");
-    const stats: fs.Stats = fs.statSync(input);
-    if (stats.isFile() === false) halt("The input swagger.json is not a file.");
-    const content: string = fs.readFileSync(input, "utf-8");
-    const swagger: ISwagger = JSON.parse(content);
-    return swagger;
-  })();
-
-  // DO GENERATE
-  const app: MigrateApplication = new MigrateApplication(swagger);
-  await app.generate(output);
-
-  // RUN SCRIPTS
-  SetupWizard.setup(output);
-};
-main(process.argv.slice(2)).catch((exp) => {
+MigrateCommander.main().catch((exp) => {
   console.error(exp);
   process.exit(-1);
 });

package/src/internal/MigrateCommander.ts

@@ -0,0 +1,52 @@
+import fs from "fs";
+import path from "path";
+
+import { FileArchiver } from "../archivers/FileArchiver";
+import { MigrateApplication } from "../module";
+import { IMigrateFile } from "../structures/IMigrateFile";
+import { ISwagger } from "../structures/ISwagger";
+import { MigrateInquirer } from "./MigrateInquirer";
+
+export namespace MigrateCommander {
+  export const main = async (): Promise<void> => {
+    const resolve = (str: string | undefined) =>
+      str ? path.resolve(str).split("\\").join("/") : undefined;
+    const options: MigrateInquirer.IOutput = await MigrateInquirer.parse();
+
+    // VALIDATE OUTPUT DIRECTORY
+    const parent: string = resolve(options.output + "/..")!;
+    if (fs.existsSync(options.output)) halt("Output directory alreay exists.");
+    else if (fs.existsSync(parent) === false)
+      halt("Output directory's parent directory does not exist.");
+    else if (fs.statSync(parent).isDirectory() === false)
+      halt("Output directory's parent is not a directory.");
+
+    // READ SWAGGER
+    const swagger: ISwagger = (() => {
+      if (fs.existsSync(options.input) === false)
+        halt("Unable to find the input swagger.json file.");
+      const stats: fs.Stats = fs.statSync(options.input);
+      if (stats.isFile() === false)
+        halt("The input swagger.json is not a file.");
+      const content: string = fs.readFileSync(options.input, "utf-8");
+      const swagger: ISwagger = JSON.parse(content);
+      return swagger;
+    })();
+
+    const app: MigrateApplication = new MigrateApplication(swagger);
+    const files: IMigrateFile[] =
+      options.mode === "nest"
+        ? app.nest(options.simulate)
+        : app.sdk(options.simulate);
+    await FileArchiver.archive({
+      mkdir: fs.promises.mkdir,
+      writeFile: (file, content) =>
+        fs.promises.writeFile(file, content, "utf-8"),
+    })(options.output)(files);
+  };
+
+  const halt = (desc: string): never => {
+    console.error(desc);
+    process.exit(-1);
+  };
+}

package/src/internal/MigrateInquirer.ts

@@ -0,0 +1,79 @@
+import commander from "commander";
+import inquirer from "inquirer";
+
+export namespace MigrateInquirer {
+  export interface IOutput {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+    input: string;
+    output: string;
+  }
+
+  export const parse = async (): Promise<IOutput> => {
+    // PREPARE ASSETS
+    commander.program.option("--mode [nest/sdk]", "migration mode");
+    commander.program.option(
+      "--input [swagger.json]",
+      "location of target swagger.json file",
+    );
+    commander.program.option("--output [directory]", "output directory path");
+    commander.program.option("--simulate", "Mockup simulator");
+
+    // INTERNAL PROCEDURES
+    const questioned = { value: false };
+    const action = (closure: (options: Partial<IOutput>) => Promise<IOutput>) =>
+      new Promise<IOutput>((resolve, reject) => {
+        commander.program.action(async (options) => {
+          try {
+            resolve(await closure(options));
+          } catch (exp) {
+            reject(exp);
+          }
+        });
+        commander.program.parseAsync().catch(reject);
+      });
+    const select =
+      (name: string) =>
+      (message: string) =>
+      async <Choice extends string>(
+        choices: Choice[],
+        filter?: (value: string) => Choice,
+      ): Promise<Choice> => {
+        questioned.value = true;
+        return (
+          await inquirer.createPromptModule()({
+            type: "list",
+            name: name,
+            message: message,
+            choices: choices,
+            filter,
+          })
+        )[name];
+      };
+    const input = (name: string) => async (message: string) =>
+      (
+        await inquirer.createPromptModule()({
+          type: "input",
+          name,
+          message,
+        })
+      )[name];
+
+    // DO CONSTRUCT
+    return action(async (partial) => {
+      partial.mode ??= await select("mode")("Migration mode")(
+        ["NestJS" as "nest", "SDK" as "sdk"],
+        (value) => (value === "NestJS" ? "nest" : "sdk"),
+      );
+      partial.input ??= await input("input")("Swagger file location");
+      partial.output ??= await input("output")("Output directory path");
+      if (partial.simulate)
+        partial.simulate = (partial.simulate as any) === "true";
+      else
+        partial.simulate =
+          (await select("simulate")("Mokup Simulator")(["true", "false"])) ===
+          "true";
+      return partial as IOutput;
+    });
+  };
+}

package/src/programmers/ApiFileProgrammer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { IMigrateConfig } from "../IMigrateConfig";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
@@ -20,13 +21,14 @@ export namespace ApiFileProgrammer {
   }
 
   export const write =
+    (config: IMigrateConfig) =>
     (components: ISwaggerComponents) =>
     (props: IProps): ts.Statement[] => {
       const importer: ImportProgrammer = new ImportProgrammer();
       const statements: ts.Statement[] = props.entries
         .map((p) => [
-          ApiFunctionProgrammer.write(components)(importer)(p),
-          ApiNamespaceProgrammer.write(components)(importer)(p),
+          ApiFunctionProgrammer.write(config)(components)(importer)(p),
+          ApiNamespaceProgrammer.write(config)(components)(importer)(p),
         ])
         .flat();
       return [

package/src/programmers/ApiFunctionProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
+import { IMigrateConfig } from "../IMigrateConfig";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
@@ -16,6 +17,7 @@ export namespace ApiFunctionProgrammer {
   }
 
   export const write =
+    (config: IMigrateConfig) =>
     (components: ISwaggerComponents) =>
     (importer: ImportProgrammer) =>
     (props: IProps): ts.FunctionDeclaration =>
@@ -28,30 +30,18 @@ export namespace ApiFunctionProgrammer {
           undefined,
           props.alias,
           undefined,
-          writeParameteers(components)(importer)(props),
+          writeParameterDeclarations(components)(importer)(props),
           ts.factory.createTypeReferenceNode("Promise", [
             ts.factory.createTypeReferenceNode(
               props.route.success === null ? "void" : `${props.alias}.Output`,
             ),
           ]),
-          ts.factory.createBlock(writeBody(importer)(props), true),
+          ts.factory.createBlock(writeBody(config)(importer)(props), true),
         ),
         writeDescription(props),
       );
 
-  const writeDescription = (props: IProps): string =>
-    [
-      ...(props.route.description?.length
-        ? [props.route.description.length, ""]
-        : []),
-      ...(props.route.deprecated ? ["@deprecated"] : []),
-      ...props.route.tags.map((value) => `@tag ${value}`),
-      `@controller ${props.controller.name}`,
-      `@path ${props.route.path}`,
-      "@nestia Generated by Nestia - https://github.com/samchon/nestia",
-    ].join("\n");
-
-  const writeParameteers =
+  export const writeParameterDeclarations =
     (components: ISwaggerComponents) =>
     (importer: ImportProgrammer) =>
     (props: IProps): ts.ParameterDeclaration[] => [
@@ -77,7 +67,7 @@ export namespace ApiFunctionProgrammer {
       ...(props.route.query
         ? [
             IdentifierFactory.parameter(
-              "query",
+              props.route.query.key,
               ts.factory.createTypeReferenceNode(`${props.alias}.Query`),
             ),
           ]
@@ -85,19 +75,33 @@ export namespace ApiFunctionProgrammer {
       ...(props.route.body
         ? [
             IdentifierFactory.parameter(
-              "input",
+              props.route.body.key,
               ts.factory.createTypeReferenceNode(`${props.alias}.Input`),
             ),
           ]
         : []),
     ];
 
+  const writeDescription = (props: IProps): string =>
+    [
+      ...(props.route.description?.length
+        ? [props.route.description.length, ""]
+        : []),
+      ...(props.route.deprecated ? ["@deprecated"] : []),
+      ...props.route.tags.map((value) => `@tag ${value}`),
+      `@controller ${props.controller.name}`,
+      `@path ${props.route.path}`,
+      "@nestia Generated by Nestia - https://github.com/samchon/nestia",
+    ].join("\n");
+
   const writeBody =
+    (config: IMigrateConfig) =>
     (importer: ImportProgrammer) =>
     (props: IProps): ts.Statement[] => {
       const encrypted: boolean = !!props.route.success?.["x-nestia-encrypted"];
       const contentType: string =
         props.route.success?.type ?? "application/json";
+
       const caller = () =>
         ts.factory.createCallExpression(
           IdentifierFactory.access(
@@ -157,7 +161,7 @@ export namespace ApiFunctionProgrammer {
                         ts.factory.createIdentifier(p.key),
                       ),
                       ...(props.route.query
-                        ? [ts.factory.createIdentifier("query")]
+                        ? [ts.factory.createIdentifier(props.route.query.key)]
                         : []),
                     ],
                   ),
@@ -169,9 +173,32 @@ export namespace ApiFunctionProgrammer {
               ],
               true,
             ),
-            ...(props.route.body ? [ts.factory.createIdentifier("input")] : []),
+            ...(props.route.body
+              ? [ts.factory.createIdentifier(props.route.body.key)]
+              : []),
           ],
         );
-      return [ts.factory.createReturnStatement(caller())];
+      if (config.simulate !== true)
+        return [ts.factory.createReturnStatement(caller())];
+      return [
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createIdentifier("!!connection.simulate"),
+            undefined,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(`${props.alias}.simulate`),
+              [],
+              [
+                "connection",
+                ...props.route.parameters.map((p) => p.key),
+                ...(props.route.query ? [props.route.query.key] : []),
+                ...(props.route.body ? [props.route.body.key] : []),
+              ].map((key) => ts.factory.createIdentifier(key)),
+            ),
+            undefined,
+            caller(),
+          ),
+        ),
+      ];
     };
 }

package/src/programmers/ApiNamespaceProgrammer.ts

@@ -4,10 +4,12 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
+import { IMigrateConfig } from "../IMigrateConfig";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
+import { ApiSimulatationProgrammer } from "./ApiSimulatationProgrammer";
 import { ImportProgrammer } from "./ImportProgrammer";
 import { SchemaProgrammer } from "./SchemaProgrammer";
 
@@ -19,6 +21,7 @@ export namespace ApiNamespaceProgrammer {
   }
 
   export const write =
+    (config: IMigrateConfig) =>
     (components: ISwaggerComponents) =>
     (importer: ImportProgrammer) =>
     (props: IProps): ts.ModuleDeclaration => {
@@ -32,11 +35,31 @@ export namespace ApiNamespaceProgrammer {
           writeMetadata(components)(importer)(props),
           FilePrinter.enter(),
           writePath(components)(importer)(props),
+          ...(config.simulate
+            ? [
+                ApiSimulatationProgrammer.random(components)(importer)(props),
+                ApiSimulatationProgrammer.simulate(components)(importer)(props),
+              ]
+            : []),
         ]),
         ts.NodeFlags.Namespace,
       );
     };
 
+  export const writePathCallExpression = (props: IProps) =>
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier(`${props.alias}.path`),
+      undefined,
+      [
+        ...props.route.parameters.map((p) =>
+          ts.factory.createIdentifier(p.key),
+        ),
+        ...(props.route.query
+          ? [ts.factory.createIdentifier(props.route.query.key)]
+          : []),
+      ],
+    );
+
   const writeTypes =
     (components: ISwaggerComponents) =>
     (importer: ImportProgrammer) =>
@@ -251,7 +274,7 @@ export namespace ApiNamespaceProgrammer {
                 undefined,
                 [
                   ts.factory.createAsExpression(
-                    ts.factory.createIdentifier("query"),
+                    ts.factory.createIdentifier(props.route.query.key),
                     TypeFactory.keyword("any"),
                   ),
                 ],

package/src/programmers/ApiProgrammer.ts

@@ -1,4 +1,5 @@
 import { HashMap, IPointer, hash } from "tstl";
+import ts from "typescript";
 import { Escaper } from "typia/lib/utils/Escaper";
 
 import { IMigrateProgram } from "../module";
@@ -6,6 +7,8 @@ import { IMigrateFile } from "../structures/IMigrateFile";
 import { FilePrinter } from "../utils/FilePrinter";
 import { StringUtil } from "../utils/StringUtil";
 import { ApiFileProgrammer } from "./ApiFileProgrammer";
+import { DtoProgrammer } from "./DtoProgrammer";
+import { ImportProgrammer } from "./ImportProgrammer";
 
 export namespace ApiProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] => {
@@ -44,6 +47,12 @@ export namespace ApiProgrammer {
           props.children.add(last.value.namespace.at(-1)!);
           last.value = props;
         });
+        const top = dict.take([], () => ({
+          namespace: [],
+          children: new Set(),
+          entries: [],
+        }));
+        if (namespace.length) top.children.add(namespace[0]);
       }
     for (const { second: props } of dict)
       props.entries.forEach(
@@ -57,12 +66,63 @@ export namespace ApiProgrammer {
           ])(entry.alias)),
       );
 
-    return [...dict].map(({ second: props }) => ({
-      location: `src/api/functional/${props.namespace.join("/")}`,
+    const output: IMigrateFile[] = [...dict].map(({ second: props }) => ({
+      location: `src/${program.config.mode === "nest" ? "api/" : ""}functional/${props.namespace.join("/")}`,
       file: "index.ts",
       content: FilePrinter.write({
-        statements: ApiFileProgrammer.write(program.swagger.components)(props),
+        statements: ApiFileProgrammer.write(program.config)(
+          program.swagger.components,
+        )(props),
       }),
     }));
+    if (program.config.mode === "sdk")
+      output.push(
+        ...[...DtoProgrammer.write(program.swagger.components).entries()].map(
+          ([key, value]) => ({
+            location: "src/structures",
+            file: `${key}.ts`,
+            content: FilePrinter.write({
+              statements: writeDtoFile(key, value),
+            }),
+          }),
+        ),
+      );
+    return output;
+  };
+
+  const writeDtoFile = (
+    key: string,
+    modulo: DtoProgrammer.IModule,
+  ): ts.Statement[] => {
+    const importer = new ImportProgrammer();
+    const statements: ts.Statement[] = iterate(importer)(modulo);
+    if (statements.length === 0) return [];
+
+    return [
+      ...importer.toStatements((name) => `./${name}`, key),
+      ...(importer.empty() ? [] : [FilePrinter.enter()]),
+      ...statements,
+    ];
   };
+
+  const iterate =
+    (importer: ImportProgrammer) =>
+    (modulo: DtoProgrammer.IModule): ts.Statement[] => {
+      const output: ts.Statement[] = [];
+      if (modulo.programmer !== null) output.push(modulo.programmer(importer));
+      if (modulo.children.size) {
+        const internal: ts.Statement[] = [];
+        for (const child of modulo.children.values())
+          internal.push(...iterate(importer)(child));
+        output.push(
+          ts.factory.createModuleDeclaration(
+            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            ts.factory.createIdentifier(modulo.name),
+            ts.factory.createModuleBlock(internal),
+            ts.NodeFlags.Namespace,
+          ),
+        );
+      }
+      return output;
+    };
 }