Add executable

Author: drwpow

.eslintrc.js

@@ -1,5 +1,4 @@
 module.exports = {
-  parser: 'babel-eslint',
   extends: ['prettier/react', 'airbnb'],
   plugins: ['prettier', 'import'],
   env: {

README.md

@@ -1,145 +1,46 @@
 [![version (scoped)](https://img.shields.io/npm/v/@manifoldco/swagger-to-ts.svg)](https://www.npmjs.com/package/@manifoldco/swagger-to-ts)
 
-Convert Swagger files to TypeScript interfaces using Node.js. This uses
-[Prettier][prettier] to prettify the interfaces.
+# 📘️ swagger-to-ts
 
-### Installation
+Convert Swagger files to TypeScript interfaces using Node.js.
 
-```shell
-npm i --save-dev @manifoldco/swagger-to-ts
-```
-
-### Usage
-
-The function takes 2 parameters: a **filepath** to a JSON file, and a
-**namespace** for the API. Namespace is required because it’s very likely
-entities within the Swagger spec will collide with some other type in your
-system, but you still want to access something predictably-named.
-
-```js
-const swaggerToTS = require('swagger-to-ts');
-
-const filepath = './path/to/my/file.json';
-const namespace = 'MySpec';
-const typeData = swaggerToJS(filepath, namespace);
-```
-
-#### From Swagger JSON
-
-```js
-const { readFileSync, writeFileSync } = require('fs');
-const swaggerToTS = require('swagger-to-ts');
-
-const file = './spec/swagger.json';
-const typeData = swaggerToTS(readFileSync(file, 'UTF-8'), 'MySpec');
-writeFileSync('./types/swagger.ts', typeData);
-```
-
-#### From Swagger YAML
-
-Swagger files must be passed to `swaggerToTS()` in a JSON format, so you’ll
-have to configure that part yourself using [js-yaml][js-yaml] or something
-similar.
-
-```js
-const { readFileSync, writeFileSync } = require('fs');
-const yaml = require('js-yaml');
+💅 Prettifies output with [Prettier][prettier].
 
-const file = './spec/swagger.yaml';
-const json = yaml.safeLoad(fs.readFileSync(file, 'UTF-8'));
-const typeData = swaggerToTS(json, 'MySpec');
-writeFileSync('./types/swagger.ts', typeData);
-```
+## Usage
 
-#### Generating multiple files
+### CLI
 
-The [glob][glob] package is helpful in converting entire folders. The
-renaming & mapping is up to you!
+```bash
+npx @manifoldco/swagger-to-ts schema.yaml --output schema.ts --namespace OpenAPI
 
-```js
-const { readFileSync, writeFileSync } = require('fs');
-const path = require('path');
-const glob = require('glob');
-const swaggerToTS = require('swagger-to-ts');
-
-const source1 = glob.sync('./swaggerspec/v1/**/*.yaml');
-const source2 = glob.sync('./swaggerspec/v2/**/*.yaml');
-
-[...source1, ...source2].forEach(file => {
-  const basename = path.basename(file);
-  const filename = basename.replace(/\.ya?ml$/i, '.ts');
-  const json = yaml.safeLoad(readFileSync(file, 'UTF-8'));
-  const typeData = swaggerToTS(json, basename);
-  writeFileSync(path.resolve(__dirname, 'types', filename), typeData);
-});
+# 🚀 schema.yaml -> schema.ts [2ms]
 ```
 
-#### Fancy Console Messages
-
-Using the [chalk][chalk] package you can spice up the console message a little:
-
-```js
-const { readFileSync, writeFileSync } = require('fs');
-const chalk = require('chalk');
-const swaggerToTS = require('swagger-to-ts');
+This will save a `schema.ts` file in the current folder under the TypeScript
+[namespace][namespace] `OpenAPI`. The CLI can accept YAML or JSON for the
+input file.
 
-const file = './spec/swagger.json';
-
-console.log('🏗 Generating types…');
-const timeStart = process.hrtime();
-
-const typeData = swaggerToTS(readFileSync(file, 'UTF-8'), 'MySpec');
-writeFileSync('./types/swagger.ts'), typeData);
-
-const timeEnd = process.hrtime(timeStart);
-console.log(
-  chalk.green(
-    `Done generating types in ${chalk.bold(timeEnd[0] + Math.round(timeEnd[1] / 1000000))}ms`
-  )
-);
-```
+### Node
 
-This will output something like the following:
-
-```shell
-🏗 Generating types…
-Done generating types in 212ms
+```bash
+npm i --save-dev @manifoldco/swagger-to-ts
 ```
 
-### Using in TypeScript project
-
-It’s recommended to name the file `*.ts` and `import` the definitions. `*.d.ts`
-can’t be imported; they’re meant to be shipped alongside modules.
-
 ```js
-import { Swagger } from '../types/swagger';
+const swaggerToTS = require('@manifoldco/swagger-to-ts');
 
-const logIn = (user: Swagger.User) => {
-  // …
+graphqlGen(spec, [options]);
 ```
 
-TypeScript would much rather have you ship `*.d.ts` files as part of an
-existing package, but sometimes that’s not possible when it comes to Swagger
-specs. `import`-ing everything like this isn’t ideal, but it’s better than
-not using static typing at all!
+`spec` must be in JSON format. For an example of converting YAML to JSON, see
+the [generate.js](./scripts/generate.js) script.
 
-### Node Scripts
-
-Setting this up to auto-run in a Node script is ideal. For instance, if you
-ship Swagger specs as part of a node package, and you want to regenerate the
-types on `postinstall`, you can specify that in your `package.json`:
-
-```js
-  "scripts": {
-    "generate:types": "node scripts/generateTypesFromSwagger",
-    "postinstall": "npm run generate:types",
-  },
-```
+### Options
 
-In this example, `scripts/generateTypesFromSwagger` is a JS file you’ve manually
-created from one of the examples above, customized to fit your needs.
+| Name      | Default  | Description                                                |
+| :-------- | :------- | :--------------------------------------------------------- |
+| `output`  | (stdout) | Where should the output file be saved?                     |
+| `swagger` | `2`      | Which Swagger version to use. Currently only supports `2`. |
 
-[chalk]: https://www.npmjs.com/package/chalk
-[glob]: https://npmjs.com/glob
-[js-yaml]: https://npmjs.com/js-yaml
+[namespace]: https://www.typescriptlang.org/docs/handbook/namespaces.html
 [prettier]: https://npmjs.com/prettier

bin/cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+const { readFileSync, existsSync, 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 swaggerToTS = require('../dist/cjs');
+
+const cli = meow(
+  `
+Usage
+  $ swagger-to-ts [input] [options]
+
+Options
+  --namespace, -n   specify namespace to prefix types
+  --help            display this
+  --output, -o      specify output file
+  --swagger, -s     specify Swagger version (default 2)
+`,
+  {
+    flags: {
+      namespace: {
+        type: 'string',
+        alias: 'n',
+      },
+      output: {
+        type: 'string',
+        alias: 'o',
+      },
+      swagger: {
+        type: 'number',
+        alias: 's',
+      },
+    },
+  }
+);
+
+let spec = cli.input[0];
+
+// 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);
+  }
+} 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, cli.flags.namespace, cli.flags);
+
+// Write to file if specifying output
+if (cli.flags.output) {
+  const timeStart = process.hrtime();
+  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;
+}
+
+// Otherwise, return result
+return result;