@nestia/migrate 0.5.0 → 0.6.0

package/src/utils/FilePrinter.ts

@@ -0,0 +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 enter = () =>
+    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/JsonTypeChecker.ts

@@ -1,52 +1,67 @@
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
-
-export namespace JsonTypeChecker {
-    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);
-}
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+
+export namespace SwaggerTypeChecker {
+  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 (SwaggerTypeChecker.isAnyOf(schema))
+        return schema.anyOf.some(isNullable(components));
+      else if (SwaggerTypeChecker.isOneOf(schema))
+        return schema.oneOf.some(isNullable(components));
+      else if (SwaggerTypeChecker.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/src/utils/MapUtil.ts

@@ -1,13 +1,13 @@
-export namespace MapUtil {
-    export const take =
-        <Key, T>(dict: Map<Key, T>) =>
-        (key: Key) =>
-        (generator: () => T): T => {
-            const oldbie: T | undefined = dict.get(key);
-            if (oldbie) return oldbie;
-
-            const value: T = generator();
-            dict.set(key, value);
-            return value;
-        };
-}
+export namespace MapUtil {
+  export const take =
+    <Key, T>(dict: Map<Key, T>) =>
+    (key: Key) =>
+    (generator: () => T): T => {
+      const oldbie: T | undefined = dict.get(key);
+      if (oldbie) return oldbie;
+
+      const value: T = generator();
+      dict.set(key, value);
+      return value;
+    };
+}

package/src/utils/SetupWizard.ts

@@ -1,15 +1,15 @@
-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) => {
-        console.log(fake ?? command);
-        cp.execSync(command, { cwd, stdio: "inherit" });
-    };
-}
+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) => {
+    console.log(fake ?? command);
+    cp.execSync(command, { cwd, stdio: "inherit" });
+  };
+}

package/src/utils/StringUtil.ts

@@ -1,51 +1,51 @@
-export namespace StringUtil {
-    export const capitalize = (str: string) =>
-        str[0].toUpperCase() + str.slice(1).toLowerCase();
-
-    export const pascal = (path: string) =>
-        splitWithNormalization(path)
-            .filter((str) => str[0] !== "{")
-            .map(capitalize)
-            .join("");
-
-    export const camel = (path: string) =>
-        splitWithNormalization(path)
-            .map((str, i) => (i === 0 ? str : capitalize(str)))
-            .join("");
-
-    export const splitWithNormalization = (path: string) =>
-        path
-            .split("/")
-            .map((str) => normalize(str.trim()))
-            .filter((str) => !!str.length);
-
-    export const reJoinWithDecimalParameters = (path: string) =>
-        path
-            .split("/")
-            .filter((str) => !!str.length)
-            .map((str) =>
-                str[0] === "{" && str[str.length - 1] === "}"
-                    ? `:${str.substring(1, str.length - 1)}`
-                    : str,
-            )
-            .join("/");
-
-    export const normalize = (str: string) =>
-        str.split(".").join("_").split("-").join("_");
-
-    export const commonPrefix = (strs: string[]): string => {
-        if (strs.length === 0) return "";
-
-        let prefix = strs[0];
-        for (let i = 1; i < strs.length; i++) {
-            while (strs[i].indexOf(prefix) !== 0) {
-                prefix = prefix.substring(0, prefix.length - 1);
-                if (prefix === "") return "";
-            }
-        }
-        return prefix
-            .split("/")
-            .filter((str) => str[0] !== "{" || str[str.length - 1] === "}")
-            .join("/");
-    };
-}
+export namespace StringUtil {
+  export const capitalize = (str: string) =>
+    str[0].toUpperCase() + str.slice(1).toLowerCase();
+
+  export const pascal = (path: string) =>
+    splitWithNormalization(path)
+      .filter((str) => str[0] !== "{")
+      .map(capitalize)
+      .join("");
+
+  export const camel = (path: string) =>
+    splitWithNormalization(path)
+      .map((str, i) => (i === 0 ? str : capitalize(str)))
+      .join("");
+
+  export const splitWithNormalization = (path: string) =>
+    path
+      .split("/")
+      .map((str) => normalize(str.trim()))
+      .filter((str) => !!str.length);
+
+  export const reJoinWithDecimalParameters = (path: string) =>
+    path
+      .split("/")
+      .filter((str) => !!str.length)
+      .map((str) =>
+        str[0] === "{" && str[str.length - 1] === "}"
+          ? `:${str.substring(1, str.length - 1)}`
+          : str,
+      )
+      .join("/");
+
+  export const normalize = (str: string) =>
+    str.split(".").join("_").split("-").join("_");
+
+  export const commonPrefix = (strs: string[]): string => {
+    if (strs.length === 0) return "";
+
+    let prefix = strs[0];
+    for (let i = 1; i < strs.length; i++) {
+      while (strs[i].indexOf(prefix) !== 0) {
+        prefix = prefix.substring(0, prefix.length - 1);
+        if (prefix === "") return "";
+      }
+    }
+    return prefix
+      .split("/")
+      .filter((str) => str[0] !== "{" || str[str.length - 1] === "}")
+      .join("/");
+  };
+}