@nestia/migrate 0.6.1 → 0.6.3

package/src/programmers/ApiSimulatationProgrammer.ts

@@ -0,0 +1,328 @@
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+
+import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { ApiFunctionProgrammer } from "./ApiFunctionProgrammer";
+import { ApiNamespaceProgrammer } from "./ApiNamespaceProgrammer";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { SchemaProgrammer } from "./SchemaProgrammer";
+
+export namespace ApiSimulatationProgrammer {
+  export interface IProps {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+    alias: string;
+  }
+  export const random =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps) =>
+      constant("random")(
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [
+            ts.factory.createParameterDeclaration(
+              undefined,
+              undefined,
+              "g",
+              ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createIdentifier("Partial"),
+                [
+                  ts.factory.createTypeReferenceNode(
+                    `${importer.external({
+                      type: "default",
+                      library: "typia",
+                      name: "typia",
+                    })}.IRandomGenerator`,
+                  ),
+                ],
+              ),
+            ),
+          ],
+          undefined,
+          undefined,
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createIdentifier(
+                importer.external({
+                  type: "default",
+                  library: "typia",
+                  name: "typia",
+                }),
+              ),
+            )("random"),
+            [
+              props.route.success
+                ? SchemaProgrammer.write(components)(importer)(
+                    props.route.success.schema,
+                  )
+                : TypeFactory.keyword("void"),
+            ],
+            [ts.factory.createIdentifier("g")],
+          ),
+        ),
+      );
+
+  export const simulate =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.VariableStatement => {
+      const caller = () =>
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("random"),
+          undefined,
+          [
+            ts.factory.createConditionalExpression(
+              ts.factory.createLogicalAnd(
+                ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral("object"),
+                  ts.factory.createTypeOfExpression(
+                    ts.factory.createIdentifier("connection.simulate"),
+                  ),
+                ),
+                ts.factory.createStrictInequality(
+                  ts.factory.createNull(),
+                  ts.factory.createIdentifier("connection.simulate"),
+                ),
+              ),
+              undefined,
+              ts.factory.createIdentifier("connection.simulate"),
+              undefined,
+              ts.factory.createIdentifier("undefined"),
+            ),
+          ],
+        );
+      assert;
+      return constant("simulate")(
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          ApiFunctionProgrammer.writeParameterDeclarations(components)(
+            importer,
+          )(props),
+          ts.factory.createTypeReferenceNode(
+            props.route.success ? "Output" : "void",
+          ),
+          undefined,
+          ts.factory.createBlock(
+            [
+              ...assert(components)(importer)(props),
+              ts.factory.createReturnStatement(caller()),
+            ],
+            true,
+          ),
+        ),
+      );
+    };
+
+  const assert =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.Statement[] => {
+      const parameters = [
+        ...props.route.parameters.map((p) => ({
+          category: "param",
+          name: p.key,
+          schema: SchemaProgrammer.write(components)(importer)(p.schema),
+        })),
+        ...(props.route.query
+          ? [
+              {
+                category: "query",
+                name: props.route.query.key,
+                schema: SchemaProgrammer.write(components)(importer)(
+                  props.route.query.schema,
+                ),
+              },
+            ]
+          : []),
+        ...(props.route.body
+          ? [
+              {
+                category: "body",
+                name: props.route.body.key,
+                schema: SchemaProgrammer.write(components)(importer)(
+                  props.route.body.schema,
+                ),
+              },
+            ]
+          : []),
+      ];
+      if (parameters.length === 0) return [];
+
+      const validator = StatementFactory.constant(
+        "assert",
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createIdentifier(
+              importer.external({
+                type: "instance",
+                library: `@nestia/fetcher/lib/NestiaSimulator`,
+                name: "NestiaSimulator",
+              }),
+            ),
+          )("assert"),
+          undefined,
+          [
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createPropertyAssignment(
+                  "method",
+                  ts.factory.createIdentifier("METADATA.method"),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "host",
+                  ts.factory.createIdentifier("connection.host"),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "path",
+                  ApiNamespaceProgrammer.writePathCallExpression(props),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "contentType",
+                  ts.factory.createStringLiteral(
+                    props.route.success?.type ?? "application/json",
+                  ),
+                ),
+              ],
+              true,
+            ),
+          ],
+        ),
+      );
+      const individual = parameters
+        .map((p) =>
+          ts.factory.createCallExpression(
+            (() => {
+              const base = IdentifierFactory.access(
+                ts.factory.createIdentifier("assert"),
+              )(p.category);
+              if (p.category !== "param") return base;
+              return ts.factory.createCallExpression(base, undefined, [
+                ts.factory.createStringLiteral(p.name),
+              ]);
+            })(),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(
+                    ts.factory.createIdentifier(
+                      importer.external({
+                        type: "default",
+                        library: "typia",
+                        name: "typia",
+                      }),
+                    ),
+                  )("assert"),
+                  undefined,
+                  [
+                    ts.factory.createIdentifier(
+                      p.category === "headers" ? "connection.headers" : p.name,
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        )
+        .map(ts.factory.createExpressionStatement);
+      return [validator, tryAndCatch(importer)(individual)];
+    };
+
+  const tryAndCatch =
+    (importer: ImportProgrammer) => (individual: ts.Statement[]) =>
+      ts.factory.createTryStatement(
+        ts.factory.createBlock(individual, true),
+        ts.factory.createCatchClause(
+          "exp",
+          ts.factory.createBlock(
+            [
+              ts.factory.createIfStatement(
+                ts.factory.createLogicalNot(
+                  ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                      ts.factory.createIdentifier(
+                        importer.external({
+                          type: "default",
+                          library: "typia",
+                          name: "typia",
+                        }),
+                      ),
+                    )("is"),
+                    [
+                      ts.factory.createTypeReferenceNode(
+                        importer.external({
+                          type: "instance",
+                          library: "@nestia/Fetcher",
+                          name: "HttpError",
+                        }),
+                      ),
+                    ],
+                    [ts.factory.createIdentifier("exp")],
+                  ),
+                ),
+                ts.factory.createThrowStatement(
+                  ts.factory.createIdentifier("exp"),
+                ),
+              ),
+              ts.factory.createReturnStatement(
+                ts.factory.createAsExpression(
+                  ts.factory.createObjectLiteralExpression(
+                    [
+                      ts.factory.createPropertyAssignment(
+                        "success",
+                        ts.factory.createFalse(),
+                      ),
+                      ts.factory.createPropertyAssignment(
+                        "status",
+                        ts.factory.createIdentifier("exp.status"),
+                      ),
+                      ts.factory.createPropertyAssignment(
+                        "headers",
+                        ts.factory.createIdentifier("exp.headers"),
+                      ),
+                      ts.factory.createPropertyAssignment(
+                        "data",
+                        ts.factory.createIdentifier("exp.toJSON().message"),
+                      ),
+                    ],
+                    true,
+                  ),
+                  TypeFactory.keyword("any"),
+                ),
+              ),
+            ],
+            true,
+          ),
+        ),
+        undefined,
+      );
+}
+
+const constant = (name: string) => (expression: ts.Expression) =>
+  ts.factory.createVariableStatement(
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    ts.factory.createVariableDeclarationList(
+      [
+        ts.factory.createVariableDeclaration(
+          ts.factory.createIdentifier(name),
+          undefined,
+          undefined,
+          expression,
+        ),
+      ],
+      ts.NodeFlags.Const,
+    ),
+  );

