fix: recursive dir creation in resolver command

if passing a path to non existing directory, it will be created

Author: tomyitav

package-lock.json

@@ -1,19 +1,18 @@
 import { AbstractCommand } from '../abstract-command'
-import * as path from 'path'
 import * as transform_ from 'graphql-json-schema'
 const transform = transform_
 import { Operation, Schema } from './resolver-types'
 import {
   functionOperationPrefix,
-  gqlMethodSuffix,
   gqlMethodSignature,
+  gqlMethodSuffix,
   keysToGenerate,
+  operationFuntionsSuffix,
   operationPrefix,
   operationSuffix,
   resolverPrefix,
   resolverSuffix,
-  subscriptionSubscribeDefinition,
-  operationFuntionsSuffix
+  subscriptionSubscribeDefinition
 } from './resolver-constants'
 import { fileExists, readFileContent, writeToFile } from '../../utils/file-operations'
 

src/commands/resolver/resolver.ts

@@ -1,13 +1,28 @@
 import * as fs from 'fs'
+import * as path from 'path'
+import * as fse from 'fs-extra'
+
+const allowedFileExtensions = ['.ts']
 
 export function writeToFile(pathToFile: string, content: string): Promise<void> {
   return new Promise((resolve, reject) => {
-    fs.writeFile(pathToFile, content, err => {
+    const pathProps = path.parse(pathToFile)
+    if (!allowedFileExtensions.includes(pathProps.ext)) {
+      reject('Illegal file extension.. only ' + allowedFileExtensions + ' extensions are allowed')
+      return
+    }
+    fse.ensureDir(pathProps.dir, err => {
       if (err) {
         reject(err)
-      } else {
-        resolve()
+        return
       }
+      fs.writeFile(pathToFile, content, err => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve()
+        }
+      })
     })
   })
 }

src/utils/file-operations.ts

@@ -1,11 +1,15 @@
 import { AbstractCommand } from '../../../src/commands/abstract-command'
 import { Resolver } from '../../../src/commands/resolver/resolver'
 import * as fs from 'fs'
+import * as fse from 'fs-extra'
 
-describe('Resolver command test', () => {
+//TODO - remove only
+describe.only('Resolver command test', () => {
   let res: AbstractCommand
   const pathToType = './test/commands/resolver/test-schema.ts'
   const pathToActualResolver = './test/output/actual/test-resolver.ts'
+  const pathToDirectoryActualResolver = './test/output/actual/non/existing/dir/test-resolver.ts'
+  const resolverDirLocation = './test/output/actual/non'
   const pathToExpectedResolver = './test/output/expected/commands/resolver/test-resolver.ts'
   const pathToNonOverridenFile =
     './test/output/expected/commands/resolver/test-not-overriden-by-resolver.ts'
@@ -18,20 +22,39 @@ describe('Resolver command test', () => {
     if (fs.existsSync(pathToActualResolver)) {
       fs.unlinkSync(pathToActualResolver)
     }
+    fs.stat(resolverDirLocation, (err, stats) => {
+      if (!err) {
+        if (stats.isDirectory()) {
+          fse.remove(resolverDirLocation, err => {
+            console.log(
+              'Could not remove resolver dir. On windows desktops, remove it manually...',
+              err
+            )
+          })
+        }
+      }
+    })
   })
 
   it('works if action returns a function', () => {
     const act = res.getAction()
     expect(act).toBeInstanceOf(Function)
   })
 
-  it('works if resolver file was generated', async () => {
+  it.only('works if resolver file was generated', async () => {
     const actFunction = res.getAction()
     await actFunction(pathToType, pathToActualResolver)
     const resolverFileExist: boolean = fs.existsSync(pathToActualResolver)
     expect(resolverFileExist).toBeTruthy()
   })
 
+  it('works if resolver file was generated in directory structure', async () => {
+    const actFunction = res.getAction()
+    await actFunction(pathToType, pathToDirectoryActualResolver)
+    const resolverFileExist: boolean = fs.existsSync(pathToDirectoryActualResolver)
+    expect(resolverFileExist).toBeTruthy()
+  })
+
   it('works if resolver file is identical to expected file', async () => {
     const actFunction = res.getAction()
     await actFunction(pathToType, pathToActualResolver)
@@ -46,6 +69,20 @@ describe('Resolver command test', () => {
     expect(actualContent).toEqual(expectedContent)
   })
 
+  // it('works if resolver file is in dir and identical to expected', async () => {
+  //   const actFunction = res.getAction()
+  //   await actFunction(pathToType, pathToDirectoryActualResolver)
+  //   const expectedContent = fs
+  //     .readFileSync(pathToExpectedResolver)
+  //     .toString()
+  //     .replace(/\s/g, '')
+  //   const actualContent = fs
+  //     .readFileSync(pathToDirectoryActualResolver)
+  //     .toString()
+  //     .replace(/\s/g, '')
+  //   expect(actualContent).toEqual(expectedContent)
+  // })
+
   it('works if resolver command does not override existing file', async () => {
     const actFunction = res.getAction()
     await actFunction(pathToType, pathToNonOverridenFile)