Get CLI running

Author: drwpow

docs/src/content/docs/advanced.md

@@ -88,7 +88,9 @@ const BASE_URL = "https://myapi.com/v1";
 // End Settings
 
 // type helpers — ignore these; these just make TS lookups better
-type FilterKeys<Obj, Matchers> = { [K in keyof Obj]: K extends Matchers ? Obj[K] : never }[keyof Obj];
+type FilterKeys<Obj, Matchers> = {
+  [K in keyof Obj]: K extends Matchers ? Obj[K] : never;
+}[keyof Obj];
 type PathResponses<T> = T extends { responses: any } ? T["responses"] : unknown;
 type OperationContent<T> = T extends { content: any } ? T["content"] : unknown;
 type MediaType = `${string}/${string}`;
@@ -107,26 +109,39 @@ type MockedResponse<T, Status extends keyof T = keyof T> = FilterKeys<
  */
 export function mockResponses(responses: {
   [Path in keyof Partial<paths>]: {
-    [Method in keyof Partial<paths[Path]>]: MockedResponse<PathResponses<paths[Path][Method]>>;
+    [Method in keyof Partial<paths[Path]>]: MockedResponse<
+      PathResponses<paths[Path][Method]>
+    >;
   };
 }) {
   fetchMock.mockResponse((req) => {
-    const mockedPath = findPath(req.url.replace(BASE_URL, ""), Object.keys(responses))!;
+    const mockedPath = findPath(
+      req.url.replace(BASE_URL, ""),
+      Object.keys(responses),
+    )!;
     // note: we get lazy with the types here, because the inference is bad anyway and this has a `void` return signature. The important bit is the parameter signature.
-    if (!mockedPath || (!responses as any)[mockedPath]) throw new Error(`No mocked response for ${req.url}`); // throw error if response not mocked (remove or modify if you’d like different behavior)
+    if (!mockedPath || (!responses as any)[mockedPath])
+      throw new Error(`No mocked response for ${req.url}`); // throw error if response not mocked (remove or modify if you’d like different behavior)
     const method = req.method.toLowerCase();
-    if (!(responses as any)[mockedPath][method]) throw new Error(`${req.method} called but not mocked on ${mockedPath}`); // likewise throw error if other parts of response aren’t mocked
+    if (!(responses as any)[mockedPath][method])
+      throw new Error(`${req.method} called but not mocked on ${mockedPath}`); // likewise throw error if other parts of response aren’t mocked
     if (!(responses as any)[mockedPath][method]) {
       throw new Error(`${req.method} called but not mocked on ${mockedPath}`);
     }
     const { status, body } = (responses as any)[mockedPath][method];
     return { status, body: JSON.stringify(body) };
-  })
+  });
 }
 
 // helper function that matches a realistic URL (/users/123) to an OpenAPI path (/users/{user_id}
