typed-openapi 1.0.1 → 1.1.1

package/dist/{chunk-STLPDNLW.js → chunk-YSJGYFYM.js}

@@ -30,7 +30,7 @@ var prefixStringStartingWithNumberIfNeeded = (str) => {
 };
 var pathParamWithBracketsRegex = /({\w+})/g;
 var wordPrecededByNonWordCharacter = /[^\w\-]+/g;
-var pathToVariableName = (path) => capitalize(kebabToCamel(path).replaceAll("/", "")).replace(pathParamWithBracketsRegex, (group) => capitalize(group.slice(1, -1))).replace(wordPrecededByNonWordCharacter, "_");
+var pathToVariableName = (path) => capitalize(kebabToCamel(path).replaceAll("/", "_")).replace(pathParamWithBracketsRegex, (group) => capitalize(group.slice(1, -1))).replace(wordPrecededByNonWordCharacter, "_");
 
 // src/openapi-schema-to-ts.ts
 var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
@@ -63,8 +63,7 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
       if (schema.anyOf.length === 1) {
         return openApiSchemaToTs({ schema: schema.anyOf[0], ctx, meta });
       }
-      const oneOf = t.union(schema.anyOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
-      return t.union([oneOf, t.array(oneOf)]);
+      return t.union(schema.anyOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
     }
     if (schema.allOf) {
       if (schema.allOf.length === 1) {
@@ -394,7 +393,6 @@ var generateEndpointByMethod = (ctx) => {
 
     // <EndpointByMethod.Shorthands>
     ${Object.keys(byMethods).map((method) => `export type ${capitalize2(method)}Endpoints = EndpointByMethod["${method}"]`).join("\n")}
-    ${endpointList.length ? `export type AllEndpoints = EndpointByMethod[keyof EndpointByMethod];` : ""}
     // </EndpointByMethod.Shorthands>
     `;
   return endpointByMethod + shorthands;
@@ -436,7 +434,7 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
   response: TConfig["response"];
 };
 
-type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Endpoint["response"]>;
+export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
 
 type RequiredKeys<T> = {
   [P in keyof T]-?: undefined extends T[P] ? never : P;
@@ -458,6 +456,14 @@ export class ApiClient {
     return this;
   }
 
+  parseResponse = async <T>(response: Response): Promise<T> => {
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      return response.json();
+    }
+    return response.text() as unknown as T;
+  }
+
   ${Object.entries(byMethods).map(([method, endpointByMethod]) => {
     const capitalizedMethod = capitalize2(method);
     const infer = inferByRuntime[ctx.runtime];
@@ -466,11 +472,32 @@ export class ApiClient {
       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"]`)}>
     ): Promise<${match(ctx.runtime).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"]`}>`).otherwise(() => `as Promise<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"]`)}>`).with("arktype", "io-ts", "typebox", "valibot", () => `as Promise<${infer(`TEndpoint`) + `["response"]`}>`).otherwise(() => `as Promise<TEndpoint["response"]>`)};
     }
     // </ApiClient.${method}>
     ` : "";
   }).join("\n")}
+
+    // <ApiClient.request>
+    /**
+     * Generic request method with full type-safety for any endpoint
+     */
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      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`)}>)
+    : Promise<Omit<Response, "json"> & {
+      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
+      json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;
+    }> {
+      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters);
+    }
+    // </ApiClient.request>
 }
 
 export function createApiClient(fetcher: Fetcher, baseUrl?: string) {
@@ -822,7 +849,7 @@ import { capitalize as capitalize4 } from "pastable/server";
 var generateTanstackQueryFile = async (ctx) => {
   const endpointMethods = new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase()));
   const file = `
-  import { queryOptions, QueryClient } from "@tanstack/react-query"
+  import { queryOptions } from "@tanstack/react-query"
   import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
 
   type EndpointQueryKey<TOptions extends EndpointParameters> = [
@@ -888,8 +915,8 @@ var generateTanstackQueryFile = async (ctx) => {
         ) {
             const queryKey = createQueryKey(path, params[0]);
             const query = {
-                endpoint: {} as TEndpoint,
-                res: {} as TEndpoint["response"],
+                /** type-only property if you need easy access to the endpoint params */
+                "~endpoint": {} as TEndpoint,
                 queryKey,
                 options: queryOptions({
                     queryFn: async ({ queryKey, signal, }) => {
@@ -897,18 +924,50 @@ var generateTanstackQueryFile = async (ctx) => {
                             ...params,
                             ...queryKey[0],
                             signal,
-                            throwOnError: true
                         });
                         return res as TEndpoint["response"];
                     },
                     queryKey: queryKey
                 }),
+                mutationOptions: {
+                    mutationKey: queryKey,
+                    mutationFn: async (localOptions) => {
+                        const res = await this.client.${method}(path, {
+                            ...params,
+                            ...queryKey[0],
+                            ...localOptions,
+                        });
+                        return res as TEndpoint["response"];
+                    }
+                }
             };
 
             return query
         }
-        // </ApiClient.get>
+        // </ApiClient.${method}>
         `).join("\n")}
