@nestia/migrate 0.7.6 → 0.7.8

package/src/structures/IMigrateDto.ts

@@ -1,8 +1,8 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
-
-export interface IMigrateDto {
-  name: string;
-  location: string;
-  schema: ISwaggerSchema | null;
-  children: IMigrateDto[];
-}
+import { ISwaggerSchema } from "./ISwaggerSchema";
+
+export interface IMigrateDto {
+  name: string;
+  location: string;
+  schema: ISwaggerSchema | null;
+  children: IMigrateDto[];
+}

package/src/structures/IMigrateProgram.ts

@@ -1,9 +1,25 @@
-import { IMigrateConfig } from "../IMigrateConfig";
-import { IMigrateController } from "./IMigrateController";
-import { ISwagger } from "./ISwagger";
-
-export interface IMigrateProgram {
-  config: IMigrateConfig;
-  controllers: IMigrateController[];
-  swagger: ISwagger;
-}
+import { IMigrateController } from "./IMigrateController";
+import { IMigrateRoute } from "./IMigrateRoute";
+import { ISwagger } from "./ISwagger";
+import { ISwaggerRoute } from "./ISwaggerRoute";
+
+export interface IMigrateProgram extends IMigrateProgram.IProps {
+  controllers: IMigrateController[];
+}
+export namespace IMigrateProgram {
+  export type Dictionary = Map<ISwaggerRoute, IEntry>;
+  export interface IEntry {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+  }
+  export interface IProps {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+    swagger: ISwagger;
+    dictionary: Dictionary;
+  }
+  export interface IConfig {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+  }
+}

package/src/structures/IMigrateRoute.ts

@@ -1,46 +1,46 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
-
-export interface IMigrateRoute {
-  name: string;
-  path: string;
-  method: string;
-  accessor: string[];
-  parameters: IMigrateRoute.IParameter[];
-  headers: IMigrateRoute.IHeaders | null;
-  query: IMigrateRoute.IQuery | null;
-  body: IMigrateRoute.IBody | null;
-  success: IMigrateRoute.IBody | null;
-  exceptions: Record<string, IMigrateRoute.IException>;
-  description?: string;
-  tags: string[];
-  deprecated: boolean;
-}
-export namespace IMigrateRoute {
-  export interface IParameter {
-    key: string;
-    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"
-      | "application/x-www-form-urlencoded"
-      | "multipart/form-data";
-    schema: ISwaggerSchema;
-    "x-nestia-encrypted"?: boolean;
-  }
-  export interface IException {
-    description?: string;
-    schema: ISwaggerSchema;
-  }
-}
+import { ISwaggerSchema } from "./ISwaggerSchema";
+
+export interface IMigrateRoute {
+  name: string;
+  path: string;
+  method: string;
+  accessor: string[];
+  parameters: IMigrateRoute.IParameter[];
+  headers: IMigrateRoute.IHeaders | null;
+  query: IMigrateRoute.IQuery | null;
+  body: IMigrateRoute.IBody | null;
+  success: IMigrateRoute.IBody | null;
+  exceptions: Record<string, IMigrateRoute.IException>;
+  description?: string;
+  tags: string[];
+  deprecated: boolean;
+}
+export namespace IMigrateRoute {
+  export interface IParameter {
+    key: string;
+    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"
+      | "application/x-www-form-urlencoded"
+      | "multipart/form-data";
+    schema: ISwaggerSchema;
+    "x-nestia-encrypted"?: boolean;
+  }
+  export interface IException {
+    description?: string;
+    schema: ISwaggerSchema;
+  }
+}

package/src/structures/ISwaggerComponents.ts

