typed-openapi 0.10.1 → 1.0.0

package/src/cli.ts

@@ -1,28 +1,32 @@
 import SwaggerParser from "@apidevtools/swagger-parser";
 import { cac } from "cac";
 import type { OpenAPIObject } from "openapi3-ts/oas31";
-import { join } from "pathe";
+import { basename, join } from "pathe";
 import { type } from "arktype";
 
 import { writeFile } from "fs/promises";
-import { name, version } from "../package.json";
-import { allowedRuntimes, generateFile } from "./generator";
-import { mapOpenApiEndpoints } from "./map-openapi-endpoints";
+import { allowedRuntimes, generateFile } from "./generator.ts";
+import { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
+import { generateTanstackQueryFile } from "./tanstack-query.generator.ts";
+import { readFileSync } from "fs";
+import { prettify } from "./format.ts";
 
+const { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cwd = process.cwd();
 const cli = cac(name);
 const now = new Date();
 
-const optionsSchema = type({ "output?": "string", runtime: allowedRuntimes });
+const optionsSchema = type({ "output?": "string", runtime: allowedRuntimes, tanstack: "boolean | string" });
 
 cli
   .command("<input>", "Generate")
   .option("-o, --output <path>", "Output path for the api client ts file (defaults to `<input>.<runtime>.ts`)")
   .option(
     "-r, --runtime <name>",
-    `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.definition}`,
+    `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) => {
     const options = optionsSchema.assert(_options);
     const openApiDoc = (await SwaggerParser.bundle(input)) as OpenAPIObject;
@@ -30,14 +34,25 @@ cli
     const ctx = mapOpenApiEndpoints(openApiDoc);
     console.log(`Found ${ctx.endpointList.length} endpoints`);
 
-    const content = generateFile({ ...ctx, runtime: options.runtime });
-    const output = join(
+    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...", output);
-    await writeFile(output, content);
+    console.log("Generating client...", outputPath);
+    await writeFile(outputPath, content);
+
+    if (options.tanstack) {
+      const tanstackContent = await generateTanstackQueryFile({
+        ...ctx,
+        relativeApiClientPath: './' + basename(outputPath),
+      });
+      const tanstackOutputPath = join(cwd, 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/format.ts

@@ -2,7 +2,7 @@ import prettier, { type Options } from "prettier";
 import parserTypescript from "prettier/parser-typescript";
 
 /** @see https://github.dev/stephenh/ts-poet/blob/5ea0dbb3c9f1f4b0ee51a54abb2d758102eda4a2/src/Code.ts#L231 */
-function maybePretty(input: string, options?: Options | null): string {
+function maybePretty(input: string, options?: Options | null) {
   try {
     return prettier.format(input, {
       parser: "typescript",

package/src/generator.ts

@@ -1,12 +1,11 @@
 import { capitalize, groupBy } from "pastable/server";
-import { Box } from "./box";
-import { prettify } from "./format";
-import { mapOpenApiEndpoints } from "./map-openapi-endpoints";
-import { AnyBox, AnyBoxDef } from "./types";
+import { Box } from "./box.ts";
+import { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
+import { AnyBox, AnyBoxDef } from "./types.ts";
 import * as Codegen from "@sinclair/typebox-codegen";
 import { match } from "ts-pattern";
 import { type } from "arktype";
-import { wrapWithQuotesIfNeeded } from "./string-utils";
+import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
 
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints> & {
   runtime?: "none" | keyof typeof runtimeValidationGenerator;
@@ -64,36 +63,36 @@ export const generateFile = (options: GeneratorOptions) => {
     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 prettify(file);
+  return (file);
 };
 
 const generateSchemaList = ({ refs, runtime }: GeneratorContext) => {
@@ -138,39 +137,36 @@ 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 = `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`;
   });
@@ -193,14 +189,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>
@@ -281,22 +277,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])${match(ctx.runtime)
             .with("zod", "yup", () => `as Promise<${infer(`TEndpoint["response"]`)}>`)
             .with("arktype", "io-ts", "typebox", "valibot", () => `as Promise<${infer(`TEndpoint`) + `["response"]`}>`)
@@ -304,9 +300,9 @@ export class ApiClient {
     }
     // </ApiClient.${method}>
     `
-        : "";
-    })
-    .join("\n")}
+          : "";
+      })
+      .join("\n")}
 }
 
 export function createApiClient(fetcher: Fetcher, baseUrl?: string) {

package/src/index.ts

@@ -1,7 +1,8 @@
-export * from "./box-factory";
-export { generateFile, type OutputRuntime } from "./generator";
-export * from "./map-openapi-endpoints";
-export * from "./openapi-schema-to-ts";
-export * from "./ref-resolver";
-export * from "./ts-factory";
-export * from "./types";
+export * from "./box-factory.ts";
+export { generateFile, type OutputRuntime } from "./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";
+export * from "./ts-factory.ts";
+export * from "./types.ts";

package/src/map-openapi-endpoints.ts

@@ -1,13 +1,13 @@
 import type { OpenAPIObject, ResponseObject } from "openapi3-ts/oas31";
 import { OperationObject, ParameterObject } from "openapi3-ts/oas31";
 import { capitalize, pick } from "pastable/server";
-import { Box } from "./box";
-import { createBoxFactory } from "./box-factory";
-import { openApiSchemaToTs } from "./openapi-schema-to-ts";
-import { createRefResolver } from "./ref-resolver";
-import { tsFactory } from "./ts-factory";
-import { AnyBox, BoxRef, OpenapiSchemaConvertContext } from "./types";
-import { pathToVariableName } from "./string-utils";
+import { Box } from "./box.ts";
+import { createBoxFactory } from "./box-factory.ts";
+import { openApiSchemaToTs } from "./openapi-schema-to-ts.ts";
+import { createRefResolver } from "./ref-resolver.ts";
+import { tsFactory } from "./ts-factory.ts";
+import { AnyBox, BoxRef, OpenapiSchemaConvertContext } from "./types.ts";
+import { pathToVariableName } from "./string-utils.ts";
 import { match, P } from "ts-pattern";
 
 const factory = tsFactory;
@@ -112,7 +112,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
                 }
               }
             }
