Merge pull request #188 from psmyrdek/types-from-url

Fetch specs from remote resources

Author: DangoDev

.eslintignore

@@ -1 +1,2 @@
 example/*.ts
+bin

README.md

@@ -4,22 +4,30 @@
 
 # 📘️ swagger-to-ts
 
-Convert [OpenAPI v2][openapi2] schemas to TypeScript interfaces using Node.js. It can handle large
-definition files within milliseconds because it neither validates nor parses; it only transforms the
-bare minimum of what it needs to.
+🚀 Convert [OpenAPI v2][openapi2] schemas to TypeScript interfaces using Node.js. 
 
-💅 Prettifies output with [Prettier][prettier].
+💅 The output is prettified with [Prettier][prettier].
+
+👉 Works for both local and remote resources (filesystem and http).
 
 To compare actual generated output, see the [example](./example) folder.
 
+(**swagger-to-ts** can handle large definition files within milliseconds because it neither validates nor parses; it only transforms the bare minimum of what it needs to.)
+
 ## Usage
 
 ### CLI
 
+#### Reading specs from file system
+
 ```bash
 npx @manifoldco/swagger-to-ts schema.yaml --output schema.d.ts
+```
+
+#### Reading specs from remote resource
 
-# 🚀 schema.yaml -> schema.d.ts [500ms]
+```bash
+npx @manifoldco/swagger-to-ts https://petstore.swagger.io/v2/swagger.json --output petstore.d.ts
 ```
 
 This will save a `schema.d.ts` file in the current folder under the TypeScript

bin/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
-const { readFileSync, existsSync, writeFileSync } = require('fs');
+const { writeFileSync } = require('fs');
 const { mkdirpSync } = require('fs-extra');
 const chalk = require('chalk');
 const { dirname, resolve } = require('path');
 const meow = require('meow');
-const yaml = require('js-yaml');
 const { default: swaggerToTS } = require('../dist-node');
+const { loadSpec } = require('./loaders');
 
 const cli = meow(
   `Usage
@@ -26,54 +26,32 @@ Options
   }
 );
 
-let spec = cli.input[0];
-
+const pathToSpec = cli.input[0];
 const timeStart = process.hrtime();
 
-// If input is a file, load it
-const pathname = resolve(process.cwd(), spec);
-if (existsSync(pathname)) {
-  spec = readFileSync(pathname, 'UTF-8');
-}
-
-// Attempt to parse YAML
-try {
-  if (/\.ya?ml$/i.test(spec) || spec[0] !== '{') {
-    spec = yaml.safeLoad(spec);
+(async () => {
+  let spec = '';
+  try {
+    spec = await loadSpec(pathToSpec);
+  } catch (e) {
+    console.error(chalk.red(`❌ "${e}"`));
   }
-} catch (e) {
-  console.error(
-    chalk.red(`❌ "${spec}" seems to be YAML, but it couldn’t be parsed.
-  ${e}`)
-  );
-}
 
-// Attempt to parse JSON
-try {
-  if (typeof spec === 'string') {
-    spec = JSON.parse(spec);
-  }
-} catch (e) {
-  console.error(
-    chalk.red(`❌ Could not parse JSON for "${spec}." Is this a valid Swagger spec?
-  ${e}`)
-  );
-}
+  const result = swaggerToTS(spec);
 
-const result = swaggerToTS(spec);
+  // Write to file if specifying output
+  if (cli.flags.output) {
+    const outputFile = resolve(process.cwd(), cli.flags.output);
+    const parent = dirname(outputFile);
+    mkdirpSync(parent);
+    writeFileSync(outputFile, result);
 
-// Write to file if specifying output
-if (cli.flags.output) {
-  const outputFile = resolve(process.cwd(), cli.flags.output);
-  const parent = dirname(outputFile);
-  mkdirpSync(parent);
-  writeFileSync(outputFile, result);
-
-  const timeEnd = process.hrtime(timeStart);
-  const time = timeEnd[0] + Math.round(timeEnd[1] / 1e6);
-  console.log(chalk.green(`🚀 ${cli.input[0]} -> ${chalk.bold(cli.flags.output)} [${time}ms]`));
-  return;
-}
+    const timeEnd = process.hrtime(timeStart);
+    const time = timeEnd[0] + Math.round(timeEnd[1] / 1e6);
+    console.log(chalk.green(`🚀 ${cli.input[0]} -> ${chalk.bold(cli.flags.output)} [${time}ms]`));
+    return;
+  }
 
-// Otherwise, return result
-return result;
+  // Otherwise, return result
+  return result;
+})();

bin/loaders/index.js

@@ -0,0 +1,38 @@
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+
+const loadFromFs = require('./loadFromFs');
+const loadFromHttp = require('./loadFromHttp');
+
+async function load(pathToSpec) {
+  let rawSpec;
+  if (/^https?:\/\//.test(pathToSpec)) {
+    rawSpec = await loadFromHttp(pathToSpec);
+  } else {
+    rawSpec = await loadFromFs(pathToSpec);
+  }
+  return rawSpec;
+}
+
+function isYamlSpec(rawSpec, pathToSpec) {
+  return /\.ya?ml$/i.test(pathToSpec) || rawSpec[0] !== '{';
+}
+
+module.exports.loadSpec = async (pathToSpec) => {
+  console.log(chalk.yellow(`🤞 Loading spec from ${chalk.bold(pathToSpec)}...`));
+  const rawSpec = await load(pathToSpec);
+
+  try {
+    if (isYamlSpec(rawSpec, pathToSpec)) {
+      return yaml.safeLoad(rawSpec);
+    }
+  } catch {
+    throw new Error(`The spec under ${pathToSpec} seems to be YAML, but it couldn’t be parsed.`);
+  }
+
+  try {
+    return JSON.parse(rawSpec);
+  } catch {
+    throw new Error(`The spec under ${pathToSpec} couldn’t be parsed neither as YAML nor JSON.`);
+  }
+};

bin/loaders/loadFromFs.js

@@ -0,0 +1,20 @@
+const { resolve } = require('path');
+const { existsSync, readFile } = require('fs');
+
+module.exports = (pathToSpec) => {
+  const pathname = resolve(process.cwd(), pathToSpec);
+  const pathExists = existsSync(pathname);
+
+  return new Promise((resolve, reject) => {
+    if (pathExists) {
+      readFile(pathname, 'UTF-8', (err, data) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(data);
+      });
+    } else {
+      reject(`Cannot find spec under the following path: ${pathname}`);
+    }
+  });
+};

bin/loaders/loadFromHttp.js

@@ -0,0 +1,38 @@
+const url = require('url');
+const adapters = {
+  'http:': require('http'),
+  'https:': require('https'),
+};
+
+function fetchFrom(inputUrl) {
+  return adapters[url.parse(inputUrl).protocol];
+}
+
+function buildOptions(pathToSpec) {
+  const requestUrl = url.parse(pathToSpec);
+  return {
+    method: 'GET',
+    hostname: requestUrl.host,
+    path: requestUrl.path,
+  };
+}
+
+module.exports = (pathToSpec) => {
+  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);
+      });
+    });
+    req.on('error', (err) => {
+      reject(err);
+    });
+    req.end();
+  });
+};