package/src/programmers/DtoProgrammer.ts

@@ -23,7 +23,7 @@ export namespace DtoProgrammer {
     const dict: Map<string, IModule> = new Map();
     for (const [key, value] of Object.entries(components.schemas ?? {}))
       prepare(dict)(key)((importer) =>
-        writeAlias(importer)(components)(key, value),
+        writeAlias(components)(importer)(key, value),
       );
     return dict;
   };
@@ -48,15 +48,15 @@ export namespace DtoProgrammer {
     };
 
   const writeAlias =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (key: string, value: ISwaggerSchema) =>
       FilePrinter.description(
         ts.factory.createTypeAliasDeclaration(
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           key.split(".").at(-1)!,
           [],
-          SchemaProgrammer.write(importer)(components)(value),
+          SchemaProgrammer.write(components)(importer)(value),
         ),
         writeComment(value),
       );

package/src/programmers/ImportProgrammer.ts

@@ -5,7 +5,13 @@ import { FilePrinter } from "../utils/FilePrinter";
 import { MapUtil } from "../utils/MapUtil";
 
 export class ImportProgrammer {
-  private external_: Map<string, Set<string>> = new Map();
+  private external_: Map<
+    string,
+    {
+      default: string | null;
+      instances: Set<string>;
+    }
+  > = new Map();
   private dtos_: Set<string> = new Set();
 
   public constructor() {}
@@ -15,10 +21,14 @@ export class ImportProgrammer {
   }
 
   public external(props: ImportProgrammer.IProps): string {
-    MapUtil.take(this.external_)(props.library)(() => new Set()).add(
-      props.instance.split(".")[0],
-    );
-    return props.instance;
+    const element = MapUtil.take(this.external_)(props.library)(() => ({
+      default: null,
+      instances: new Set(),
+    }));
+    const name: string = props.name.split(".")[0];
+    if (props.type === "default") element.default = props.name;
+    else element.instances.add(name);
+    return name;
   }
 
   public dto(name: string): ts.TypeReferenceNode {
@@ -29,8 +39,9 @@ export class ImportProgrammer {
 
   public tag(type: string, arg: number | string): ts.TypeReferenceNode {
     this.external({
+      type: "instance",
       library: "typia",
-      instance: "tags",
+      name: "tags",
     });
     return ts.factory.createTypeReferenceNode(`tags.${type}`, [
       ts.factory.createLiteralTypeNode(
@@ -46,25 +57,29 @@ export class ImportProgrammer {
     current?: string,
   ): ts.Statement[] {
     return [
-      ...[...this.external_.entries()].map(([library, properties]) =>
-        ts.factory.createImportDeclaration(
+      ...[...this.external_.entries()].map(([library, props]) => {
+        return ts.factory.createImportDeclaration(
           undefined,
           ts.factory.createImportClause(
             false,
-            undefined,
-            ts.factory.createNamedImports(
-              [...properties].map((i) =>
-                ts.factory.createImportSpecifier(
-                  false,
-                  undefined,
-                  ts.factory.createIdentifier(i),
-                ),
-              ),
-            ),
+            props.default !== null
+              ? ts.factory.createIdentifier(props.default)
+              : undefined,
+            props.instances.size
+              ? ts.factory.createNamedImports(
+                  [...props.instances].map((i) =>
+                    ts.factory.createImportSpecifier(
+                      false,
+                      undefined,
+                      ts.factory.createIdentifier(i),
+                    ),
+                  ),
+                )
+              : undefined,
           ),
           ts.factory.createStringLiteral(library),
-        ),
-      ),
+        );
+      }),
       ...(this.external_.size && this.dtos_.size ? [FilePrinter.enter()] : []),
       ...[...this.dtos_]
         .filter(
@@ -92,7 +107,8 @@ export class ImportProgrammer {
 }
 export namespace ImportProgrammer {
   export interface IProps {
+    type: "default" | "instance";
     library: string;
-    instance: string;
+    name: string;
   }
 }

package/src/programmers/NestControllerProgrammer.ts

@@ -18,8 +18,9 @@ export namespace NestControllerProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier(
                 importer.external({
+                  type: "instance",
                   library: "@nestjs/common",
-                  instance: "Controller",
+                  name: "Controller",
                 }),
               ),
               [],

package/src/programmers/NestMethodProgrammer.ts

@@ -17,7 +17,7 @@ export namespace NestMethodProgrammer {
     (importer: ImportProgrammer) =>
     (route: IMigrateRoute): ts.MethodDeclaration => {
       const output: ts.TypeNode = route.success
-        ? SchemaProgrammer.write(importer)(components)(route.success.schema)
+        ? SchemaProgrammer.write(components)(importer)(route.success.schema)
         : TypeFactory.keyword("void");
 
       const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
@@ -30,7 +30,7 @@ export namespace NestMethodProgrammer {
         route.name,
         undefined,
         undefined,
-        writeParameters(importer)(components)(route),
+        writeParameters(components)(importer)(route),
         ts.factory.createTypeReferenceNode("Promise", [output]),
         ts.factory.createBlock(
           [
@@ -46,12 +46,15 @@ export namespace NestMethodProgrammer {
             ),
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                  importer.external({
-                    library: "typia",
-                    instance: "random",
-                  }),
-                ),
+                IdentifierFactory.access(
+                  ts.factory.createIdentifier(
+                    importer.external({
+                      type: "default",
+                      library: "typia",
+                      name: "typia",
+                    }),
+                  ),
+                )("random"),
                 [output],
                 undefined,
               ),
@@ -60,9 +63,17 @@ export namespace NestMethodProgrammer {
           true,
         ),
       );
-      return FilePrinter.description(method, route.description ?? "");
+      return FilePrinter.description(method, writeDescription(route));
     };
 
+  const writeDescription = (method: IMigrateRoute): string =>
+    [
+      ...(method.description?.length ? [method.description.length, ""] : []),
+      ...(method.deprecated ? ["@deprecated"] : []),
+      ...method.tags.map((value) => `@tag ${value}`),
+      "@nestia Generated by Nestia - https://github.com/samchon/nestia",
+    ].join("\n");
+
   const writeMethodDecorators =
     (components: ISwaggerComponents) =>
     (importer: ImportProgrammer) =>
@@ -71,7 +82,11 @@ export namespace NestMethodProgrammer {
         (lib: string) =>
         (instance: string): ts.Identifier =>
           ts.factory.createIdentifier(
-            importer.external({ library: lib, instance }),
+            importer.external({
+              type: "instance",
+              library: lib,
+              name: instance,
+            }),
           );
       const router = (instance: string) =>
         ts.factory.createDecorator(
@@ -116,7 +131,7 @@ export namespace NestMethodProgrammer {
           ts.factory.createDecorator(
             ts.factory.createCallExpression(
               external("@nestia/core")("TypedException"),
-              [SchemaProgrammer.write(importer)(components)(value.schema)],
+              [SchemaProgrammer.write(components)(importer)(value.schema)],
               [
                 isNaN(Number(key))
                   ? ts.factory.createStringLiteral(key)
@@ -132,8 +147,8 @@ export namespace NestMethodProgrammer {
     };
 
   const writeParameters =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (route: IMigrateRoute): ts.ParameterDeclaration[] => [
       ...route.parameters.map(({ key, schema: value }) =>
         ts.factory.createParameterDeclaration(
@@ -142,8 +157,9 @@ export namespace NestMethodProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier(
                   importer.external({
+                    type: "instance",
                     library: "@nestia/core",
-                    instance: "TypedParam",
+                    name: "TypedParam",
                   }),
                 ),
                 undefined,
@@ -154,21 +170,21 @@ export namespace NestMethodProgrammer {
           undefined,
           StringUtil.normalize(key),
           undefined,
-          SchemaProgrammer.write(importer)(components)(value),
+          SchemaProgrammer.write(components)(importer)(value),
         ),
       ),
       ...(route.headers
         ? [
             writeDtoParameter({ method: "TypedHeaders", variable: "headers" })(
-              importer,
-            )(components)(route.headers),
+              components,
+            )(importer)(route.headers.schema),
           ]
         : []),
       ...(route.query
         ? [
             writeDtoParameter({ method: "TypedQuery", variable: "query" })(
-              importer,
-            )(components)(route.query),
+              components,
+            )(importer)(route.query.schema),
           ]
         : []),
       ...(route.body
@@ -178,15 +194,15 @@ export namespace NestMethodProgrammer {
                 ? "EncryptedBody"
                 : "TypedBody",
               variable: "body",
-            })(importer)(components)(route.body.schema),
+            })(components)(importer)(route.body.schema),
           ]
         : []),
     ];
 
   const writeDtoParameter =
     (accessor: { method: string; variable: string }) =>
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (schema: ISwaggerSchema): ts.ParameterDeclaration =>
       ts.factory.createParameterDeclaration(
         [
@@ -194,8 +210,9 @@ export namespace NestMethodProgrammer {
             ts.factory.createCallExpression(
               ts.factory.createIdentifier(
                 importer.external({
+                  type: "instance",
                   library: "@nestia/core",
-                  instance: accessor.method,
+                  name: accessor.method,
                 }),
               ),
               undefined,
@@ -206,6 +223,6 @@ export namespace NestMethodProgrammer {
         undefined,
         StringUtil.normalize(accessor.variable),
         undefined,
-        SchemaProgrammer.write(importer)(components)(schema),
+        SchemaProgrammer.write(components)(importer)(schema),
       );
 }

package/src/programmers/NestProgrammer.ts

@@ -8,7 +8,7 @@ import { ImportProgrammer } from "./ImportProgrammer";
 import { NestControllerProgrammer } from "./NestControllerProgrammer";
 import { NestModuleProgrammer } from "./NestModuleProgrammer";
 
-export namespace MigrateProgrammer {
+export namespace NestProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] =>
     [
       {