add cli directory support (using globs) (#238)

* Add directory support

* updates

* reset vscode settings

* fixes on fixes

* complete glob and dir support

* add error check

* remove ?.

* use old node friendly methods

* bump @types/node

* actually add the package.json this time

* resolve pr comments

* add pathTransform test

* fix util test

* remove return and add documentation

Author: Ethan-Arrowood

README.md

@@ -94,7 +94,7 @@ See [server demo](example) and [browser demo](https://github.com/bcherny/json-sc
 | $refOptions | object | `{}` | [$RefParser](https://github.com/BigstickCarpet/json-schema-ref-parser) Options, used when resolving `$ref`s |
 ## CLI
 
-A simple CLI utility is provided with this package.
+A CLI utility is provided with this package.
 
 ```sh
 cat foo.json | json2ts > foo.d.ts
@@ -117,6 +117,71 @@ json2ts -i foo.json -o foo.d.ts --unreachableDefinitions
 json2ts -i foo.json -o foo.d.ts --style.singleQuote --no-style.semi
 ```
 
+The CLI supports directory of definitions as well. It supports directory paths, glob patterns, and output directories.
+
+Example 1: Directory of type definitions to an output directory
+
+Input Directory
+```
+schemas /
+ | a.json
+ | b.json
+```
+
+```sh
+json2ts -i schemas/ -o types/
+```
+
+Output Directory
+```
+types /
+ | a.d.ts
+ | b.d.ts
+```
+
+Example 2: Directory to pipe out
+Input Directory
+```
+schemas /
+ | a.json
+ | b.json
+```
+
+```sh
+json2ts -i schemas/
+```
+
+Example 3: Nested input directory mapped to nested output
+Input Directory
+```
+schemas /
+  foo /
+    | a.json
+  bar /
+    | b.json
+  fuzz /
+    c.json
+    buzz /
+      d.json
+```
+
+```sh
+json2ts -i schemas/ -o types/
+```
+
+Output Directory
+```
+types /
+  foo /
+    | a.d.ts
+  bar /
+    | b.d.ts
+  fuzz /
+    c.d.ts
+    buzz /
+      d.d.ts
+```
+
 ## Tests
 
 `npm test`

package.json

@@ -45,23 +45,29 @@
   },
   "homepage": "https://github.com/bcherny/json-schema-to-typescript#readme",
   "dependencies": {
+    "@types/is-glob": "^4.0.1",
     "@types/json-schema": "^7.0.3",
-    "@types/node": ">=4.5.0",
+    "@types/mkdirp": "^0.5.2",
     "@types/prettier": "^1.16.1",
     "cli-color": "^1.4.0",
+    "glob": "^7.1.4",
+    "is-glob": "^4.0.1",
     "json-schema-ref-parser": "^6.1.0",
     "json-stringify-safe": "^5.0.1",
     "lodash": "^4.17.11",
     "minimist": "^1.2.0",
+    "mkdirp": "^0.5.1",
     "mz": "^2.7.0",
     "prettier": "^1.19.1",
     "stdin": "0.0.1"
   },
   "devDependencies": {
     "@types/cli-color": "^0.3.29",
+    "@types/glob": "^7.1.1",
     "@types/lodash": "^4.14.121",
     "@types/minimist": "^1.2.0",
     "@types/mz": "0.0.32",
+    "@types/node": "^12.12.29",
     "@typescript-eslint/eslint-plugin": "^2.9.0",
     "@typescript-eslint/parser": "^2.9.0",
     "ava": "^1.2.1",

src/cli.ts

@@ -1,12 +1,27 @@
 #!/usr/bin/env node
 
 import {whiteBright} from 'cli-color'
-import {JSONSchema4} from 'json-schema'
 import minimist = require('minimist')
-import {readFile, writeFile} from 'mz/fs'
-import {resolve} from 'path'
+import {readFile, writeFile, existsSync, lstatSync, readdirSync} from 'mz/fs'
+import * as _mkdirp from 'mkdirp'
+import * as _glob from 'glob'
+import isGlob = require('is-glob')
+import {promisify} from 'util'
+import {join, resolve, dirname, basename} from 'path'
 import stdin = require('stdin')
 import {compile, Options} from './index'
+import {pathTransform} from './utils'
+
+// Promisify mkdirp & glob
+const mkdirp = (path: string): Promise<_mkdirp.Made> =>
+  new Promise((res, rej) => {
+    _mkdirp(path, (err, made) => {
+      if (err) rej(err)
+      else res(made === null ? undefined : made)
+    })
+  })
+
+const glob = promisify(_glob)
 
 main(
   minimist(process.argv.slice(2), {
@@ -25,35 +40,103 @@ async function main(argv: minimist.ParsedArgs) {
   }
 
   const argIn: string = argv._[0] || argv.input
-  const argOut: string = argv._[1] || argv.output
+  const argOut: string | undefined = argv._[1] || argv.output // the output can be omitted so this can be undefined
+
+  const ISGLOB = isGlob(argIn)
+  const ISDIR = isDir(argIn)
+
+  if ((ISGLOB || ISDIR) && argOut && argOut.includes('.d.ts')) {
+    throw new ReferenceError(
+      `You have specified a single file ${argOut} output for a multi file input ${argIn}. This feature is not yet supported, refer to issue #272 (https://github.com/bcherny/json-schema-to-typescript/issues/272)`
+    )
+  }
 
   try {
-    const schema: JSONSchema4 = JSON.parse(await readInput(argIn))
-    const ts = await compile(schema, argIn, argv as Partial<Options>)
-    await writeOutput(ts, argOut)
+    // Process input as either glob, directory, or single file
+    if (ISGLOB) {
+      await processGlob(argIn, argOut, argv as Partial<Options>)
+    } else if (ISDIR) {
+      await processDir(argIn, argOut, argv as Partial<Options>)
+    } else {
+      await processFile(argIn, argOut, argv as Partial<Options>)
+    }
   } catch (e) {
     console.error(whiteBright.bgRedBright('error'), e)
     process.exit(1)
   }
 }
 
-function readInput(argIn?: string) {
-  if (!argIn) {
-    return new Promise(stdin)
+// check if path is an existing directory
+function isDir(path: string): boolean {
+  return existsSync(path) && lstatSync(path).isDirectory()
+}
+
+async function processGlob(argIn: string, argOut: string | undefined, argv: Partial<Options>) {
+  const files = await glob(argIn) // execute glob pattern match
+
+  if (files.length === 0) {
+    throw ReferenceError(
+      `You passed a glob pattern "${argIn}", but there are no files that match that pattern in ${process.cwd()}`
+    )
   }
-  return readFile(resolve(process.cwd(), argIn), 'utf-8')
+  // create output directory if it does not exist
+  if (argOut && !existsSync(argOut)) {
+    await mkdirp(argOut)
+  }
+
+  Promise.all(
+    files.map(file => {
+      const outPath = argOut && `${argOut}/${basename(file, '.json')}.d.ts`
+      processFile(file, outPath, argv)
+    })
+  )
 }
 
-function writeOutput(ts: string, argOut: string): Promise<void> {
+async function processDir(argIn: string, argOut: string | undefined, argv: Partial<Options>) {
+  const files = getPaths(argIn)
+
+  Promise.all(
+    files.map(file => {
+      if (!argOut) {
+        processFile(file, argOut, argv)
+      } else {
+        let outPath = pathTransform(argOut, file)
+        if (!isDir(dirname(outPath))) {
+          _mkdirp.sync(dirname(outPath))
+        }
+        outPath = outPath.replace('.json', '.d.ts')
+        processFile(file, outPath, argv)
+      }
+    })
+  )
+}
+
+async function processFile(argIn: string, argOut: string | undefined, argv: Partial<Options>): Promise<void> {
+  const schema = JSON.parse(await readInput(argIn))
+  const ts = await compile(schema, argIn, argv)
+
   if (!argOut) {
-    try {
-      process.stdout.write(ts)
-      return Promise.resolve()
-    } catch (err) {
-      return Promise.reject(err)
-    }
+    process.stdout.write(ts)
+  } else {
+    return await writeFile(argOut, ts)
+  }
+}
+
+function getPaths(path: string, paths: string[] = []) {
+  if (existsSync(path) && lstatSync(path).isDirectory()) {
+    readdirSync(resolve(path)).forEach(item => getPaths(join(path, item), paths))
+  } else {
+    paths.push(path)
   }
-  return writeFile(argOut, ts)
+
+  return paths
+}
+
+function readInput(argIn?: string) {
+  if (!argIn) {
+    return new Promise(stdin)
+  }
+  return readFile(resolve(process.cwd(), argIn), 'utf-8')
 }
 
 function printHelp() {

src/utils.ts

@@ -1,6 +1,6 @@
 import {whiteBright} from 'cli-color'
 import {deburr, isPlainObject, mapValues, trim, upperFirst} from 'lodash'
-import {basename, extname} from 'path'
+import {basename, extname, join} from 'path'
 import {JSONSchema} from './types/JSONSchema'
 
 // TODO: pull out into a separate package
@@ -221,3 +221,26 @@ export function escapeBlockComment(schema: JSONSchema) {
     }
   }
 }
+
+/*
+the following logic determines the out path by comparing the in path to the users specified out path.
+For example, if input directory MultiSchema looks like:
+  MultiSchema/foo/a.json
+  MultiSchema/bar/fuzz/c.json
+  MultiSchema/bar/d.json
+And the user wants the outputs to be in MultiSchema/Out, then this code will be able to map the inner directories foo, bar, and fuzz into the intended Out directory like so:
+  MultiSchema/Out/foo/a.json
+  MultiSchema/Out/bar/fuzz/c.json
+  MultiSchema/Out/bar/d.json
+*/
+export function pathTransform(o: string, i: string): string {
+  const outPathList = o.split('/')
+  const inPathList = i.split('/')
+
+  const intersection = outPathList.filter(x => inPathList.includes(x))
+  const symmetricDifference = outPathList
+    .filter(x => !inPathList.includes(x))
+    .concat(inPathList.filter(x => !outPathList.includes(x)))
+
+  return join(...intersection, ...symmetricDifference)
+}