@nestia/migrate 0.6.0 → 0.6.2

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

@@ -0,0 +1,48 @@
+import ts from "typescript";
+
+import { IMigrateController } from "../structures/IMigrateController";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { FilePrinter } from "../utils/FilePrinter";
+import { StringUtil } from "../utils/StringUtil";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { NestMethodProgrammer } from "./NestMethodProgrammer";
+
+export namespace NestControllerProgrammer {
+  export const write =
+    (components: ISwaggerComponents) =>
+    (controller: IMigrateController): ts.Statement[] => {
+      const importer: ImportProgrammer = new ImportProgrammer();
+      const $class = ts.factory.createClassDeclaration(
+        [
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(
+                importer.external({
+                  type: "instance",
+                  library: "@nestjs/common",
+                  name: "Controller",
+                }),
+              ),
+              [],
+              [ts.factory.createStringLiteral(controller.path)],
+            ),
+          ),
+          ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
+        ],
+        controller.name,
+        [],
+        [],
+        controller.routes.map(NestMethodProgrammer.write(components)(importer)),
+      );
+      return [
+        ...importer.toStatements(
+          (ref) =>
+            `${"../".repeat(
+              StringUtil.splitWithNormalization(controller.location).length - 1,
+            )}api/structures/${ref}`,
+        ),
+        ...(importer.empty() ? [] : [FilePrinter.enter()]),
+        $class,
+      ];
+    };
+}

package/src/programmers/NestMethodProgrammer.ts

