Absorb schema loading/parsing into Node API

Author: drwpow

README.md

@@ -121,19 +121,26 @@ npm i --save-dev openapi-typescript
 ```
 
 ```js
-const { readFileSync } = require("fs");
+const fs = require("fs");
 const openapiTS = require("openapi-typescript").default;
 
-const input = JSON.parse(readFileSync("spec.json", "utf8")); // Input can be any JS object (OpenAPI format)
-const output = openapiTS(input); // Outputs TypeScript defs as a string (to be parsed, or written to a file)
+// option 1: load JS object, write to local file
+const schema = await fs.promises.readFile("spec.json", "utf8") // must be OpenAPI JSON
+const output = await openapiTS(JSON.parse(schema));
+
+// option 2 (new in v3.3): load local path
+const localPath = path.join(__dirname, 'spec.yaml'); // may be YAML or JSON format
+const output = await openapiTS(localPath);
+
+// option 3 (new in v3.3): load remote URL
+const output = await openapiTS('https://myurl.com/v1/openapi.yaml');
 ```
 
-The Node API is a bit more flexible: it will only take a JS object as input (OpenAPI format), and return a string of TS
-definitions. This lets you pull from any source (a Swagger server, local files, etc.), and similarly lets you parse,
-post-process, and save the output anywhere.
+The Node API may be useful if dealing with dynamically-created schemas, or you’re using within context of a larger application. It
+
+⚠️ As of `v3.3`, this is an async function.
 
-If your specs are in YAML, you’ll have to convert them to JS objects using a library such as [js-yaml][js-yaml]. If
-you’re batching large folders of specs, [glob][glob] may also come in handy.
+It’s important to note that options 2 and 3 are triggered by passing in a `string` rather than an `object`.
 
 #### Custom Formatter
 

bin/cli.js

@@ -5,7 +5,6 @@ const { bold, green, red } = require("kleur");
 const path = require("path");
 const meow = require("meow");
 const { default: openapiTS } = require("../dist/cjs/index.js");
-const { loadSpec } = require("./loaders");
 
 const cli = meow(
   `Usage
