Convert to ESM (#846)

Also drops Node 12 support

Author: drwpow

.eslintrc.js renamed to .eslintrc.cjs

@@ -13,7 +13,7 @@ jobs:
   test:
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [14.x, 16.x, 17.x]
         os: [macos-latest, ubuntu-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
@@ -23,10 +23,3 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - run: npm ci
       - run: npm run test:coverage
-  typecheck:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-      - run: npm ci
-      - run: npm run typecheck

.github/workflows/pull_request.yml

@@ -69,7 +69,7 @@ _Thanks to [@psmyrdek](https://github.com/psmyrdek) for the remote spec feature!
 Import any top-level item from the generated spec to use it. It works best if you also alias types to save on typing:
 
 ```ts
-import { components } from './generated-schema.ts';
+import { components } from "./generated-schema.ts";
 
 type APIResponse = components["schemas"]["APIResponse"];
 ```
@@ -79,7 +79,7 @@ Because OpenAPI schemas may have invalid TypeScript characters as names, the squ
 Also note that there’s a special `operations` interface that you can import `OperationObjects` by their [operationId][openapi-operationid]:
 
 ```ts
-import { operations } from './generated-schema.ts';
+import { operations } from "./generated-schema.ts";
 
 type getUsersById = operations["getUsersById"];
 ```
@@ -93,16 +93,16 @@ _Thanks to [@gr2m](https://github.com/gr2m) for the operations feature!_
 The generated spec can also be used with [openapi-typescript-fetch](https://www.npmjs.com/package/openapi-typescript-fetch) which implements a typed fetch client for openapi-typescript.
 
 ```ts
-import { paths } from './petstore'
+import { paths } from "./petstore";
 
-import { Fetcher } from 'openapi-typescript-fetch'
+import { Fetcher } from "openapi-typescript-fetch";
 
 // declare fetcher for paths
 const fetcher = Fetcher.for<paths>()
 
 // global configuration
 fetcher.configure({
-  baseUrl: 'https://petstore.swagger.io/v2',
+  baseUrl: "https://petstore.swagger.io/v2",
   init: {
     headers: {
       ...
@@ -112,19 +112,19 @@ fetcher.configure({
 })
 
 // create fetch operations
-const findPetsByStatus = fetcher.path('/pet/findByStatus').method('get').create()
-const addPet = fetcher.path('/pet').method('post').create()
+const findPetsByStatus = fetcher.path("/pet/findByStatus").method("get").create()
+const addPet = fetcher.path("/pet").method("post").create()
 
 // fetch
 try {
   const { status, data: pets } = await findPetsByStatus({
-    status: ['available', 'pending'],
+    status: ["available", "pending"],
   })
   await addPet({ ... })
 } catch(e) {
   // check which operation threw the exception
   if (e instanceof addPet.Error) {
-    // get discriminated union { status, data } 
+    // get discriminated union { status, data }
     const error = e.getActualType()
     if (error.status === 400) {
       error.data.validationErrors // 400 response data
@@ -167,19 +167,19 @@ npm i --save-dev openapi-typescript
 ```
 
 ```js
-const fs = require("fs");
-const openapiTS = require("openapi-typescript").default;
+import fs from "fs";
+import openapiTS from "openapi-typescript";
 
 // example 1: load [object] as schema (JSON only)
 const schema = await fs.promises.readFile("spec.json", "utf8") // must be OpenAPI JSON
 const output = await openapiTS(JSON.parse(schema));
 
 // example 2: load [string] as local file (YAML or JSON; released in v4.0)
-const localPath = path.join(__dirname, 'spec.yaml'); // may be YAML or JSON format
+const localPath = new URL("./spec.yaml", import.meta.url); // may be YAML or JSON format
 const output = await openapiTS(localPath);
 
 // example 3: load [string] as remote URL (YAML or JSON; released in v4.0)
-const output = await openapiTS('https://myurl.com/v1/openapi.yaml');
+const output = await openapiTS("https://myurl.com/v1/openapi.yaml");
 ```
 
 The Node API may be useful if dealing with dynamically-created schemas, or you’re using within context of a larger application. Pass in either a JSON-friendly object to load a schema from memory, or a string to load a schema from a local file or remote URL (it will load the file quickly using built-in Node methods). Note that a YAML string isn’t supported in the Node.js API; either use the CLI or convert to JSON using [js-yaml][js-yaml] first.
@@ -204,7 +204,7 @@ By default, this will generate a type `updated_at?: string;`. But we can overrid
 ```js
 const types = openapiTS(mySchema, {
   formatter(node: SchemaObject) {
-    if (node.format === 'date-time') {
+    if (node.format === "date-time") {
       return "Date"; // return the TypeScript “Date” type, as a string
     }
   // for all other schema objects, let openapi-typescript decide (return undefined)

README.md

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const { bold, green, red } = require("kleur");
-const meow = require("meow");
-const path = require("path");
-const glob = require("tiny-glob");
-const { default: openapiTS } = require("../dist/cjs/index.js");
-
-const cli = meow(
-  `Usage
+import fs from "fs";
+import path from "path";
+import glob from "tiny-glob";
+import parser from "yargs-parser";
+import openapiTS from "../dist/esm/index.js";
+
+const GREEN = "\u001b[32m";
+const BOLD = "\u001b[1m";
+const RESET = "\u001b[0m";
+
+const HELP = `Usage
   $ openapi-typescript [input] [options]
 
 Options
@@ -24,54 +26,7 @@ Options
   --prettier-config, -c        (optional) specify path to Prettier config file
   --raw-schema                 (optional) Parse as partial schema (raw components)
   --version                    (optional) Force schema parsing version
-`,
-  {
-    flags: {
-      output: {
-        type: "string",
-        alias: "o",
-      },
-      auth: {
-        type: "string",
-      },
-      headersObject: {
-        type: "string",
-        alias: "h",
-      },
-      header: {
-        type: "string",
-        alias: "x",
-        isMultiple: true,
-      },
-      httpMethod: {
-        type: "string",
-        alias: "m",
-        default: "GET",
-      },
-      immutableTypes: {
-        type: "boolean",
-        alias: "it",
-      },
-      defaultNonNullable: {
-        type: "boolean",
-      },
-      additionalProperties: {
-        type: "boolean",
-        alias: "ap",
-      },
-      prettierConfig: {
-        type: "string",
-        alias: "c",
-      },
-      rawSchema: {
-        type: "boolean",
-      },
-      version: {
-        type: "number",
-      },
-    },
-  }
-);
+`;
 
 const OUTPUT_FILE = "FILE";
 const OUTPUT_STDOUT = "STDOUT";
@@ -80,21 +35,42 @@ const timeStart = process.hrtime();
 
 function errorAndExit(errorMessage) {
   process.exitCode = 1; // needed for async functions
-  throw new Error(red(errorMessage));
+  throw new Error(errorMessage);
 }
 
+const [, , input, ...args] = process.argv;
+const flags = parser(args, {
+  array: ["header"],
+  boolean: ["defaultNonNullable", "immutableTypes", "rawSchema"],
+  number: ["version"],
+  string: ["auth", "header", "headersObject", "httpMethod", "prettierConfig"],
+  alias: {
+    additionalProperties: ["ap"],
+    header: ["x"],
+    headersObject: ["h"],
+    httpMethod: ["m"],
+    immutableTypes: ["it"],
+    output: ["o"],
+    prettierConfig: ["c"],
+  },
+  default: {
+    httpMethod: "GET",
+  },
+});
+
 async function generateSchema(pathToSpec) {
-  const output = cli.flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOUT
+  const output = flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOUT
 
   // Parse incoming headers from CLI flags
   let httpHeaders = {};
+
   // prefer --headersObject if specified
-  if (cli.flags.headersObject) {
-    httpHeaders = JSON.parse(cli.flags.headersObject); // note: this will generate a recognizable error for the user to act on
+  if (flags.headersObject) {
+    httpHeaders = JSON.parse(flags.headersObject); // note: this will generate a recognizable error for the user to act on
   }
   // otherwise, parse --header
-  else if (Array.isArray(cli.flags.header)) {
-    cli.flags.header.forEach((header) => {
+  else if (Array.isArray(flags.header)) {
+    flags.header.forEach((header) => {
       const firstColon = header.indexOf(":");
       const k = header.substring(0, firstColon).trim();
       const v = header.substring(firstColon + 1).trim();
@@ -104,21 +80,21 @@ async function generateSchema(pathToSpec) {
 
   // generate schema
   const result = await openapiTS(pathToSpec, {
-    additionalProperties: cli.flags.additionalProperties,
-    auth: cli.flags.auth,
-    defaultNonNullable: cli.flags.defaultNonNullable,
-    immutableTypes: cli.flags.immutableTypes,
-    prettierConfig: cli.flags.prettierConfig,
-    rawSchema: cli.flags.rawSchema,
+    additionalProperties: flags.additionalProperties,
+    auth: flags.auth,
+    defaultNonNullable: flags.defaultNonNullable,
+    immutableTypes: flags.immutableTypes,
+    prettierConfig: flags.prettierConfig,
+    rawSchema: flags.rawSchema,
     silent: output === OUTPUT_STDOUT,
-    version: cli.flags.version,
+    version: flags.version,
     httpHeaders,
-    httpMethod: cli.flags.httpMethod,
+    httpMethod: flags.httpMethod,
   });
 
   // output
   if (output === OUTPUT_FILE) {
-    let outputFilePath = path.resolve(process.cwd(), cli.flags.output); // note: may be directory
+    let outputFilePath = path.resolve(process.cwd(), flags.output); // note: may be directory
     const isDir = fs.existsSync(outputFilePath) && fs.lstatSync(outputFilePath).isDirectory();
     if (isDir) {
       const filename = pathToSpec.replace(new RegExp(`${path.extname(pathToSpec)}$`), ".ts");
@@ -129,7 +105,7 @@ async function generateSchema(pathToSpec) {
 
     const timeEnd = process.hrtime(timeStart);
     const time = timeEnd[0] + Math.round(timeEnd[1] / 1e6);
-    console.log(green(`🚀 ${pathToSpec} -> ${bold(outputFilePath)} [${time}ms]`));
+    console.log(`🚀 ${GREEN}${pathToSpec} -> ${BOLD}${outputFilePath}${RESET}${GREEN} [${time}ms]${RESET}`);
   } else {
     process.stdout.write(result);
     // if stdout, (still) don’t log anything to console!
@@ -139,21 +115,27 @@ async function generateSchema(pathToSpec) {
 }
 
 async function main() {
-  let output = cli.flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOUT
-  const pathToSpec = cli.input[0];
+  if (flags.help) {
+    console.info(HELP);
+    process.exit(0);
+  }
+
+  let output = flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOUT
+  const pathToSpec = input;
 
   if (output === OUTPUT_FILE) {
-    console.info(bold(`✨ openapi-typescript ${require("../package.json").version}`)); // only log if we’re NOT writing to stdout
+    const packageJSON = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    console.info(`✨ ${BOLD}openapi-typescript ${packageJSON.version}${RESET}`); // only log if we’re NOT writing to stdout
   }
 
   // error: --raw-schema
-  if (cli.flags.rawSchema && !cli.flags.version) {
+  if (flags.rawSchema && !flags.version) {
     throw new Error(`--raw-schema requires --version flag`);
   }
 
   // handle remote schema, exit
   if (/^https?:\/\//.test(pathToSpec)) {
-    if (output !== "." && output === OUTPUT_FILE) fs.mkdirSync(path.dirname(cli.flags.output), { recursive: true });
+    if (output !== "." && output === OUTPUT_FILE) fs.mkdirSync(path.dirname(flags.output), { recursive: true });
     await generateSchema(pathToSpec);
     return;
   }
@@ -168,15 +150,15 @@ async function main() {
   }
 
   // error: tried to glob output to single file
-  if (isGlob && output === OUTPUT_FILE && fs.existsSync(cli.flags.output) && fs.lstatSync(cli.flags.output).isFile()) {
-    errorAndExit(`❌ Expected directory for --output if using glob patterns. Received "${cli.flags.output}".`);
+  if (isGlob && output === OUTPUT_FILE && fs.existsSync(flags.output) && fs.lstatSync(flags.output).isFile()) {
+    errorAndExit(`❌ Expected directory for --output if using glob patterns. Received "${flags.output}".`);
   }
 
   // generate schema(s) in parallel
   await Promise.all(
     inputSpecPaths.map(async (specPath) => {
-      if (cli.flags.output !== "." && output === OUTPUT_FILE) {
-        let outputDir = path.resolve(process.cwd(), cli.flags.output);
+      if (flags.output !== "." && output === OUTPUT_FILE) {
+        let outputDir = path.resolve(process.cwd(), flags.output);
         if (isGlob) {
           outputDir = path.resolve(outputDir, path.dirname(specPath)); // globs: use output dir + spec dir
         } else {