@@ -0,0 +1,228 @@
+import ts from "typescript";
+import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { FilePrinter } from "../utils/FilePrinter";
+import { StringUtil } from "../utils/StringUtil";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { SchemaProgrammer } from "./SchemaProgrammer";
+
+export namespace NestMethodProgrammer {
+  export const write =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (route: IMigrateRoute): ts.MethodDeclaration => {
+      const output: ts.TypeNode = route.success
+        ? SchemaProgrammer.write(components)(importer)(route.success.schema)
+        : TypeFactory.keyword("void");
+
+      const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
+        [
+          ...writeMethodDecorators(components)(importer)(route),
+          ts.factory.createToken(ts.SyntaxKind.PublicKeyword),
+          ts.factory.createToken(ts.SyntaxKind.AsyncKeyword),
+        ],
+        undefined,
+        route.name,
+        undefined,
+        undefined,
+        writeParameters(components)(importer)(route),
+        ts.factory.createTypeReferenceNode("Promise", [output]),
+        ts.factory.createBlock(
+          [
+            ...[
+              ...route.parameters.map((p) => StringUtil.normalize(p.key)),
+              ...(route.headers ? ["headers"] : []),
+              ...(route.query ? ["query"] : []),
+              ...(route.body ? ["body"] : []),
+            ].map((str) =>
+              ts.factory.createExpressionStatement(
+                ts.factory.createIdentifier(str),
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(
+                  ts.factory.createIdentifier(
+                    importer.external({
+                      type: "default",
+                      library: "typia",
+                      name: "typia",
+                    }),
+                  ),
+                )("random"),
+                [output],
+                undefined,
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+      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) =>
+    (route: IMigrateRoute): ts.Decorator[] => {
+      const external =
+        (lib: string) =>
+        (instance: string): ts.Identifier =>
+          ts.factory.createIdentifier(
+            importer.external({
+              type: "instance",
+              library: lib,
+              name: instance,
+            }),
+          );
+      const router = (instance: string) =>
+        ts.factory.createDecorator(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(external("@nestia/core")(instance))(
+              StringUtil.capitalize(route.method),
+            ),
+            [],
+            [ts.factory.createStringLiteral(route.path)],
+          ),
+        );
+
+      const decorators: ts.Decorator[] = [];
+      if (route.success?.["x-nestia-encrypted"])
+        decorators.push(router("EncryptedRoute"));
+      else if (route.success?.type === "text/plain")
+        decorators.push(
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              external("@nestjs/common")(StringUtil.capitalize(route.method)),
+              [],
+              [ts.factory.createStringLiteral(route.path)],
+            ),
+          ),
+        );
+      else if (route.success?.type === "application/x-www-form-urlencoded")
+        decorators.push(router("TypedQuery"));
+      else if (route.success?.type === "application/json")
+        decorators.push(router("TypedRoute"));
+      else if (route.method === "head")
+        decorators.push(
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              external("@nestjs/common")("Head"),
+              [],
+              [ts.factory.createStringLiteral(route.path)],
+            ),
+          ),
+        );
+      for (const [key, value] of Object.entries(route.exceptions ?? {}))
+        decorators.push(
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              external("@nestia/core")("TypedException"),
+              [SchemaProgrammer.write(components)(importer)(value.schema)],
+              [
+                isNaN(Number(key))
+                  ? ts.factory.createStringLiteral(key)
+                  : ExpressionFactory.number(Number(key)),
+                ...(value.description?.length
+                  ? [ts.factory.createStringLiteral(value.description)]
+                  : []),
+              ],
+            ),
+          ),
+        );
+      return decorators;
+    };
+
+  const writeParameters =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (route: IMigrateRoute): ts.ParameterDeclaration[] => [
+      ...route.parameters.map(({ key, schema: value }) =>
+        ts.factory.createParameterDeclaration(
+          [
+            ts.factory.createDecorator(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                  importer.external({
+                    type: "instance",
+                    library: "@nestia/core",
+                    name: "TypedParam",
+                  }),
+                ),
+                undefined,
+                [ts.factory.createStringLiteral(key)],
+              ),
+            ),
+          ],
+          undefined,
+          StringUtil.normalize(key),
+          undefined,
+          SchemaProgrammer.write(components)(importer)(value),
+        ),
+      ),
+      ...(route.headers
+        ? [
+            writeDtoParameter({ method: "TypedHeaders", variable: "headers" })(
+              components,
+            )(importer)(route.headers.schema),
+          ]
+        : []),
+      ...(route.query
+        ? [
+            writeDtoParameter({ method: "TypedQuery", variable: "query" })(
+              components,
+            )(importer)(route.query.schema),
+          ]
+        : []),
+      ...(route.body
+        ? [
+            writeDtoParameter({
+              method: route.body?.["x-nestia-encrypted"]
+                ? "EncryptedBody"
+                : "TypedBody",
+              variable: "body",
+            })(components)(importer)(route.body.schema),
+          ]
+        : []),
+    ];
+
+  const writeDtoParameter =
+    (accessor: { method: string; variable: string }) =>
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (schema: ISwaggerSchema): ts.ParameterDeclaration =>
+      ts.factory.createParameterDeclaration(
+        [
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(
+                importer.external({
+                  type: "instance",
+                  library: "@nestia/core",
+                  name: accessor.method,
+                }),
+              ),
+              undefined,
+              undefined,
+            ),
+          ),
+        ],
+        undefined,
+        StringUtil.normalize(accessor.variable),
+        undefined,
+        SchemaProgrammer.write(components)(importer)(schema),
+      );
+}

package/src/programmers/{ModuleProgrammer.ts → NestModuleProgrammer.ts}

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { IMigrateController } from "../structures/IMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
 