+
+        // <ApiClient.request>
+        /**
+         * Generic mutation method with full type-safety for any endpoint that doesnt require parameters to be passed initially
+         */
+        mutation<
+        TMethod extends keyof EndpointByMethod,
+        TPath extends keyof EndpointByMethod[TMethod],
+        TEndpoint extends EndpointByMethod[TMethod][TPath]
+        >(
+          method: TMethod,
+          path: TPath) {
+            const mutationKey = [{ method, path }] as const;
+            return {
+                mutationKey: mutationKey,
+                mutationOptions: {
+                    mutationKey: mutationKey,
+                    mutationFn: async (params: TEndpoint extends { parameters: infer Parameters} ? Parameters: never) => this.client.request(method, path, params)
+                }
+            }
+        }
+        // </ApiClient.request>
   }
 `;
   return prettify(file);

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   generateTanstackQueryFile,
   mapOpenApiEndpoints,
   prettify
-} from "./chunk-STLPDNLW.js";
+} from "./chunk-YSJGYFYM.js";
 
 // src/cli.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -13,6 +13,7 @@ import { basename, join } from "pathe";
 import { type } from "arktype";
 import { writeFile } from "fs/promises";
 import { readFileSync } from "fs";
+import { dirname } from "path";
 var { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 var cwd = process.cwd();
 var cli = cac(name);
@@ -39,7 +40,7 @@ cli.command("<input>", "Generate").option("-o, --output <path>", "Output path fo
       ...ctx,
       relativeApiClientPath: "./" + basename(outputPath)
     });
-    const tanstackOutputPath = join(cwd, typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
+    const tanstackOutputPath = join(dirname(outputPath), typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
     console.log("Generating tanstack client...", tanstackOutputPath);
     await writeFile(tanstackOutputPath, tanstackContent);
   }

package/dist/index.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typed-openapi",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "exports": {

package/src/cli.ts

@@ -10,6 +10,7 @@ import { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
 import { generateTanstackQueryFile } from "./tanstack-query.generator.ts";
 import { readFileSync } from "fs";
 import { prettify } from "./format.ts";
+import { dirname } from "path";
 
 const { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cwd = process.cwd();
@@ -48,7 +49,7 @@ cli
         ...ctx,
         relativeApiClientPath: './' + basename(outputPath),
       });
-      const tanstackOutputPath = join(cwd, typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
+      const tanstackOutputPath = join(dirname(outputPath), typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
       console.log("Generating tanstack client...", tanstackOutputPath);
       await writeFile(tanstackOutputPath, tanstackContent);
     }

package/src/generator.ts

@@ -208,7 +208,6 @@ const generateEndpointByMethod = (ctx: GeneratorContext) => {
     ${Object.keys(byMethods)
       .map((method) => `export type ${capitalize(method)}Endpoints = EndpointByMethod["${method}"]`)
       .join("\n")}
-    ${endpointList.length ? `export type AllEndpoints = EndpointByMethod[keyof EndpointByMethod];` : ""}
     // </EndpointByMethod.Shorthands>
     `;
 
@@ -253,7 +252,7 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
   response: TConfig["response"];
 };
 
