typed-openapi 1.3.2 → 1.4.1

package/dist/{chunk-YRJ7W5RY.js → chunk-7FXHZEBG.js}

@@ -4,7 +4,7 @@ import {
   generateTanstackQueryFile,
   mapOpenApiEndpoints,
   prettify
-} from "./chunk-YLPQQ24J.js";
+} from "./chunk-FM2BOVDQ.js";
 
 // src/generate-client-files.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -16,13 +16,18 @@ var now = /* @__PURE__ */ new Date();
 var optionsSchema = type({
   "output?": "string",
   runtime: allowedRuntimes,
-  tanstack: "boolean | string"
+  tanstack: "boolean | string",
+  schemasOnly: "boolean"
 });
 async function generateClientFiles(input, options) {
   const openApiDoc = await SwaggerParser.bundle(input);
   const ctx = mapOpenApiEndpoints(openApiDoc);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
-  const content = await prettify(generateFile({ ...ctx, runtime: options.runtime }));
+  const content = await prettify(generateFile({
+    ...ctx,
+    runtime: options.runtime,
+    schemasOnly: options.schemasOnly
+  }));
   const outputPath = join(
     cwd,
     options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`

package/dist/{chunk-YLPQQ24J.js → chunk-FM2BOVDQ.js}

@@ -77,7 +77,7 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
       if (schema.enum) {
         if (schema.enum.length === 1) {
           const value = schema.enum[0];
-          return t.literal(value === null ? "null" : `"${value}"`);
+          return t.literal(value === null ? "null" : value === true ? "true" : value === false ? "false" : `"${value}"`);
         }
         if (schemaType === "string") {
           return t.union(schema.enum.map((value) => t.literal(`"${value}"`)));
@@ -276,14 +276,20 @@ var methods = ["get", "put", "post", "delete", "options", "head", "patch", "trac
 var methodsRegex = new RegExp(`(?:${methods.join("|")})_`);
 var endpointExport = new RegExp(`export (?:type|const) (?:${methodsRegex.source})`);
 var replacerByRuntime = {
-  yup: (line) => line.replace(/y\.InferType<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(y\.object)(\()/).source, "g"), "$1$2("),
-  zod: (line) => line.replace(/z\.infer<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(z\.object)(\()/).source, "g"), "$1$2(")
+  yup: (line) => line.replace(/y\.InferType<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(
+    new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(y\.object)(\()/).source, "g"),
+    "$1$2("
+  ),
+  zod: (line) => line.replace(/z\.infer<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(
+    new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(z\.object)(\()/).source, "g"),
+    "$1$2("
+  )
 };
 var generateFile = (options) => {
   const ctx = { ...options, runtime: options.runtime ?? "none" };
   const schemaList = generateSchemaList(ctx);
-  const endpointSchemaList = generateEndpointSchemaList(ctx);
-  const apiClient = generateApiClient(ctx);
+  const endpointSchemaList = options.schemasOnly ? "" : generateEndpointSchemaList(ctx);
+  const apiClient = options.schemasOnly ? "" : generateApiClient(ctx);
   const transform = ctx.runtime === "none" ? (file2) => file2 : (file2) => {
     const model = Codegen.TypeScriptToModel.Generate(file2);
     const transformer = runtimeValidationGenerator[ctx.runtime];
@@ -327,7 +333,7 @@ var parameterObjectToString = (parameters) => {
   if (parameters instanceof Box) return parameters.value;
   let str = "{";
   for (const [key, box] of Object.entries(parameters)) {
-    str += `${wrapWithQuotesIfNeeded(key)}: ${box.value},
+    str += `${wrapWithQuotesIfNeeded(key)}${box.type === "optional" ? "?" : ""}: ${box.value},
 `;
   }
   return str + "}";
@@ -490,7 +496,17 @@ export class ApiClient {
     >(
       method: TMethod,
       path: TPath,
-      ...params: MaybeOptionalArg<${match(ctx.runtime).with("zod", "yup", () => inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`)).with("arktype", "io-ts", "typebox", "valibot", () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`).otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
+      ...params: MaybeOptionalArg<${match(ctx.runtime).with(
+    "zod",
+    "yup",
+    () => inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`)
+  ).with(
+    "arktype",
+    "io-ts",
+    "typebox",
+    "valibot",
+    () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`
+  ).otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
     : Promise<Omit<Response, "json"> & {
       /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
       json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;
@@ -754,12 +770,15 @@ var mapOpenApiEndpoints = (doc) => {
         },
         { query: {}, path: {}, header: {} }
       );
-      const params = Object.entries(paramObjects).reduce((acc, [key, value]) => {
-        if (Object.keys(value).length) {
-          acc[key] = value;
-        }
-        return acc;
-      }, {});
+      const params = Object.entries(paramObjects).reduce(
+        (acc, [key, value]) => {
+          if (Object.keys(value).length) {
+            acc[key] = value;
+          }
+          return acc;
+        },
+        {}
+      );
       if (operation.requestBody) {
         endpoint.meta.hasParameters = true;
         const requestBody = refs.unwrap(operation.requestBody ?? {});
@@ -907,7 +926,8 @@ var generateTanstackQueryFile = async (ctx) => {
   export class TanstackQueryApiClient {
       constructor(public client: ApiClient) { }
 
-      ${Array.from(endpointMethods).map((method) => `
+      ${Array.from(endpointMethods).map(
+    (method) => `
         // <ApiClient.${method}>
         ${method}<Path extends keyof ${capitalize4(method)}Endpoints, TEndpoint extends ${capitalize4(method)}Endpoints[Path]>(
             path: Path,
@@ -945,7 +965,8 @@ var generateTanstackQueryFile = async (ctx) => {
             return query
         }
         // </ApiClient.${method}>
-        `).join("\n")}
+        `
+  ).join("\n")}
 
         // <ApiClient.request>
         /**

package/dist/cli.js

@@ -1,9 +1,9 @@
 import {
   generateClientFiles
-} from "./chunk-YRJ7W5RY.js";
+} from "./chunk-7FXHZEBG.js";
 import {
   allowedRuntimes
-} from "./chunk-YLPQQ24J.js";
+} from "./chunk-FM2BOVDQ.js";
 
 // src/cli.ts
 import { cac } from "cac";
@@ -14,7 +14,14 @@ cli.command("<input>", "Generate").option("-o, --output <path>", "Output path fo
   "-r, --runtime <name>",
   `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
   { default: "none" }
-).option("--tanstack [name]", "Generate tanstack client, defaults to false, can optionally specify a name for the generated file").action(async (input, _options) => {
+).option(
+  "--schemas-only",
+  "Only generate schemas, skipping client generation (defaults to false)",
+  { default: false }
+).option(
+  "--tanstack [name]",
+  "Generate tanstack client, defaults to false, can optionally specify a name for the generated file"
+).action(async (input, _options) => {
   return generateClientFiles(input, _options);
 });
 cli.help();

package/dist/index.d.ts

@@ -236,6 +236,7 @@ type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
 
 type GeneratorOptions$1 = ReturnType<typeof mapOpenApiEndpoints> & {
     runtime?: "none" | keyof typeof runtimeValidationGenerator;
+    schemasOnly?: boolean;
 };
 declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   openApiSchemaToTs,
   tsFactory,
   unwrap
-} from "./chunk-YLPQQ24J.js";
+} from "./chunk-FM2BOVDQ.js";
 export {
   createBoxFactory,
   createFactory,

package/dist/node.export.d.ts

@@ -6,6 +6,7 @@ declare const prettify: (str: string, options?: Options | null) => string | Prom
 declare const optionsSchema: arktype_internal_methods_object_ts.ObjectType<{
     runtime: "none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod";
     tanstack: string | boolean;
+    schemasOnly: boolean;
     output?: string;
 }, {}>;
 declare function generateClientFiles(input: string, options: typeof optionsSchema.infer): Promise<void>;

package/dist/node.export.js

@@ -1,9 +1,9 @@
 import {
   generateClientFiles
-} from "./chunk-YRJ7W5RY.js";
+} from "./chunk-7FXHZEBG.js";
 import {
   prettify
-} from "./chunk-YLPQQ24J.js";
+} from "./chunk-FM2BOVDQ.js";
 export {
   generateClientFiles,
   prettify

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typed-openapi",
   "type": "module",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "exports": {
@@ -63,6 +63,7 @@
     "dev": "tsup --watch",
     "build": "tsup",
     "test": "vitest",
+    "fmt": "prettier --write src",
     "typecheck": "tsc -b ./tsconfig.build.json"
   }
 }

package/src/cli.ts

@@ -15,7 +15,15 @@ cli
     `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
     { default: "none" },
   )
-  .option("--tanstack [name]", "Generate tanstack client, defaults to false, can optionally specify a name for the generated file")
+  .option(
+    "--schemas-only",
+    "Only generate schemas, skipping client generation (defaults to false)",
+    { default: false },
+  )
+  .option(
+    "--tanstack [name]",
+    "Generate tanstack client, defaults to false, can optionally specify a name for the generated file",
+  )
   .action(async (input, _options) => {
     return generateClientFiles(input, _options);
   });

package/src/generate-client-files.ts

@@ -12,35 +12,40 @@ const cwd = process.cwd();
 const now = new Date();
 
 export const optionsSchema = type({
-    "output?": "string",
-    runtime: allowedRuntimes,
-    tanstack: "boolean | string"
+  "output?": "string",
+  runtime: allowedRuntimes,
+  tanstack: "boolean | string",
+  schemasOnly: "boolean",
 });
 
 export async function generateClientFiles(input: string, options: typeof optionsSchema.infer) {
-    const openApiDoc = (await SwaggerParser.bundle(input)) as OpenAPIObject;
-
-    const ctx = mapOpenApiEndpoints(openApiDoc);
-    console.log(`Found ${ctx.endpointList.length} endpoints`);
-
-    const content = await prettify(generateFile({ ...ctx, runtime: options.runtime }));
-    const outputPath = join(
-        cwd,
-        options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`,
-    );
-
-    console.log("Generating client...", outputPath);
-    await writeFile(outputPath, content);
-
-    if (options.tanstack) {
-        const tanstackContent = await generateTanstackQueryFile({
-            ...ctx,
-            relativeApiClientPath: './' + basename(outputPath),
-        });
-        const tanstackOutputPath = join(dirname(outputPath), typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
-        console.log("Generating tanstack client...", tanstackOutputPath);
-        await writeFile(tanstackOutputPath, tanstackContent);
-    }
-
-    console.log(`Done in ${new Date().getTime() - now.getTime()}ms !`);
+  const openApiDoc = (await SwaggerParser.bundle(input)) as OpenAPIObject;
+
+  const ctx = mapOpenApiEndpoints(openApiDoc);
+  console.log(`Found ${ctx.endpointList.length} endpoints`);
+
+  const content = await prettify(generateFile({
+    ...ctx,
+    runtime: options.runtime,
+    schemasOnly: options.schemasOnly,
+  }));
+  const outputPath = join(
+    cwd,
+    options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`,
+  );
+
+  console.log("Generating client...", outputPath);
+  await writeFile(outputPath, content);
+
+  if (options.tanstack) {
+    const tanstackContent = await generateTanstackQueryFile({
+      ...ctx,
+      relativeApiClientPath: './' + basename(outputPath),
+    });
+    const tanstackOutputPath = join(dirname(outputPath), typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
+    console.log("Generating tanstack client...", tanstackOutputPath);
+    await writeFile(tanstackOutputPath, tanstackContent);
+  }
+
+  console.log(`Done in ${new Date().getTime() - now.getTime()}ms !`);
 }

package/src/generator.ts

@@ -9,6 +9,7 @@ import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
 
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints> & {
   runtime?: "none" | keyof typeof runtimeValidationGenerator;
+  schemasOnly?: boolean;
 };
 type GeneratorContext = Required<GeneratorOptions>;
 
@@ -45,54 +46,60 @@ const replacerByRuntime = {
   yup: (line: string) =>
     line
       .replace(/y\.InferType<\s*?typeof (.*?)\s*?>/g, "typeof $1")
-      .replace(new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(y\.object)(\()/).source, "g"), "$1$2("),
+      .replace(
+        new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(y\.object)(\()/).source, "g"),
+        "$1$2(",
+      ),
   zod: (line: string) =>
     line
       .replace(/z\.infer<\s*?typeof (.*?)\s*?>/g, "typeof $1")
-      .replace(new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(z\.object)(\()/).source, "g"), "$1$2("),
+      .replace(
+        new RegExp(`(${endpointExport.source})` + new RegExp(/([\s\S]*? )(z\.object)(\()/).source, "g"),
+        "$1$2(",
+      ),
 };
 
 export const generateFile = (options: GeneratorOptions) => {
   const ctx = { ...options, runtime: options.runtime ?? "none" } as GeneratorContext;
 
   const schemaList = generateSchemaList(ctx);
-  const endpointSchemaList = generateEndpointSchemaList(ctx);
-  const apiClient = generateApiClient(ctx);
+  const endpointSchemaList = options.schemasOnly ? "" : generateEndpointSchemaList(ctx);
+  const apiClient = options.schemasOnly ? "" : generateApiClient(ctx);
 
   const transform =
     ctx.runtime === "none"
       ? (file: string) => file
       : (file: string) => {
-        const model = Codegen.TypeScriptToModel.Generate(file);
-        const transformer = runtimeValidationGenerator[ctx.runtime as Exclude<typeof ctx.runtime, "none">];
-        // tmp fix for typebox, there's currently a "// todo" only with Codegen.ModelToTypeBox.Generate
-        // https://github.com/sinclairzx81/typebox-codegen/blob/44d44d55932371b69f349331b1c8a60f5d760d9e/src/model/model-to-typebox.ts#L31
-        const generated = ctx.runtime === "typebox" ? Codegen.TypeScriptToTypeBox.Generate(file) : transformer(model);
-
-        let converted = "";
-        const match = generated.match(/(const __ENDPOINTS_START__ =)([\s\S]*?)(export type __ENDPOINTS_END__)/);
-        const content = match?.[2];
-
-        if (content && ctx.runtime in replacerByRuntime) {
-          const before = generated.slice(0, generated.indexOf("export type __ENDPOINTS_START"));
-          converted =
-            before +
-            replacerByRuntime[ctx.runtime as keyof typeof replacerByRuntime](
-              content.slice(content.indexOf("export")),
-            );
-        } else {
-          converted = generated;
-        }
+          const model = Codegen.TypeScriptToModel.Generate(file);
+          const transformer = runtimeValidationGenerator[ctx.runtime as Exclude<typeof ctx.runtime, "none">];
+          // tmp fix for typebox, there's currently a "// todo" only with Codegen.ModelToTypeBox.Generate
+          // https://github.com/sinclairzx81/typebox-codegen/blob/44d44d55932371b69f349331b1c8a60f5d760d9e/src/model/model-to-typebox.ts#L31
+          const generated = ctx.runtime === "typebox" ? Codegen.TypeScriptToTypeBox.Generate(file) : transformer(model);
+
+          let converted = "";
+          const match = generated.match(/(const __ENDPOINTS_START__ =)([\s\S]*?)(export type __ENDPOINTS_END__)/);
+          const content = match?.[2];
+
+          if (content && ctx.runtime in replacerByRuntime) {
+            const before = generated.slice(0, generated.indexOf("export type __ENDPOINTS_START"));
+            converted =
+              before +
+              replacerByRuntime[ctx.runtime as keyof typeof replacerByRuntime](
+                content.slice(content.indexOf("export")),
+              );
+          } else {
+            converted = generated;
+          }
 
-        return converted;
-      };
+          return converted;
+        };
 
   const file = `
   ${transform(schemaList + endpointSchemaList)}
   ${apiClient}
   `;
 
-  return (file);
+  return file;
 };
 
 const generateSchemaList = ({ refs, runtime }: GeneratorContext) => {
@@ -121,7 +128,7 @@ const parameterObjectToString = (parameters: Box<AnyBoxDef> | Record<string, Any
 
   let str = "{";
   for (const [key, box] of Object.entries(parameters)) {
-    str += `${wrapWithQuotesIfNeeded(key)}: ${box.value},\n`;
+    str += `${wrapWithQuotesIfNeeded(key)}${box.type === "optional" ? "?" : ""}: ${box.value},\n`;
   }
   return str + "}";
 };
@@ -137,36 +144,39 @@ const generateEndpointSchemaList = (ctx: GeneratorContext) => {
       method: "${endpoint.method.toUpperCase()}",
       path: "${endpoint.path}",
       requestFormat: "${endpoint.requestFormat}",
-      ${endpoint.meta.hasParameters
-        ? `parameters: {
+      ${
+        endpoint.meta.hasParameters
+          ? `parameters: {
             ${parameters.query ? `query:  ${parameterObjectToString(parameters.query)},` : ""}
         ${parameters.path ? `path:  ${parameterObjectToString(parameters.path)},` : ""}
         ${parameters.header ? `header:  ${parameterObjectToString(parameters.header)},` : ""}
-        ${parameters.body
-          ? `body:  ${parameterObjectToString(
-            ctx.runtime === "none"
-              ? parameters.body.recompute((box) => {
-                if (Box.isReference(box) && !box.params.generics) {
-                  box.value = `Schemas.${box.value}`;
-                }
-                return box;
-              })
-              : parameters.body,
-          )},`
-          : ""
+        ${
+          parameters.body
+            ? `body:  ${parameterObjectToString(
+                ctx.runtime === "none"
+                  ? parameters.body.recompute((box) => {
+                      if (Box.isReference(box) && !box.params.generics) {
+                        box.value = `Schemas.${box.value}`;
+                      }
+                      return box;
+                    })
+                  : parameters.body,
+              )},`
+            : ""
         }
           }`
-        : "parameters: never,"
+          : "parameters: never,"
       }
-      response: ${ctx.runtime === "none"
-        ? endpoint.response.recompute((box) => {
-          if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
-            box.value = `Schemas.${box.value}`;
-          }
-
-          return box;
-        }).value
-        : endpoint.response.value
+      response: ${
+        ctx.runtime === "none"
+          ? endpoint.response.recompute((box) => {
+              if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
+                box.value = `Schemas.${box.value}`;
+              }
+
+              return box;
+            }).value
+          : endpoint.response.value
       },
     }\n`;
   });
@@ -189,14 +199,14 @@ const generateEndpointByMethod = (ctx: GeneratorContext) => {
      // <EndpointByMethod>
      export ${ctx.runtime === "none" ? "type" : "const"} EndpointByMethod = {
      ${Object.entries(byMethods)
-      .map(([method, list]) => {
-        return `${method}: {
+       .map(([method, list]) => {
+         return `${method}: {
            ${list.map(
-          (endpoint) => `"${endpoint.path}": ${ctx.runtime === "none" ? "Endpoints." : ""}${endpoint.meta.alias}`,
-        )}
+             (endpoint) => `"${endpoint.path}": ${ctx.runtime === "none" ? "Endpoints." : ""}${endpoint.meta.alias}`,
+           )}
          }`;
-      })
-      .join(",\n")}
+       })
+       .join(",\n")}
      }
      ${ctx.runtime === "none" ? "" : "export type EndpointByMethod = typeof EndpointByMethod;"}
      // </EndpointByMethod>
@@ -263,7 +273,6 @@ type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [confi
 // </ApiClientTypes>
 `;
 
-
   const apiClient = `
 // <ApiClient>
 export class ApiClient {
@@ -285,22 +294,22 @@ export class ApiClient {
   }
 
   ${Object.entries(byMethods)
-      .map(([method, endpointByMethod]) => {
-        const capitalizedMethod = capitalize(method);
-        const infer = inferByRuntime[ctx.runtime];
+    .map(([method, endpointByMethod]) => {
+      const capitalizedMethod = capitalize(method);
+      const infer = inferByRuntime[ctx.runtime];
 
-        return endpointByMethod.length
-          ? `// <ApiClient.${method}>
+      return endpointByMethod.length
+        ? `// <ApiClient.${method}>
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
       ...params: MaybeOptionalArg<${match(ctx.runtime)
-            .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
-            .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-            .otherwise(() => `TEndpoint["parameters"]`)}>
+        .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
+        .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
+        .otherwise(() => `TEndpoint["parameters"]`)}>
     ): Promise<${match(ctx.runtime)
-            .with("zod", "yup", () => infer(`TEndpoint["response"]`))
-            .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`)
-            .otherwise(() => `TEndpoint["response"]`)}> {
+      .with("zod", "yup", () => infer(`TEndpoint["response"]`))
+      .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`)
+      .otherwise(() => `TEndpoint["response"]`)}> {
       return this.fetcher("${method}", this.baseUrl + path, params[0])
           .then(response => this.parseResponse(response))${match(ctx.runtime)
             .with("zod", "yup", () => `as Promise<${infer(`TEndpoint["response"]`)}>`)
@@ -309,9 +318,9 @@ export class ApiClient {
     }
     // </ApiClient.${method}>
     `
-          : "";
-      })
-      .join("\n")}
+        : "";
+    })
+    .join("\n")}
 
     // <ApiClient.request>
     /**
@@ -325,9 +334,17 @@ export class ApiClient {
       method: TMethod,
       path: TPath,
       ...params: MaybeOptionalArg<${match(ctx.runtime)
-      .with("zod", "yup", () => inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`))
-      .with("arktype", "io-ts", "typebox", "valibot", () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`)
-      .otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
+        .with("zod", "yup", () =>
+          inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`),
+        )
+        .with(
+          "arktype",
+          "io-ts",
+          "typebox",
+          "valibot",
+          () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`,
+        )
+        .otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
     : Promise<Omit<Response, "json"> & {
       /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
       json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from "./box-factory.ts";
 export { generateFile, type OutputRuntime } from "./generator.ts";
-export * from "./tanstack-query.generator.ts"
+export * from "./tanstack-query.generator.ts";
 export * from "./map-openapi-endpoints.ts";
 export * from "./openapi-schema-to-ts.ts";
 export * from "./ref-resolver.ts";

package/src/map-openapi-endpoints.ts

@@ -64,13 +64,16 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
       );
 
       // Filter out empty objects
-      const params = Object.entries(paramObjects).reduce((acc, [key, value]) => {
-        if (Object.keys(value).length) {
-          // @ts-expect-error
-          acc[key] = value;
-        }
-        return acc;
-      }, {} as { query?: Record<string, Box>; path?: Record<string, Box>; header?: Record<string, Box>; body?: Box });
+      const params = Object.entries(paramObjects).reduce(
+        (acc, [key, value]) => {
+          if (Object.keys(value).length) {
+            // @ts-expect-error
+            acc[key] = value;
+          }
+          return acc;
+        },
+        {} as { query?: Record<string, Box>; path?: Record<string, Box>; header?: Record<string, Box>; body?: Box },
+      );
 
       // Body
       if (operation.requestBody) {

package/src/node.export.ts

@@ -1,2 +1,2 @@
 export { prettify } from "./format.ts";
-export { generateClientFiles } from "./generate-client-files.ts"
+export { generateClientFiles } from "./generate-client-files.ts";

package/src/openapi-schema-to-ts.ts

@@ -65,7 +65,7 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
       if (schema.enum) {
         if (schema.enum.length === 1) {
           const value = schema.enum[0];
-          return t.literal(value === null ? "null" : `"${value}"`);
+          return t.literal(value === null ? "null" : value === true ? "true" : value === false ? "false" : `"${value}"`);
         }
 
         if (schemaType === "string") {
@@ -100,7 +100,12 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
 
     if (schemaType === "object" || schema.properties || schema.additionalProperties) {
       if (!schema.properties) {
-        if (schema.additionalProperties && !isReferenceObject(schema.additionalProperties) && typeof schema.additionalProperties !== "boolean" && schema.additionalProperties.type) {
+        if (
+          schema.additionalProperties &&
+          !isReferenceObject(schema.additionalProperties) &&
+          typeof schema.additionalProperties !== "boolean" &&
+          schema.additionalProperties.type
+        ) {
           const valueSchema = openApiSchemaToTs({ schema: schema.additionalProperties, ctx, meta });
           return t.literal(`Record<string, ${valueSchema.value}>`);
         }

package/src/ref-resolver.ts

@@ -119,7 +119,7 @@ export const createRefResolver = (doc: OpenAPIObject, factory: GenericFactory) =
   };
 };
 
-export interface RefResolver extends ReturnType<typeof createRefResolver> { }
+export interface RefResolver extends ReturnType<typeof createRefResolver> {}
 
 const setSchemaDependencies = (schema: LibSchemaObject, deps: Set<string>) => {
   const visit = (schema: LibSchemaObject | ReferenceObject): void => {

package/src/string-utils.ts

@@ -35,9 +35,8 @@ const prefixStringStartingWithNumberIfNeeded = (str: string) => {
 const pathParamWithBracketsRegex = /({\w+})/g;
 const wordPrecededByNonWordCharacter = /[^\w\-]+/g;
 
-
 /** @example turns `/media-objects/{id}` into `MediaObjectsId` */
 export const pathToVariableName = (path: string) =>
-  capitalize(kebabToCamel((path)).replaceAll("/", "_")) // /media-objects/{id} -> MediaObjects{id}
+  capitalize(kebabToCamel(path).replaceAll("/", "_")) // /media-objects/{id} -> MediaObjects{id}
     .replace(pathParamWithBracketsRegex, (group) => capitalize(group.slice(1, -1))) // {id} -> Id
     .replace(wordPrecededByNonWordCharacter, "_"); // "/robots.txt" -> "/robots_txt"

package/src/tanstack-query.generator.ts

@@ -2,13 +2,13 @@ import { capitalize } from "pastable/server";
 import { prettify } from "./format.ts";
 import type { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
 
-type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints>
+type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints>;
 type GeneratorContext = Required<GeneratorOptions>;
 
 export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relativeApiClientPath: string }) => {
-    const endpointMethods = (new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase())));
+  const endpointMethods = new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase()));
 
-    const file = `
+  const file = `
   import { queryOptions } from "@tanstack/react-query"
   import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
 
@@ -44,7 +44,9 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
   };
 
   // <EndpointByMethod.Shorthands>
-  ${Array.from(endpointMethods).map((method) => `export type ${capitalize(method)}Endpoints = EndpointByMethod["${method}"];`).join("\n")}
+  ${Array.from(endpointMethods)
+    .map((method) => `export type ${capitalize(method)}Endpoints = EndpointByMethod["${method}"];`)
+    .join("\n")}
   // </EndpointByMethod.Shorthands>
 
   // <ApiClientTypes>
@@ -67,7 +69,9 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
   export class TanstackQueryApiClient {
       constructor(public client: ApiClient) { }
 
-      ${Array.from(endpointMethods).map((method) => `
+      ${Array.from(endpointMethods)
+        .map(
+          (method) => `
         // <ApiClient.${method}>
         ${method}<Path extends keyof ${capitalize(method)}Endpoints, TEndpoint extends ${capitalize(method)}Endpoints[Path]>(
             path: Path,
@@ -105,7 +109,9 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
             return query
         }
         // </ApiClient.${method}>
-        `).join("\n")}
+        `,
+        )
+        .join("\n")}
 
         // <ApiClient.request>
         /**
@@ -139,5 +145,5 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
   }
 `;
 
-    return prettify(file);
+  return prettify(file);
 };

package/src/types.ts

@@ -4,7 +4,7 @@ import type { SchemaObject as SchemaObject3 } from "openapi3-ts/oas30";
 import type { RefResolver } from "./ref-resolver.ts";
 import { Box } from "./box.ts";
 
-export type LibSchemaObject = SchemaObject & SchemaObject3
+export type LibSchemaObject = SchemaObject & SchemaObject3;
 
 export type BoxDefinition = {
   type: string;