@@ -51,56 +50,36 @@ async function main() {
   let output = "FILE"; // FILE or STDOUT
   const pathToSpec = cli.input[0];
 
-  // 0. setup
   if (!cli.flags.output) {
     output = "STDOUT"; // if --output not specified, fall back to stdout
   }
   if (output === "FILE") {
-    console.info(bold(`✨ openapi-typescript ${require("../package.json").version}`)); // only log if we’re NOT writing to stdout
+    console.info(bold(`✨ openapi-typescript ${require("../package.json").version}`)); // don’t log anything to console!
   }
 
-  // 1. input
-  let spec = undefined;
-  try {
-    spec = await loadSpec(pathToSpec, {
-      auth: cli.flags.auth,
-      log: output !== "STDOUT",
-    });
-  } catch (err) {
-    process.exitCode = 1; // needed for async functions
-    throw new Error(red(`❌ ${err}`));
-  }
-
-  // 2. generate schema (the main part!)
-  const result = openapiTS(spec, {
+  const result = await openapiTS(pathToSpec, {
+    auth: cli.flags.auth,
+    silent: output === "STDOUT",
     immutableTypes: cli.flags.immutableTypes,
     prettierConfig: cli.flags.prettierConfig,
     rawSchema: cli.flags.rawSchema,
     version: cli.flags.version,
   });
 
-  // 3. output
   if (output === "FILE") {
     // output option 1: file
     const outputFile = path.resolve(process.cwd(), cli.flags.output);
 
-    // recursively create parent directories if they don’t exist
-    const parentDirs = cli.flags.output.split(path.sep);
-    for (var i = 1; i < parentDirs.length; i++) {
-      const dir = path.resolve(process.cwd(), ...parentDirs.slice(0, i));
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir);
-      }
-    }
-
-    fs.writeFileSync(outputFile, result, "utf8");
+    await fs.promises.mkdir(path.dirname(outputFile), { recursive: true });
+    await fs.promises.writeFile(outputFile, result, "utf8");
 
     const timeEnd = process.hrtime(timeStart);
     const time = timeEnd[0] + Math.round(timeEnd[1] / 1e6);
     console.log(green(`🚀 ${pathToSpec} -> ${bold(cli.flags.output)} [${time}ms]`));
   } else {
     // output option 2: stdout
     process.stdout.write(result);
+    // (still) don’t log anything to console!
   }
 
   return result;

bin/loaders/index.js

@@ -54,23 +54,24 @@
     "version": "npm run build"
   },
   "dependencies": {
-    "js-yaml": "^4.0.0",
-    "kleur": "^4.1.3",
+    "js-yaml": "^4.1.0",
+    "kleur": "^4.1.4",
     "meow": "^9.0.0",
     "mime": "^2.5.2",
     "prettier": "^2.2.1"
   },
   "devDependencies": {
-    "@types/jest": "^26.0.14",
-    "@types/js-yaml": "^4.0.0",
-    "@typescript-eslint/eslint-plugin": "^4.4.1",
-    "@typescript-eslint/parser": "^4.4.1",
-    "codecov": "^3.8.1",
-    "eslint": "^7.11.0",
-    "eslint-config-prettier": "^8.1.0",
-    "eslint-plugin-prettier": "^3.1.4",
-    "jest": "^26.5.3",
-    "ts-jest": "^26.4.1",
-    "typescript": "^4.1.3"
+    "@types/jest": "^26.0.23",
+    "@types/js-yaml": "^4.0.1",
+    "@types/mime": "^2.0.3",
+    "@typescript-eslint/eslint-plugin": "^4.22.0",
+    "@typescript-eslint/parser": "^4.22.0",
+    "codecov": "^3.8.2",
+    "eslint": "^7.25.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "jest": "^26.6.3",
+    "ts-jest": "^26.5.5",
+    "typescript": "^4.2.4"
   }
 }

bin/loaders/loadFromFs.js

@@ -1,6 +1,7 @@
 import path from "path";
 import prettier from "prettier";
 import parserTypescript from "prettier/parser-typescript";
+import load from "./load";
 import { swaggerVersion } from "./utils";
 import { transformAll } from "./transform/index";
 import { OpenAPI2, OpenAPI3, SchemaObject, SwaggerToTSOptions } from "./types";
@@ -14,24 +15,27 @@ export const WARNING_MESSAGE = `/**
 
 `;
 
-export default function openapiTS(
-  schema: OpenAPI2 | OpenAPI3 | Record<string, SchemaObject>,
+export default async function openapiTS(
+  schema: string | OpenAPI2 | OpenAPI3 | Record<string, SchemaObject>,
   options?: SwaggerToTSOptions
-): string {
-  // 1. determine version
-  const version = (options && options.version) || swaggerVersion(schema as OpenAPI2 | OpenAPI3);
+): Promise<string> {
+  // 1. load schema
+  const schemaObj = await load(schema, { auth: options?.auth, silent: options?.silent || false });
 
-  // 2. generate output
+  // 2. determine version
+  const version = options?.version || swaggerVersion(schemaObj as OpenAPI2 | OpenAPI3);
+
+  // 3. generate output
   let output = `${WARNING_MESSAGE}
-  ${transformAll(schema, {
+  ${transformAll(schemaObj, {
     formatter: options && typeof options.formatter === "function" ? options.formatter : undefined,
     immutableTypes: (options && options.immutableTypes) || false,
     rawSchema: options && options.rawSchema,
     version,
   })}
 `;
 
-  // 3. Prettify output
+  // 4. Prettify output
   let prettierOptions: prettier.Options = {
     parser: "typescript",
     plugins: [parserTypescript],