-type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Endpoint["response"]>;
+export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
 
 type RequiredKeys<T> = {
   [P in keyof T]-?: undefined extends T[P] ? never : P;
@@ -264,6 +263,7 @@ type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [confi
 // </ApiClientTypes>
 `;
 
+
   const apiClient = `
 // <ApiClient>
 export class ApiClient {
@@ -276,6 +276,14 @@ export class ApiClient {
     return this;
   }
 
+  parseResponse = async <T>(response: Response): Promise<T> => {
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      return response.json();
+    }
+    return response.text() as unknown as T;
+  }
+
   ${Object.entries(byMethods)
       .map(([method, endpointByMethod]) => {
         const capitalizedMethod = capitalize(method);
@@ -293,7 +301,8 @@ export class ApiClient {
             .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)
+      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"]`)}>`)
             .with("arktype", "io-ts", "typebox", "valibot", () => `as Promise<${infer(`TEndpoint`) + `["response"]`}>`)
             .otherwise(() => `as Promise<TEndpoint["response"]>`)};
@@ -303,6 +312,29 @@ export class ApiClient {
           : "";
       })
       .join("\n")}
+
+    // <ApiClient.request>
+    /**
+     * Generic request method with full type-safety for any endpoint
+     */
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      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`)}>)
+    : Promise<Omit<Response, "json"> & {
+      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
+      json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;
+    }> {
+      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters);
+    }
+    // </ApiClient.request>
 }
 
 export function createApiClient(fetcher: Fetcher, baseUrl?: string) {

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

@@ -40,14 +40,15 @@ export const openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }: Openapi
       return t.union(schema.oneOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
     }
 
-    // anyOf = oneOf but with 1 or more = `T extends oneOf ? T | T[] : never`
+    // tl;dr: anyOf = oneOf
+    // oneOf matches exactly one subschema, and anyOf can match one or more subschemas.
+    // https://swagger.io/docs/specification/v3_0/data-models/oneof-anyof-allof-not/
     if (schema.anyOf) {
       if (schema.anyOf.length === 1) {
         return openApiSchemaToTs({ schema: schema.anyOf[0]!, ctx, meta });
       }
 
-      const oneOf = t.union(schema.anyOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
-      return t.union([oneOf, t.array(oneOf)]);
+      return t.union(schema.anyOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
     }
 
     if (schema.allOf) {

package/src/string-utils.ts

@@ -35,8 +35,9 @@ 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

@@ -9,7 +9,7 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
     const endpointMethods = (new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase())));
 
     const file = `
-  import { queryOptions, QueryClient } from "@tanstack/react-query"
+  import { queryOptions } from "@tanstack/react-query"
   import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
 
   type EndpointQueryKey<TOptions extends EndpointParameters> = [
@@ -75,8 +75,8 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
         ) {
             const queryKey = createQueryKey(path, params[0]);
             const query = {
-                endpoint: {} as TEndpoint,
-                res: {} as TEndpoint["response"],
+                /** type-only property if you need easy access to the endpoint params */
+                "~endpoint": {} as TEndpoint,
                 queryKey,
                 options: queryOptions({
                     queryFn: async ({ queryKey, signal, }) => {
@@ -84,18 +84,50 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
                             ...params,
                             ...queryKey[0],
                             signal,
-                            throwOnError: true
                         });
                         return res as TEndpoint["response"];
                     },
                     queryKey: queryKey
                 }),
+                mutationOptions: {
+                    mutationKey: queryKey,
+                    mutationFn: async (localOptions) => {
+                        const res = await this.client.${method}(path, {
+                            ...params,
+                            ...queryKey[0],
+                            ...localOptions,
+                        });
+                        return res as TEndpoint["response"];
+                    }
+                }
             };
 
             return query
         }
-        // </ApiClient.get>
+        // </ApiClient.${method}>
         `).join("\n")}
+
+        // <ApiClient.request>
+        /**
+         * Generic mutation method with full type-safety for any endpoint that doesnt require parameters to be passed initially
+         */
+        mutation<
+        TMethod extends keyof EndpointByMethod,
+        TPath extends keyof EndpointByMethod[TMethod],
+        TEndpoint extends EndpointByMethod[TMethod][TPath]
+        >(
+          method: TMethod,
+          path: TPath) {
+            const mutationKey = [{ method, path }] as const;
+            return {
+                mutationKey: mutationKey,
+                mutationOptions: {
+                    mutationKey: mutationKey,
+                    mutationFn: async (params: TEndpoint extends { parameters: infer Parameters} ? Parameters: never) => this.client.request(method, path, params)
+                }
+            }
+        }
+        // </ApiClient.request>
   }
 `;