@@ -1,7 +1,7 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
-import { ISwaggerSecurity } from "./ISwaggerSecurity";
-
-export interface ISwaggerComponents {
-  schemas?: Record<string, ISwaggerSchema>;
-  securitySchemes?: Record<string, ISwaggerSecurity>;
-}
+import { ISwaggerSchema } from "./ISwaggerSchema";
+import { ISwaggerSecurity } from "./ISwaggerSecurity";
+
+export interface ISwaggerComponents {
+  schemas?: Record<string, ISwaggerSchema>;
+  securitySchemes?: Record<string, ISwaggerSecurity>;
+}

package/src/structures/ISwaggerRoute.ts

@@ -1,55 +1,55 @@
-import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
-
-import { ISwaggerSchema } from "./ISwaggeSchema";
-
-export interface ISwaggerRoute {
-  parameters?: ISwaggerRoute.IParameter[];
-  requestBody?: ISwaggerRoute.IRequestBody;
-  responses?: ISwaggerRoute.IResponseBody;
-  summary?: string;
-  description?: string;
-  deprecated?: boolean;
-  security?: Record<string, string[]>[];
-  tags?: string[];
-  "x-nestia-jsDocTags"?: IJsDocTagInfo[];
-}
-export namespace ISwaggerRoute {
-  export interface IParameter {
-    name?: string;
-    in: "path" | "query" | "header" | "cookie";
-    schema: ISwaggerSchema;
-    required?: boolean;
-    description?: string;
-  }
-  export interface IRequestBody {
-    description?: string;
-    content: IContent;
-    required?: boolean;
-    "x-nestia-encrypted"?: boolean;
-  }
-  export type IResponseBody = Record<
-    string,
-    {
-      description?: string;
-      content?: IContent;
-      "x-nestia-encrypted"?: boolean;
-    }
-  >;
-  export interface IContent {
-    "text/plain"?: {
-      schema: ISwaggerSchema;
-    };
-    "application/json"?: {
-      schema: ISwaggerSchema;
-    };
-    "application/x-www-form-urlencoded"?: {
-      schema: ISwaggerSchema;
-    };
-    "multipart/form-data"?: {
-      schema: ISwaggerSchema;
-    };
-    "*/*"?: {
-      schema: ISwaggerSchema;
-    };
-  }
-}
+import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
+
+import { ISwaggerSchema } from "./ISwaggerSchema";
+
+export interface ISwaggerRoute {
+  parameters?: ISwaggerRoute.IParameter[];
+  requestBody?: ISwaggerRoute.IRequestBody;
+  responses?: ISwaggerRoute.IResponseBody;
+  summary?: string;
+  description?: string;
+  deprecated?: boolean;
+  security?: Record<string, string[]>[];
+  tags?: string[];
+  "x-nestia-jsDocTags"?: IJsDocTagInfo[];
+}
+export namespace ISwaggerRoute {
+  export interface IParameter {
+    name?: string;
+    in: "path" | "query" | "header" | "cookie";
+    schema: ISwaggerSchema;
+    required?: boolean;
+    description?: string;
+  }
+  export interface IRequestBody {
+    description?: string;
+    content: IContent;
+    required?: boolean;
+    "x-nestia-encrypted"?: boolean;
+  }
+  export type IResponseBody = Record<
+    string,
+    {
+      description?: string;
+      content?: IContent;
+      "x-nestia-encrypted"?: boolean;
+    }
+  >;
+  export interface IContent {
+    "text/plain"?: {
+      schema: ISwaggerSchema;
+    };
+    "application/json"?: {
+      schema: ISwaggerSchema;
+    };
+    "application/x-www-form-urlencoded"?: {
+      schema: ISwaggerSchema;
+    };
+    "multipart/form-data"?: {
+      schema: ISwaggerSchema;
+    };
+    "*/*"?: {
+      schema: ISwaggerSchema;
+    };
+  }
+}

package/src/structures/{ISwaggeSchema.ts → ISwaggerSchema.ts}

