feat(emit-schema): add support for recursive directory creation

package.json

@@ -42,6 +42,7 @@
     "@types/ioredis": "^4.0.8",
     "@types/jest": "^23.3.14",
     "@types/node": "^11.9.4",
+    "@types/rimraf": "^2.0.2",
     "@types/ws": "^6.0.1",
     "apollo-cache-control": "^0.5.2",
     "apollo-cache-inmemory": "^1.4.3",
@@ -70,6 +71,7 @@
     "mysql": "^2.16.0",
     "prettier": "^1.16.4",
     "reflect-metadata": "^0.1.13",
+    "rimraf": "^2.6.3",
     "subscriptions-transport-ws": "^0.9.15",
     "ts-jest": "^24.0.0",
     "ts-node": "^8.0.2",

src/utils/buildSchema.ts

@@ -4,11 +4,11 @@ import { Options as PrintSchemaOptions } from "graphql/utilities/schemaPrinter";
 import { SchemaGenerator, SchemaGeneratorOptions } from "../schema/schema-generator";
 import { loadResolversFromGlob } from "../helpers/loadResolversFromGlob";
 import {
-  defaultSchemaFilePath,
   emitSchemaDefinitionFileSync,
   emitSchemaDefinitionFile,
   defaultPrintSchemaOptions,
 } from "./emitSchemaDefinitionFile";
+import { resolve } from "path";
 
 interface EmitSchemaFileOptions extends PrintSchemaOptions {
   path?: string;
@@ -61,6 +61,7 @@ function getEmitSchemaDefinitionFileOptions(
   schemaFileName: string;
   printSchemaOptions: PrintSchemaOptions;
 } {
+  const defaultSchemaFilePath = resolve(process.cwd(), "schema.gql");
   return {
     schemaFileName:
       typeof buildSchemaOptions.emitSchemaFile === "string"

src/utils/emitSchemaDefinitionFile.ts

@@ -1,9 +1,6 @@
-import { writeFile, writeFileSync } from "fs";
 import { GraphQLSchema, printSchema } from "graphql";
 import { Options as PrintSchemaOptions } from "graphql/utilities/schemaPrinter";
-import * as path from "path";
-
-export const defaultSchemaFilePath = path.resolve(process.cwd(), "schema.gql");
+import { outputFile, outputFileSync } from "./fileWriter";
 
 export const defaultPrintSchemaOptions: PrintSchemaOptions = { commentDescriptions: false };
 
@@ -21,7 +18,7 @@ export function emitSchemaDefinitionFileSync(
   options: PrintSchemaOptions = defaultPrintSchemaOptions,
 ) {
   const schemaFileContent = generatedSchemaWarning + printSchema(schema, options);
-  writeFileSync(schemaFilePath, schemaFileContent);
+  outputFileSync(schemaFilePath, schemaFileContent);
 }
 
 export async function emitSchemaDefinitionFile(
@@ -30,7 +27,5 @@ export async function emitSchemaDefinitionFile(
   options: PrintSchemaOptions = defaultPrintSchemaOptions,
 ) {
   const schemaFileContent = generatedSchemaWarning + printSchema(schema, options);
-  return new Promise<void>((resolve, reject) =>
-    writeFile(schemaFilePath, schemaFileContent, err => (err ? reject(err) : resolve())),
-  );
+  return outputFile(schemaFilePath, schemaFileContent);
 }

src/utils/fileWriter.ts

@@ -0,0 +1,88 @@
+import * as path from "path";
+import * as fs from "fs";
+
+function parsePath(targetPath: string) {
+  const directoryArray: string[] = [];
+  const parsedPath = path.parse(path.resolve(targetPath));
+  const splitPath = parsedPath.dir.split(path.sep);
+  if (parsedPath.root === "/") {
+    splitPath[0] = `/${splitPath[0]}`;
+  }
+  splitPath.reduce((previous: string, next: string) => {
+    const directory = path.join(previous, next);
+    directoryArray.push(directory);
+    return path.join(directory);
+  });
+  return directoryArray;
+}
+
+function mkdirRecursive(filePath: string) {
+  const directoryArray = parsePath(filePath);
+  return directoryArray
+    .map(directory => {
+      return () =>
+        new Promise((res, rej) => {
+          fs.mkdir(directory, err => {
+            if (err && err.code !== "EEXIST") {
+              rej(err);
+            } else {
+              res();
+            }
+          });
+        });
+    })
+    .reduce((promise, func) => {
+      return promise.then(
+        () => func(),
+        err => {
+          throw err;
+        },
+      );
+    }, Promise.resolve({}));
+}
+
+function mkdirRecursiveSync(filePath: string) {
+  const directoryArray = parsePath(filePath);
+  directoryArray.forEach(directory => {
+    if (!fs.existsSync(directory)) {
+      fs.mkdirSync(directory);
+    }
+  });
+}
+
+export function outputFile(filePath: string, fileContent: any) {
+  return new Promise((resolve, reject) => {
+    fs.writeFile(filePath, fileContent, err => {
+      if (err && err.code !== "ENOENT") {
+        reject(err);
+      } else {
+        mkdirRecursive(filePath)
+          .then(() => {
+            fs.writeFile(filePath, fileContent, error => {
+              if (error) {
+                reject(error);
+              } else {
+                resolve();
+              }
+            });
+          })
+          .catch(e => {
+            reject(e);
+          });
+      }
+    });
+  });
+}
+
+export function outputFileSync(filePath: string, fileContent: any) {
+  try {
+    fs.writeFileSync(filePath, fileContent);
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      throw e;
+    } else {
+      mkdirRecursiveSync(filePath);
+      fs.writeFileSync(filePath, fileContent);
+    }
+  }
+}