Update openapi-fetch types

Author: drwpow

.changeset/beige-ligers-tell.md

@@ -0,0 +1,5 @@
+---
+"openapi-fetch": patch
+---
+
+Fix GET requests requiring 2nd param when it’s not needed

packages/openapi-fetch/src/index.test.ts

@@ -51,7 +51,7 @@ describe("client", () => {
         status: 200,
         body: JSON.stringify(["one", "two", "three"]),
       });
-      const dataRes = await client.GET("/string-array", {});
+      const dataRes = await client.GET("/string-array");
 
       // … is initially possibly undefined
       // @ts-expect-error
@@ -73,7 +73,7 @@ describe("client", () => {
         status: 500,
         body: JSON.stringify({ code: 500, message: "Something went wrong" }),
       });
-      const errorRes = await client.GET("/string-array", {});
+      const errorRes = await client.GET("/string-array");
 
       // … is initially possibly undefined
       // @ts-expect-error

packages/openapi-fetch/src/index.ts

@@ -13,7 +13,6 @@ import type {
 const DEFAULT_HEADERS = {
   "Content-Type": "application/json",
 };
-const TRAILING_SLASH_RE = /\/*$/;
 
 // Note: though "any" is considered bad practice in general, this library relies
 // on "any" for type inference only it can give.  Same goes for the "{}" type.
@@ -32,28 +31,46 @@ interface ClientOptions extends Omit<RequestInit, "headers"> {
   // headers override to make typing friendlier
   headers?: HeadersOptions;
 }
+
 export type HeadersOptions =
   | HeadersInit
   | Record<string, string | number | boolean | null | undefined>;
+
 export type QuerySerializer<T> = (
   query: T extends { parameters: any }
     ? NonNullable<T["parameters"]["query"]>
     : Record<string, unknown>,
 ) => string;
+
 export type BodySerializer<T> = (body: OperationRequestBodyContent<T>) => any;
+
 export type ParseAs = "json" | "text" | "blob" | "arrayBuffer" | "stream";
+
 export interface DefaultParamsOption {
   params?: { query?: Record<string, unknown> };
 }
+
+export interface EmptyParameters {
+  query?: never;
+  header?: never;
+  path?: never;
+  cookie?: never;
+}
+
 export type ParamsOption<T> = T extends { parameters: any }
-  ? { params: NonNullable<T["parameters"]> }
+  ? T["parameters"] extends EmptyParameters
+    ? DefaultParamsOption
+    : { params: NonNullable<T["parameters"]> }
   : DefaultParamsOption;
+
 export type RequestBodyOption<T> = OperationRequestBodyContent<T> extends never
   ? { body?: never }
   : undefined extends OperationRequestBodyContent<T>
   ? { body?: OperationRequestBodyContent<T> }
   : { body: OperationRequestBodyContent<T> };
+
 export type FetchOptions<T> = RequestOptions<T> & Omit<RequestInit, "body">;
+
 export type FetchResponse<T> =
   | {
       data: FilterKeys<SuccessResponse<ResponseObjectMap<T>>, MediaType>;
@@ -65,6 +82,7 @@ export type FetchResponse<T> =
       error: FilterKeys<ErrorResponse<ResponseObjectMap<T>>, MediaType>;
       response: Response;
     };
+
 export type RequestOptions<T> = ParamsOption<T> &
   RequestBodyOption<T> & {
     querySerializer?: QuerySerializer<T>;
@@ -159,11 +177,18 @@ export default function createClient<Paths extends {}>(
     return { error, response: response as any };
   }
 
+  type GetPaths = PathsWithMethod<Paths, "get">;
+  type GetFetchOptions<P extends GetPaths> = FetchOptions<
+    FilterKeys<Paths[P], "get">
+  >;
+
   return {
     /** Call a GET endpoint */
-    async GET<P extends PathsWithMethod<Paths, "get">>(
+    async GET<P extends GetPaths>(
       url: P,
-      init: FetchOptions<FilterKeys<Paths[P], "get">>,
+      ...init: GetFetchOptions<P> extends DefaultParamsOption
+        ? [GetFetchOptions<P>?]
+        : [GetFetchOptions<P>]
     ) {
       return coreFetch<P, "get">(url, { ...init, method: "GET" } as any);
     },
@@ -252,9 +277,11 @@ export function createFinalURL<O>(
     querySerializer: QuerySerializer<O>;
   },
 ): string {
-  let finalURL = `${
-    options.baseUrl ? options.baseUrl.replace(TRAILING_SLASH_RE, "") : ""
-  }${url as string}`;
+  let finalURL = options.baseUrl ?? "";
+  if (finalURL.endsWith("/")) {
+    finalURL = finalURL.slice(0, -1);
+  }
+  finalURL += url;
   if (options.params.path) {
     for (const [k, v] of Object.entries(options.params.path)) {
       finalURL = finalURL.replace(`{${k}}`, encodeURIComponent(String(v)));

packages/openapi-typescript-helpers/index.d.ts

@@ -2,7 +2,15 @@
 
 // HTTP types
 
-export type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+export type HttpMethod =
+  | "get"
+  | "put"
+  | "post"
+  | "delete"
+  | "options"
+  | "head"
+  | "patch"
+  | "trace";
 /** 2XX statuses */
 export type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
 // prettier-ignore
@@ -12,8 +20,15 @@ export type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 |
 // OpenAPI type helpers
 
 /** Given an OpenAPI **Paths Object**, find all paths that have the given method */
-export type PathsWithMethod<Paths extends Record<string, PathItemObject>, PathnameMethod extends HttpMethod> = {
-  [Pathname in keyof Paths]: Paths[Pathname] extends { [K in PathnameMethod]: any } ? Pathname : never;
+export type PathsWithMethod<
+  Paths extends Record<string, PathItemObject>,
+  PathnameMethod extends HttpMethod,
+> = {
+  [Pathname in keyof Paths]: Paths[Pathname] extends {
+    [K in PathnameMethod]: any;
+  }
+    ? Pathname
+    : never;
 }[keyof Paths];
 /** DO NOT USE! Only used only for OperationObject type inference */
 export interface OperationObject {
@@ -23,27 +38,48 @@ export interface OperationObject {
   responses: any;
 }
 /** Internal helper used in PathsWithMethod */
-export type PathItemObject = { [M in HttpMethod]: OperationObject } & { parameters?: any };
+export type PathItemObject = {
+  [M in HttpMethod]: OperationObject;
+} & { parameters?: any };
 /** Return `responses` for an Operation Object */
-export type ResponseObjectMap<T> = T extends { responses: any } ? T["responses"] : unknown;
+export type ResponseObjectMap<T> = T extends { responses: any }
+  ? T["responses"]
+  : unknown;
 /** Return `content` for a Response Object */
-export type ResponseContent<T> = T extends { content: any } ? T["content"] : unknown;
+export type ResponseContent<T> = T extends { content: any }
+  ? T["content"]
+  : unknown;
 /** Return `requestBody` for an Operation Object */
-export type OperationRequestBody<T> = T extends { requestBody?: any } ? T["requestBody"] : never;
+export type OperationRequestBody<T> = T extends { requestBody?: any }
+  ? T["requestBody"]
+  : never;
 /** Internal helper used in OperationRequestBodyContent */
-export type OperationRequestBodyMediaContent<T> = undefined extends OperationRequestBody<T> ? FilterKeys<NonNullable<OperationRequestBody<T>>, "content"> | undefined : FilterKeys<OperationRequestBody<T>, "content">;
+export type OperationRequestBodyMediaContent<T> =
+  undefined extends OperationRequestBody<T>
+    ? FilterKeys<NonNullable<OperationRequestBody<T>>, "content"> | undefined
+    : FilterKeys<OperationRequestBody<T>, "content">;
 /** Return first `content` from a Request Object Mapping, allowing any media type */
-export type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never
-  ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined
+export type OperationRequestBodyContent<T> = FilterKeys<
+  OperationRequestBodyMediaContent<T>,
+  MediaType
+> extends never
+  ?
+      | FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType>
+      | undefined
   : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
 /** Return first 2XX response from a Response Object Map */
 export type SuccessResponse<T> = FilterKeys<FilterKeys<T, OkStatus>, "content">;
 /** Return first 5XX or 4XX response (in that order) from a Response Object Map */
-export type ErrorResponse<T> = FilterKeys<FilterKeys<T, ErrorStatus>, "content">;
+export type ErrorResponse<T> = FilterKeys<
+  FilterKeys<T, ErrorStatus>,
+  "content"
+>;
 
 // Generic TS utils
 
 /** Find first match of multiple keys */
-export type FilterKeys<Obj, Matchers> = { [K in keyof Obj]: K extends Matchers ? Obj[K] : never }[keyof Obj];
+export type FilterKeys<Obj, Matchers> = {
+  [K in keyof Obj]: K extends Matchers ? Obj[K] : never;
+}[keyof Obj];
 /** Return any `[string]/[string]` media type (important because openapi-fetch allows any content response, not just JSON-like) */
 export type MediaType = `${string}/${string}`;