@nestia/migrate 0.6.1 → 0.6.3

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/IMigrateProgram.ts

@@ -1,7 +1,9 @@
+import { IMigrateConfig } from "../IMigrateConfig";
 import { IMigrateController } from "./IMigrateController";
 import { ISwagger } from "./ISwagger";
 
 export interface IMigrateProgram {
+  config: IMigrateConfig;
   controllers: IMigrateController[];
   swagger: ISwagger;
 }

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":""}