-export namespace ModuleProgrammer {
+export namespace NestModuleProgrammer {
   export const write = (controllers: IMigrateController[]): ts.Statement[] => [
     $import("@nestjs/common")("Module"),
     ...(controllers.length ? [FilePrinter.enter()] : []),

package/src/programmers/{MigrateProgrammer.ts → NestProgrammer.ts}

@@ -2,30 +2,26 @@ import ts from "typescript";
 
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
-import { ISwagger } from "../structures/ISwagger";
 import { FilePrinter } from "../utils/FilePrinter";
-import { ControllerProgrammer } from "./ControllerProgrammer";
 import { DtoProgrammer } from "./DtoProgrammer";
 import { ImportProgrammer } from "./ImportProgrammer";
-import { ModuleProgrammer } from "./ModuleProgrammer";
-
-export namespace MigrateProgrammer {
-  export const analyze = (swagger: ISwagger): IMigrateProgram => ({
-    swagger,
-    controllers: ControllerProgrammer.analyze(swagger),
-  });
+import { NestControllerProgrammer } from "./NestControllerProgrammer";
+import { NestModuleProgrammer } from "./NestModuleProgrammer";
 
+export namespace NestProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] =>
     [
       {
         location: "src",
         file: "MyModule.ts",
-        statements: ModuleProgrammer.write(program.controllers),
+        statements: NestModuleProgrammer.write(program.controllers),
       },
       ...program.controllers.map((c) => ({
         location: c.location,
         file: `${c.name}.ts`,
-        statements: ControllerProgrammer.write(program.swagger.components)(c),
+        statements: NestControllerProgrammer.write(program.swagger.components)(
+          c,
+        ),
       })),
       ...[...DtoProgrammer.write(program.swagger.components).entries()].map(
         ([key, value]) => ({
@@ -40,7 +36,10 @@ export namespace MigrateProgrammer {
       content: FilePrinter.write({ statements: o.statements }),
     }));
 
-  const writeDtoFile = (key: string, modulo: DtoProgrammer.IModule): ts.Statement[] => {
+  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 [];

package/src/programmers/SchemaProgrammer.ts

@@ -15,8 +15,8 @@ export namespace SchemaProgrammer {
     FACADE
   ----------------------------------------------------------- */
   export const write =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (schema: ISwaggerSchema): ts.TypeNode => {
       const union: ts.TypeNode[] = [];
       if (SwaggerTypeChecker.isUnknown(schema))
@@ -36,16 +36,16 @@ export namespace SchemaProgrammer {
         else if (SwaggerTypeChecker.isString(schema))
           return writeString(importer)(schema);
         else if (SwaggerTypeChecker.isArray(schema))
-          return writeArray(importer)(components)(schema);
+          return writeArray(components)(importer)(schema);
         else if (SwaggerTypeChecker.isObject(schema))
-          return writeObject(importer)(components)(schema);
+          return writeObject(components)(importer)(schema);
         else if (SwaggerTypeChecker.isReference(schema))
           return writeReference(importer)(schema);
         // NESTED UNION
         else if (SwaggerTypeChecker.isAnyOf(schema))
-          return writeUnion(importer)(components)(schema.anyOf);
+          return writeUnion(components)(importer)(schema.anyOf);
         else if (SwaggerTypeChecker.isOneOf(schema))
-          return writeUnion(importer)(components)(schema.oneOf);
+          return writeUnion(components)(importer)(schema.oneOf);
         else return TypeFactory.keyword("any");
       })();
       union.push(type);
@@ -141,12 +141,12 @@ export namespace SchemaProgrammer {
     INSTANCES
   ----------------------------------------------------------- */
   const writeArray =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (schema: ISwaggerSchema.IArray): ts.TypeNode => {
       const intersection: ts.TypeNode[] = [
         ts.factory.createArrayTypeNode(
-          write(importer)(components)(schema.items),
+          write(components)(importer)(schema.items),
         ),
       ];
       if (schema.minItems !== undefined)
@@ -159,13 +159,13 @@ export namespace SchemaProgrammer {
     };
 
   const writeObject =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (schema: ISwaggerSchema.IObject): ts.TypeNode => {
       const regular = () =>
         ts.factory.createTypeLiteralNode(
           Object.entries(schema.properties ?? []).map(([key, value]) =>
-            writeRegularProperty(importer)(components)(schema.required ?? [])(
+            writeRegularProperty(components)(importer)(schema.required ?? [])(
               key,
               value,
             ),
@@ -173,24 +173,21 @@ export namespace SchemaProgrammer {
         );
       const dynamic = () =>
         ts.factory.createTypeLiteralNode([
-          writeDynamicProperty(importer)(components)(
+          writeDynamicProperty(components)(importer)(
             schema.additionalProperties as ISwaggerSchema,
           ),
         ]);
-      return FilePrinter.description(
-        !!schema.properties?.length &&
-          typeof schema.additionalProperties === "object"
-          ? ts.factory.createIntersectionTypeNode([regular(), dynamic()])
-          : typeof schema.additionalProperties === "object"
-            ? dynamic()
-            : regular(),
-        writeComment(schema),
-      );
+      return !!schema.properties?.length &&
+        typeof schema.additionalProperties === "object"
+        ? ts.factory.createIntersectionTypeNode([regular(), dynamic()])
+        : typeof schema.additionalProperties === "object"
+          ? dynamic()
+          : regular();
     };
 
   const writeRegularProperty =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (required: string[]) =>
     (key: string, value: ISwaggerSchema) =>
       FilePrinter.description(
@@ -202,14 +199,14 @@ export namespace SchemaProgrammer {
           required.includes(key)
             ? undefined
             : ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-          write(importer)(components)(value),
+          write(components)(importer)(value),
         ),
         writeComment(value),
       );
 
   const writeDynamicProperty =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (value: ISwaggerSchema) =>
       FilePrinter.description(
         ts.factory.createIndexSignature(
@@ -223,7 +220,7 @@ export namespace SchemaProgrammer {
               TypeFactory.keyword("string"),
             ),
           ],
-          write(importer)(components)(value),
+          write(components)(importer)(value),
         ),
         writeComment(value),
       );
@@ -237,10 +234,10 @@ export namespace SchemaProgrammer {
     UNIONS
   ----------------------------------------------------------- */
   const writeUnion =
-    (importer: ImportProgrammer) =>
     (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
     (elements: ISwaggerSchema[]): ts.UnionTypeNode =>
-      ts.factory.createUnionTypeNode(elements.map(write(importer)(components)));
+      ts.factory.createUnionTypeNode(elements.map(write(components)(importer)));
 }
 const createNode = (text: string) => ts.factory.createTypeReferenceNode(text);
 const writeComment = (schema: ISwaggerSchema): string =>

package/src/structures/IMigrateRoute.ts

@@ -1,5 +1,3 @@
-import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
-
 import { ISwaggerSchema } from "./ISwaggeSchema";
 
 export interface IMigrateRoute {
@@ -7,13 +5,14 @@ export interface IMigrateRoute {
   path: string;
   method: string;
   parameters: IMigrateRoute.IParameter[];
-  headers: ISwaggerSchema | null;
-  query: ISwaggerSchema | null;
+  headers: IMigrateRoute.IHeaders | null;
+  query: IMigrateRoute.IQuery | null;
   body: IMigrateRoute.IBody | null;
   success: IMigrateRoute.IBody | null;
   exceptions: Record<string, IMigrateRoute.IException>;
   description?: string;
-  "x-nestia-jsDocTags"?: IJsDocTagInfo[];
+  tags: string[];
+  deprecated: boolean;
 }
 export namespace IMigrateRoute {
   export interface IParameter {
@@ -21,7 +20,16 @@ export namespace IMigrateRoute {
     schema: ISwaggerSchema;
     description?: string;
   }
+  export interface IHeaders {
+    key: string;
+    schema: ISwaggerSchema;
+  }
+  export interface IQuery {
+    key: string;
+    schema: ISwaggerSchema;
+  }
   export interface IBody {
+    key: string;
     type:
       | "text/plain"
       | "application/json"

package/src/utils/SetupWizard.ts

@@ -3,9 +3,6 @@ import cp from "child_process";
 export namespace SetupWizard {
   export const setup = (output: string) => {
     execute(output)("npm install");
-    execute(output)("npx nestia e2e", "npm run build:sdk");
-    execute(output)("npm run build:test");
-    execute(output)("npm run test");
   };
 
   const execute = (cwd: string) => (command: string, fake?: string) => {

package/src/utils/StringUtil.ts

@@ -1,3 +1,5 @@
+import { NamingConvention } from "typia/lib/utils/NamingConvention";
+
 export namespace StringUtil {
   export const capitalize = (str: string) =>
     str[0].toUpperCase() + str.slice(1).toLowerCase();
@@ -5,12 +7,14 @@ export namespace StringUtil {
   export const pascal = (path: string) =>
     splitWithNormalization(path)
       .filter((str) => str[0] !== "{")
-      .map(capitalize)
+      .map(NamingConvention.pascal)
       .join("");
 
   export const camel = (path: string) =>
     splitWithNormalization(path)
-      .map((str, i) => (i === 0 ? str : capitalize(str)))
+      .map((str, i) =>
+        i === 0 ? NamingConvention.camel(str) : NamingConvention.pascal(str),
+      )
       .join("");
 
   export const splitWithNormalization = (path: string) =>
@@ -48,4 +52,9 @@ export namespace StringUtil {
       .filter((str) => str[0] !== "{" || str[str.length - 1] === "}")
       .join("/");
   };
+
+  export const escapeDuplicate =
+    (keep: string[]) =>
+    (change: string): string =>
+      keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
 }