-          }  
+          }
         }
 
         // No need to pass empty objects, it's confusing
@@ -121,13 +121,13 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
 
       // Match the first 2xx-3xx response found, or fallback to default one otherwise
       let responseObject: ResponseObject | undefined;
-      Object.entries(operation.responses).map(([status, responseOrRef]) => {
+      Object.entries(operation.responses ?? {}).map(([status, responseOrRef]) => {
         const statusCode = Number(status);
         if (statusCode >= 200 && statusCode < 300) {
           responseObject = refs.unwrap<ResponseObject>(responseOrRef);
         }
       });
-      if (!responseObject && operation.responses.default) {
+      if (!responseObject && operation.responses?.default) {
         responseObject = refs.unwrap(operation.responses.default);
       }
 

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

@@ -1,10 +1,9 @@
-import { isPrimitiveType } from "./asserts";
-import { Box } from "./box";
-import { createBoxFactory } from "./box-factory";
-import { isReferenceObject } from "./is-reference-object";
-import { AnyBoxDef, OpenapiSchemaConvertArgs } from "./types";
-import { wrapWithQuotesIfNeeded } from "./string-utils";
-import type { SchemaObject } from "openapi3-ts/oas30";
+import { isPrimitiveType } from "./asserts.ts";
+import { Box } from "./box.ts";
+import { createBoxFactory } from "./box-factory.ts";
+import { isReferenceObject } from "./is-reference-object.ts";
+import { AnyBoxDef, OpenapiSchemaConvertArgs, type LibSchemaObject } from "./types.ts";
+import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
 
 export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: OpenapiSchemaConvertArgs): Box<AnyBoxDef> => {
   const meta = {} as OpenapiSchemaConvertArgs["meta"];
@@ -13,7 +12,7 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
     throw new Error("Schema is required");
   }
 
-  const t = createBoxFactory(schema, ctx);
+  const t = createBoxFactory(schema as LibSchemaObject, ctx);
   const getTs = () => {
     if (isReferenceObject(schema)) {
       const refInfo = ctx.refs.getInfosByRef(schema.$ref);
@@ -30,7 +29,7 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
     }
 
     if (schema.type === "null") {
-      return t.reference("null");
+      return t.literal("null");
     }
 
     if (schema.oneOf) {
@@ -82,7 +81,7 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
       if (schemaType === "string") return t.string();
       if (schemaType === "boolean") return t.boolean();
       if (schemaType === "number" || schemaType === "integer") return t.number();
-      if (schemaType === "null") return t.reference("null");
+      if (schemaType === "null") return t.literal("null");
     }
 
     if (schemaType === "array") {
@@ -100,7 +99,12 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
 
     if (schemaType === "object" || schema.properties || schema.additionalProperties) {
       if (!schema.properties) {
-        return t.unknown();
+        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}>`);
+        }
+
+        return t.literal("Record<string, unknown>");
       }
 
       let additionalProperties;
@@ -154,8 +158,8 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
   let output = getTs();
   if (!isReferenceObject(schema)) {
     // OpenAPI 3.1 does not have nullable, but OpenAPI 3.0 does
-    if ((schema as any as SchemaObject).nullable) {
-      output = t.union([output, t.reference("null")]);
+    if ((schema as LibSchemaObject).nullable) {
+      output = t.union([output, t.literal("null")]);
     }
   }
 

package/src/ref-resolver.ts

@@ -1,12 +1,12 @@
-import type { OpenAPIObject, ReferenceObject, SchemaObject } from "openapi3-ts/oas31";
+import type { OpenAPIObject, ReferenceObject } from "openapi3-ts/oas31";
 import { get } from "pastable/server";
 
-import { Box } from "./box";
-import { isReferenceObject } from "./is-reference-object";
-import { openApiSchemaToTs } from "./openapi-schema-to-ts";
-import { normalizeString } from "./string-utils";
-import { AnyBoxDef, GenericFactory } from "./types";
-import { topologicalSort } from "./topological-sort";
+import { Box } from "./box.ts";
+import { isReferenceObject } from "./is-reference-object.ts";
+import { openApiSchemaToTs } from "./openapi-schema-to-ts.ts";
+import { normalizeString } from "./string-utils.ts";
+import { AnyBoxDef, GenericFactory, type LibSchemaObject } from "./types.ts";
+import { topologicalSort } from "./topological-sort.ts";
 
 const autocorrectRef = (ref: string) => (ref[1] === "/" ? ref : "#/" + ref.slice(1));
 const componentsWithSchemas = ["schemas", "responses", "parameters", "requestBodies", "headers"];
@@ -36,7 +36,7 @@ export const createRefResolver = (doc: OpenAPIObject, factory: GenericFactory) =
 
   const boxByRef = new Map<string, Box<AnyBoxDef>>();
 
-  const getSchemaByRef = <T = SchemaObject>(ref: string) => {
+  const getSchemaByRef = <T = LibSchemaObject>(ref: string) => {
     // #components -> #/components
     const correctRef = autocorrectRef(ref);
     const split = correctRef.split("/");
@@ -119,10 +119,10 @@ export const createRefResolver = (doc: OpenAPIObject, factory: GenericFactory) =
   };
 };
 
-export interface RefResolver extends ReturnType<typeof createRefResolver> {}
+export interface RefResolver extends ReturnType<typeof createRefResolver> { }
 
-const setSchemaDependencies = (schema: SchemaObject, deps: Set<string>) => {
-  const visit = (schema: SchemaObject | ReferenceObject): void => {
+const setSchemaDependencies = (schema: LibSchemaObject, deps: Set<string>) => {
+  const visit = (schema: LibSchemaObject | ReferenceObject): void => {
     if (!schema) return;
 
     if (isReferenceObject(schema)) {

package/src/tanstack-query.generator.ts

@@ -0,0 +1,103 @@
+import { capitalize } from "pastable/server";
+import { prettify } from "./format.ts";
+import type { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
+
+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 file = `
+  import { queryOptions, QueryClient } from "@tanstack/react-query"
+  import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
+
+  type EndpointQueryKey<TOptions extends EndpointParameters> = [
+      TOptions & {
+          _id: string;
+          _infinite?: boolean;
+      }
+  ];
+
+  const createQueryKey = <TOptions extends EndpointParameters>(id: string, options?: TOptions, infinite?: boolean): [
+      EndpointQueryKey<TOptions>[0]
+  ] => {
+      const params: EndpointQueryKey<TOptions>[0] = { _id: id, } as EndpointQueryKey<TOptions>[0];
+      if (infinite) {
+          params._infinite = infinite;
+      }
+      if (options?.body) {
+          params.body = options.body;
+      }
+      if (options?.header) {
+          params.header = options.header;
+      }
+      if (options?.path) {
+          params.path = options.path;
+      }
+      if (options?.query) {
+          params.query = options.query;
+      }
+      return [
+          params
+      ];
+  };
+
+  // <EndpointByMethod.Shorthands>
+  ${Array.from(endpointMethods).map((method) => `export type ${capitalize(method)}Endpoints = EndpointByMethod["${method}"];`).join("\n")}
+  // </EndpointByMethod.Shorthands>
+
+  // <ApiClientTypes>
+  export type EndpointParameters = {
+      body?: unknown;
+      query?: Record<string, unknown>;
+      header?: Record<string, unknown>;
+      path?: Record<string, unknown>;
+  };
+
+  type RequiredKeys<T> = {
+      [P in keyof T]-?: undefined extends T[P] ? never : P;
+  }[keyof T];
+
+  type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [config: T];
+
+  // </ApiClientTypes>
+
+  // <ApiClient>
+  export class TanstackQueryApiClient {
+      constructor(public client: ApiClient) { }
+
+      ${Array.from(endpointMethods).map((method) => `
+        // <ApiClient.${method}>
+        ${method}<Path extends keyof ${capitalize(method)}Endpoints, TEndpoint extends ${capitalize(method)}Endpoints[Path]>(
+            path: Path,
+            ...params: MaybeOptionalArg<TEndpoint["parameters"]>
+        ) {
+            const queryKey = createQueryKey(path, params[0]);
+            const query = {
+                endpoint: {} as TEndpoint,
+                res: {} as TEndpoint["response"],
+                queryKey,
+                options: queryOptions({
+                    queryFn: async ({ queryKey, signal, }) => {
+                        const res = await this.client.${method}(path, {
+                            ...params,
+                            ...queryKey[0],
+                            signal,
+                            throwOnError: true
+                        });
+                        return res as TEndpoint["response"];
+                    },
+                    queryKey: queryKey
+                }),
+            };
+
+            return query
+        }
+        // </ApiClient.get>
+        `).join("\n")}
+  }
+`;
+
+    return prettify(file);
+};

package/src/ts-factory.ts

@@ -1,6 +1,6 @@
-import { Box } from "./box";
-import { createFactory, unwrap } from "./box-factory";
-import { wrapWithQuotesIfNeeded } from "./string-utils";
+import { Box } from "./box.ts";
+import { createFactory, unwrap } from "./box-factory.ts";
+import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
 
 export const tsFactory = createFactory({
   union: (types) => types.map(unwrap).join(" | "),

package/src/types.ts

@@ -1,7 +1,10 @@
 import type { ReferenceObject, SchemaObject } from "openapi3-ts/oas31";
+import type { SchemaObject as SchemaObject3 } from "openapi3-ts/oas30";
 
-import type { RefResolver } from "./ref-resolver";
-import { Box } from "./box";
+import type { RefResolver } from "./ref-resolver.ts";
+import { Box } from "./box.ts";
+
+export type LibSchemaObject = SchemaObject & SchemaObject3
 
 export type BoxDefinition = {
   type: string;
@@ -10,7 +13,7 @@ export type BoxDefinition = {
 };
 export type BoxParams = string | BoxDefinition;
 export type WithSchema = {
-  schema: SchemaObject | ReferenceObject | undefined;
+  schema: LibSchemaObject | ReferenceObject | undefined;
   ctx: OpenapiSchemaConvertContext;
 };