@nestia/migrate 0.6.1 → 0.6.2

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[] =>
     [
       {

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;
 }

package/lib/analyzers/RouteAnalyzer.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=RouteAnalyzer.js.map

package/lib/analyzers/RouteAnalyzer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"RouteAnalyzer.js","sourceRoot":"","sources":["../../src/analyzers/RouteAnalyzer.ts"],"names":[],"mappings":""}