-export function findPath(actual: string, testPaths: string[]): string | undefined {
-  const url = new URL(actual, actual.startsWith("http") ? undefined : "http://testapi.com");
+export function findPath(
+  actual: string,
+  testPaths: string[],
+): string | undefined {
+  const url = new URL(
+    actual,
+    actual.startsWith("http") ? undefined : "http://testapi.com",
+  );
   const actualParts = url.pathname.split("/");
   for (const p of testPaths) {
     let matched = true;
@@ -149,7 +164,9 @@ export function findPath(actual: string, testPaths: string[]): string | undefine
 ```ts
 export function mockResponses(responses: {
   [Path in keyof Partial<paths>]: {
-    [Method in keyof Partial<paths[Path]>]: MockedResponse<PathResponses<paths[Path][Method]>>;
+    [Method in keyof Partial<paths[Path]>]: MockedResponse<
+      PathResponses<paths[Path][Method]>
+    >;
   };
 });
 ```
@@ -158,6 +175,18 @@ export function mockResponses(responses: {
 
 Now, whenever your schema updates, **all your mock data will be typechecked correctly** 🎉. This is a huge step in ensuring resilient, accurate tests.
 
+## Debugging
+
+To enable debugging, set `DEBUG=openapi-ts:*` as an env var like so:
+
+```sh
+$ DEBUG=openapi-ts:* npx openapi-typescript schema.yaml -o my-types.ts
+```
+
+To only see certain types of debug messages, you can set `DEBUG=openapi-ts:[scope]` instead. Valid scopes are `redoc`, `lint`, `bundle`, and `ts`.
+
+Note that debug messages will be suppressed if using the CLI and outputting via `stdout`.
+
 ## Tips
 
 In no particular order, here are a few best practices to make life easier when working with OpenAPI-derived types.

packages/openapi-typescript/bin/cli.js

@@ -3,10 +3,17 @@
 import { loadConfig } from "@redocly/openapi-core";
 import glob from "fast-glob";
 import fs from "node:fs";
-import path from "node:path";
+import { fileURLToPath } from "node:url";
 import parser from "yargs-parser";
-import openapiTS, { astToString, COMMENT_HEADER } from "../dist/index.js";
-import { c, error } from "../dist/utils.js";
+import openapiTS, {
+  astToString,
+  c,
+  COMMENT_HEADER,
+  error,
+  formatTime,
+} from "../dist/index.js";
+
+/* eslint-disable no-console */
 
 const HELP = `Usage
   $ openapi-typescript [input] [options]
@@ -34,7 +41,7 @@ const CWD = new URL(`file://${process.cwd()}/`);
 const EXT_RE = /\.[^.]+$/i;
 const HTTP_RE = /^https?:\/\//;
 
-const timeStart = process.hrtime();
+const timeStart = performance.now();
 
 const [, , ...args] = process.argv;
 if (args.includes("-ap")) {
@@ -76,14 +83,14 @@ const flags = parser(args, {
   },
 });
 
-async function generateSchema(pathToSpec) {
+async function generateSchema(url) {
   const output = flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOUT
 
-  const redoclyConfig = await loadConfig(flags.redoc);
+  const redoclyConfig = flags.redoc ? await loadConfig(flags.redoc) : undefined;
 
   // generate schema
   const result = `${COMMENT_HEADER}${astToString(
-    await openapiTS(pathToSpec, {
+    await openapiTS(url, {
       additionalProperties: flags.additionalProperties,
       alphabetize: flags.alphabetize,
       contentNever: flags.contentNever,
@@ -110,7 +117,7 @@ async function generateSchema(pathToSpec) {
       if (typeof flags.output === "string" && !flags.output.endsWith("/")) {
         outputFilePath = new URL(`${flags.output}/`, CWD);
       }
-      const filename = pathToSpec.replace(EXT_RE, ".ts");
+      const filename = fileURLToPath(url).replace(EXT_RE, ".ts");
       const originalOutputFilePath = outputFilePath;
       outputFilePath = new URL(filename, originalOutputFilePath);
       if (outputFilePath.protocol !== "file:") {
@@ -123,12 +130,10 @@ async function generateSchema(pathToSpec) {
 
     fs.writeFileSync(outputFilePath, result, "utf8");
 
-    const timeEnd = process.hrtime(timeStart);
-    const time = timeEnd[0] + Math.round(timeEnd[1] / 1e6);
     console.log(
-      `🚀 ${c.green(`${pathToSpec} → ${c.bold(outputFilePath)}`)} ${c.dim(
-        `[${time}ms]`,
-      )}`,
+      `🚀 ${c.green(
+        `${fileURLToPath(url)} → ${c.bold(fileURLToPath(outputFilePath))}`,
+      )} ${c.dim(`[${formatTime(performance.now() - timeStart)}]`)}`,
     );
   } else {
     process.stdout.write(result);
@@ -175,7 +180,7 @@ async function main() {
     if (output !== "." && output === OUTPUT_FILE) {
       fs.mkdirSync(outputDir, { recursive: true });
     }
-    await generateSchema(pathToSpec);
+    await generateSchema(new URL(pathToSpec));
     return;
   }
 
@@ -204,16 +209,15 @@ async function main() {
   // generate schema(s) in parallel
   await Promise.all(
     inputSpecPaths.map(async (specPath) => {
+      const globInputFile = new URL(specPath, CWD);
       if (flags.output !== "." && output === OUTPUT_FILE) {
         if (isGlob || isDirUrl) {
-          fs.mkdirSync(new URL(path.dirname(specPath), outputDir), {
-            recursive: true,
-          }); // recursively make parent dirs
+          fs.mkdirSync(outputDir, { recursive: true }); // recursively make parent dirs
         } else {
           fs.mkdirSync(outputDir, { recursive: true }); // recursively make parent dirs
         }
       }
-      await generateSchema(specPath);
+      await generateSchema(globInputFile);
     }),
   );
 }