Improve remote specs (#508)

* Improve remote schema error message

#505, #507

* Add --auth flag

Author: drwpow

README.md

@@ -109,6 +109,7 @@ For anything more complicated, or for generating specs dynamically, you can also
 | Option                         | Alias | Default  | Description                                                      |
 | :----------------------------- | :---- | :------: | :--------------------------------------------------------------- |
 | `--output [location]`          | `-o`  | (stdout) | Where should the output file be saved?                           |
+| `--auth [token]`               |       |          | (optional) Provide an auth token to be passed along in the request (only if accessing a private schema). |
 | `--prettier-config [location]` |       |          | (optional) Path to your custom Prettier configuration for output |
 | `--raw-schema`                 |       | `false`  | Generate TS types from partial schema (e.g. having `components.schema` at the top level) |
 

bin/cli.js

@@ -13,7 +13,8 @@ const cli = meow(
 
 Options
   --help                display this
-  --output, -o          (optional) specify output file (default: stdout)
+  --output, -o          Specify output file (default: stdout)
+  --auth                (optional) Provide an authentication token for private URL
   --prettier-config     (optional) specify path to Prettier config file
   --raw-schema          (optional) Read from raw schema instead of document
   --version             (optional) Schema version (must be present for raw schemas)
@@ -24,6 +25,9 @@ Options
         type: "string",
         alias: "o",
       },
+      auth: {
+        type: "string",
+      },
       prettierConfig: {
         type: "string",
       },
@@ -54,7 +58,10 @@ async function main() {
   // 1. input
   let spec = undefined;
   try {
-    spec = await loadSpec(pathToSpec, { log: output !== "STDOUT" });
+    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}`));

bin/loaders/index.js

@@ -1,14 +1,15 @@
+const mime = require("mime");
 const yaml = require("js-yaml");
 const { bold, yellow } = require("kleur");
 
 const loadFromFs = require("./loadFromFs");
 const loadFromHttp = require("./loadFromHttp");
 
-async function load(pathToSpec) {
+async function load(pathToSpec, { auth }) {
   // option 1: remote URL
   if (/^https?:\/\//.test(pathToSpec)) {
     try {
-      const rawSpec = await loadFromHttp(pathToSpec);
+      const rawSpec = await loadFromHttp(pathToSpec, { auth });
       return rawSpec;
     } catch (e) {
       if (e.code === "ENOTFOUND") {
@@ -24,33 +25,32 @@ async function load(pathToSpec) {
   return loadFromFs(pathToSpec);
 }
 
-function isYamlSpec(rawSpec, pathToSpec) {
-  return /\.ya?ml$/i.test(pathToSpec) || rawSpec[0] !== "{";
-}
-
-module.exports.loadSpec = async (pathToSpec, { log = true }) => {
+async function loadSpec(pathToSpec, { auth, log = true }) {
   if (log === true) {
     console.log(yellow(`🤞 Loading spec from ${bold(pathToSpec)}…`)); // only log if not writing to stdout
   }
-  const rawSpec = await load(pathToSpec);
 
-  try {
-    if (isYamlSpec(rawSpec, pathToSpec)) {
-      return yaml.load(rawSpec);
-    }
-  } catch (err) {
-    let message = `The spec under ${pathToSpec} seems to be YAML, but it couldn’t be parsed.`;
+  const rawSpec = await load(pathToSpec, { auth });
 
-    if (err.message) {
-      message += `\n${err.message}`;
+  switch (mime.getType(pathToSpec)) {
+    case "text/yaml": {
+      try {
+        return yaml.load(rawSpec);
+      } catch (err) {
+        throw new Error(`YAML: ${err.toString()}`);
+      }
+    }
+    case "application/json":
+    case "application/json5": {
+      try {
+        return JSON.parse(rawSpec);
+      } catch (err) {
+        throw new Error(`JSON: ${err.toString()}`);
+      }
+    }
+    default: {
+      throw new Error(`Unknown format: "${contentType}". Only YAML or JSON supported.`);
     }
-
-    throw new Error(message);
-  }
-
-  try {
-    return JSON.parse(rawSpec);
-  } catch {
-    throw new Error(`The spec under ${pathToSpec} couldn’t be parsed neither as YAML nor JSON.`);
   }
-};
+}
+exports.loadSpec = loadSpec;

bin/loaders/loadFromFs.js

@@ -1,7 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 
-module.exports = (pathToSpec) => {
+function loadFromFs(pathToSpec) {
   const pathname = path.resolve(process.cwd(), pathToSpec);
   const pathExists = fs.existsSync(pathname);
 
@@ -10,4 +10,5 @@ module.exports = (pathToSpec) => {
   }
 
   return fs.readFileSync(pathname, "utf8");
-};
+}
+module.exports = loadFromFs;

bin/loaders/loadFromHttp.js

@@ -1,39 +1,39 @@
 const url = require("url");
-const adapters = {
-  "http:": require("http"),
-  "https:": require("https"),
-};
 
-function fetchFrom(inputUrl) {
-  return adapters[url.parse(inputUrl).protocol];
-}
+function loadFromHttp(pathToSpec, { auth }) {
+  const { protocol } = url.parse(pathToSpec);
 
-function buildOptions(pathToSpec) {
-  const requestUrl = url.parse(pathToSpec);
-  return {
-    method: "GET",
-    hostname: requestUrl.hostname,
-    port: requestUrl.port,
-    path: requestUrl.path,
-  };
-}
+  if (protocol !== "http:" && protocol !== "https:") {
+    throw new Error(`Unsupported protocol: "${protocol}". URL must start with "http://" or "https://".`);
+  }
 
-module.exports = (pathToSpec) => {
+  const fetch = require(protocol === "https:" ? "https" : "http");
   return new Promise((resolve, reject) => {
-    const opts = buildOptions(pathToSpec);
-    const req = fetchFrom(pathToSpec).request(opts, (res) => {
-      let rawData = "";
-      res.setEncoding("utf8");
-      res.on("data", (chunk) => {
-        rawData += chunk;
-      });
-      res.on("end", () => {
-        resolve(rawData);
-      });
-    });
+    const req = fetch.request(
+      pathToSpec,
+      {
+        method: "GET",
+        auth,
+      },
+      (res) => {
+        let rawData = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(rawData);
+          } else {
+            reject(rawData || `${res.statusCode} ${res.statusMessage}`);
+          }
+        });
+      }
+    );
     req.on("error", (err) => {
       reject(err);
     });
     req.end();
   });
-};
+}
+module.exports = loadFromHttp;