@@ -1,90 +1,90 @@
-export type ISwaggerSchema =
-  | ISwaggerSchema.IUnknown
-  | ISwaggerSchema.INullOnly
-  | ISwaggerSchema.IAnyOf
-  | ISwaggerSchema.IOneOf
-  | ISwaggerSchema.IBoolean
-  | ISwaggerSchema.IInteger
-  | ISwaggerSchema.INumber
-  | ISwaggerSchema.IString
-  | ISwaggerSchema.IArray
-  | ISwaggerSchema.IObject
-  | ISwaggerSchema.IReference;
-export namespace ISwaggerSchema {
-  export interface IUnknown extends IAttribute {
-    type?: undefined;
-  }
-  export interface INullOnly extends IAttribute {
-    type: "null";
-  }
-
-  export interface IAnyOf extends IAttribute {
-    anyOf: ISwaggerSchema[];
-  }
-  export interface IOneOf extends IAttribute {
-    oneOf: ISwaggerSchema[];
-  }
-
-  export interface IBoolean extends ISignificant<"boolean"> {
-    default?: boolean;
-    enum?: boolean[];
-  }
-  export interface IInteger extends ISignificant<"integer"> {
-    /** @type int */ default?: number;
-    /** @type int */ enum?: number[];
-    /** @type int */ minimum?: number;
-    /** @type int */ maximum?: number;
-    /** @type int */ exclusiveMinimum?: boolean;
-    /** @type int */ exclusiveMaximum?: boolean;
-    /** @type uint */ multipleOf?: number;
-  }
-  export interface INumber extends ISignificant<"number"> {
-    default?: number;
-    enum?: number[];
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: boolean;
-    exclusiveMaximum?: boolean;
-    multipleOf?: number;
-  }
-  export interface IString extends ISignificant<"string"> {
-    default?: string;
-    enum?: string[];
-    format?: string;
-    pattern?: string;
-    /** @type uint */ minLength?: number;
-    /** @type uint */ maxLength?: number;
-  }
-
-  export interface IArray extends ISignificant<"array"> {
-    items: ISwaggerSchema;
-    /** @type uint */ minItems?: number;
-    /** @type uint */ maxItems?: number;
-    "x-typia-tuple"?: ITuple;
-  }
-  export interface ITuple extends ISignificant<"array"> {
-    items: ISwaggerSchema[];
-  }
-  export interface IObject extends ISignificant<"object"> {
-    properties?: Record<string, ISwaggerSchema>;
-    required?: string[];
-    additionalProperties?: ISwaggerSchema | boolean;
-    "x-typia-patternProperties"?: Record<string, ISwaggerSchema>;
-  }
-
-  export interface IReference extends IAttribute {
-    $ref: string;
-  }
-
-  interface ISignificant<Type extends string> extends IAttribute {
-    type: Type;
-    nullable?: boolean;
-  }
-  interface IAttribute {
-    title?: string;
-    description?: string;
-    deprecated?: boolean;
-    "x-typia-optional"?: boolean;
-    "x-typia-rest"?: boolean;
-  }
-}
+export type ISwaggerSchema =
+  | ISwaggerSchema.IUnknown
+  | ISwaggerSchema.INullOnly
+  | ISwaggerSchema.IAnyOf
+  | ISwaggerSchema.IOneOf
+  | ISwaggerSchema.IBoolean
+  | ISwaggerSchema.IInteger
+  | ISwaggerSchema.INumber
+  | ISwaggerSchema.IString
+  | ISwaggerSchema.IArray
+  | ISwaggerSchema.IObject
+  | ISwaggerSchema.IReference;
+export namespace ISwaggerSchema {
+  export interface IUnknown extends IAttribute {
+    type?: undefined;
+  }
+  export interface INullOnly extends IAttribute {
+    type: "null";
+  }
+
+  export interface IAnyOf extends IAttribute {
+    anyOf: ISwaggerSchema[];
+  }
+  export interface IOneOf extends IAttribute {
+    oneOf: ISwaggerSchema[];
+  }
+
+  export interface IBoolean extends ISignificant<"boolean"> {
+    default?: boolean;
+    enum?: boolean[];
+  }
+  export interface IInteger extends ISignificant<"integer"> {
+    /** @type int */ default?: number;
+    /** @type int */ enum?: number[];
+    /** @type int */ minimum?: number;
+    /** @type int */ maximum?: number;
+    /** @type int */ exclusiveMinimum?: boolean;
+    /** @type int */ exclusiveMaximum?: boolean;
+    /** @type uint */ multipleOf?: number;
+  }
+  export interface INumber extends ISignificant<"number"> {
+    default?: number;
+    enum?: number[];
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    multipleOf?: number;
+  }
+  export interface IString extends ISignificant<"string"> {
+    default?: string;
+    enum?: string[];
+    format?: string;
+    pattern?: string;
+    /** @type uint */ minLength?: number;
+    /** @type uint */ maxLength?: number;
+  }
+
+  export interface IArray extends ISignificant<"array"> {
+    items: ISwaggerSchema;
+    /** @type uint */ minItems?: number;
+    /** @type uint */ maxItems?: number;
+    "x-typia-tuple"?: ITuple;
+  }
+  export interface ITuple extends ISignificant<"array"> {
+    items: ISwaggerSchema[];
+  }
+  export interface IObject extends ISignificant<"object"> {
+    properties?: Record<string, ISwaggerSchema>;
+    required?: string[];
+    additionalProperties?: ISwaggerSchema | boolean;
+    "x-typia-patternProperties"?: Record<string, ISwaggerSchema>;
+  }
+
+  export interface IReference extends IAttribute {
+    $ref: string;
+  }
+
+  interface ISignificant<Type extends string> extends IAttribute {
+    type: Type;
+    nullable?: boolean;
+  }
+  interface IAttribute {
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    "x-typia-optional"?: boolean;
+    "x-typia-rest"?: boolean;
+  }
+}

package/src/utils/FilePrinter.ts

@@ -1,36 +1,36 @@
-import ts from "typescript";
-
-export namespace FilePrinter {
-  export const description = <Node extends ts.Node>(
-    node: Node,
-    comment: string,
-  ): Node => {
-    if (comment.length === 0) return node;
-    ts.addSyntheticLeadingComment(
-      node,
-      ts.SyntaxKind.MultiLineCommentTrivia,
-      ["*", ...comment.split("\n").map((str) => ` * ${str}`), ""].join("\n"),
-      true,
-    );
-    return node;
-  };
-
-  export const newLine = () =>
-    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
-
-  export const write = (props: {
-    statements: ts.Statement[];
-    top?: string;
-  }): string => {
-    const script: string = ts
-      .createPrinter()
-      .printFile(
-        ts.factory.createSourceFile(
-          props.statements,
-          ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
-          ts.NodeFlags.None,
-        ),
-      );
-    return (props.top ?? "") + script;
-  };
-}
+import ts from "typescript";
+
+export namespace FilePrinter {
+  export const description = <Node extends ts.Node>(
+    node: Node,
+    comment: string,
+  ): Node => {
+    if (comment.length === 0) return node;
+    ts.addSyntheticLeadingComment(
+      node,
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      ["*", ...comment.split("\n").map((str) => ` * ${str}`), ""].join("\n"),
+      true,
+    );
+    return node;
+  };
+
+  export const newLine = () =>
+    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
+
+  export const write = (props: {
+    statements: ts.Statement[];
+    top?: string;
+  }): string => {
+    const script: string = ts
+      .createPrinter()
+      .printFile(
+        ts.factory.createSourceFile(
+          props.statements,
+          ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+          ts.NodeFlags.None,
+        ),
+      );
+    return (props.top ?? "") + script;
+  };
+}

package/src/utils/SwaggerTypeChecker.ts

@@ -1,67 +1,67 @@
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-
-export namespace SwaggerSwaggerChecker {
-  export const isAnyOf = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IAnyOf => (schema as any).anyOf !== undefined;
-
-  export const isOneOf = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IOneOf => (schema as any).oneOf !== undefined;
-
-  export const isNullOnly = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.INullOnly => (schema as any).type === "null";
-
-  export const isBoolean = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IBoolean => (schema as any).type === "boolean";
-
-  export const isInteger = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IInteger => (schema as any).type === "integer";
-
-  export const isNumber = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.INumber => (schema as any).type === "number";
-
-  export const isString = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IString => (schema as any).type === "string";
-
-  export const isArray = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IArray => (schema as any).type === "array";
-
-  export const isObject = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IObject => (schema as any).type === "object";
-
-  export const isReference = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IReference => (schema as any).$ref !== undefined;
-
-  export const isUnknown = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IUnknown =>
-    (schema as any).type === undefined &&
-    !isAnyOf(schema) &&
-    !isOneOf(schema) &&
-    !isReference(schema);
-
-  export const isNullable =
-    (components: ISwaggerComponents) =>
-    (schema: ISwaggerSchema): boolean => {
-      if (SwaggerSwaggerChecker.isAnyOf(schema))
-        return schema.anyOf.some(isNullable(components));
-      else if (SwaggerSwaggerChecker.isOneOf(schema))
-        return schema.oneOf.some(isNullable(components));
-      else if (SwaggerSwaggerChecker.isReference(schema)) {
-        const $id = schema.$ref.replace("#/components/schemas/", "");
-        const target = (components.schemas ?? {})[$id];
-        return target === undefined ? false : isNullable(components)(target);
-      }
-      return (schema as ISwaggerSchema.IString).nullable === true;
-    };
-}
+import { ISwaggerSchema } from "../structures/ISwaggerSchema";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+
+export namespace SwaggerSwaggerChecker {
+  export const isAnyOf = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IAnyOf => (schema as any).anyOf !== undefined;
+
+  export const isOneOf = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IOneOf => (schema as any).oneOf !== undefined;
+
+  export const isNullOnly = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.INullOnly => (schema as any).type === "null";
+
+  export const isBoolean = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IBoolean => (schema as any).type === "boolean";
+
+  export const isInteger = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IInteger => (schema as any).type === "integer";
+
+  export const isNumber = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.INumber => (schema as any).type === "number";
+
+  export const isString = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IString => (schema as any).type === "string";
+
+  export const isArray = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IArray => (schema as any).type === "array";
+
+  export const isObject = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IObject => (schema as any).type === "object";
+
+  export const isReference = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IReference => (schema as any).$ref !== undefined;
+
+  export const isUnknown = (
+    schema: ISwaggerSchema,
+  ): schema is ISwaggerSchema.IUnknown =>
+    (schema as any).type === undefined &&
+    !isAnyOf(schema) &&
+    !isOneOf(schema) &&
+    !isReference(schema);
+
+  export const isNullable =
+    (components: ISwaggerComponents) =>
+    (schema: ISwaggerSchema): boolean => {
+      if (SwaggerSwaggerChecker.isAnyOf(schema))
+        return schema.anyOf.some(isNullable(components));
+      else if (SwaggerSwaggerChecker.isOneOf(schema))
+        return schema.oneOf.some(isNullable(components));
+      else if (SwaggerSwaggerChecker.isReference(schema)) {
+        const $id = schema.$ref.replace("#/components/schemas/", "");
+        const target = (components.schemas ?? {})[$id];
+        return target === undefined ? false : isNullable(components)(target);
+      }
+      return (schema as ISwaggerSchema.IString).nullable === true;
+    };
+}

package/lib/IMigrateConfig.d.ts

@@ -1,4 +0,0 @@
-export interface IMigrateConfig {
-    mode: "nest" | "sdk";
-    simulate: boolean;
-}

package/lib/IMigrateConfig.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=IMigrateConfig.js.map