fix identification of required properties when strictNullChecks is disabled

# Conflicts:
#	packages/openapi-fetch/src/index.d.ts

Author: ngraef

.changeset/lazy-dancers-push.md

@@ -0,0 +1,7 @@
+---
+"openapi-typescript-helpers": patch
+"openapi-react-query": patch
+"openapi-fetch": patch
+---
+
+Fix identification of required properties when `strictNullChecks` is disabled

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

@@ -1,12 +1,13 @@
 import type {
   ErrorResponse,
   FilterKeys,
-  HasRequiredKeys,
   HttpMethod,
+  IsOperationRequestBodyOptional,
   MediaType,
   OperationRequestBodyContent,
   PathsWithMethod,
   ResponseObjectMap,
+  RequiredKeysOf,
   SuccessResponse,
 } from "openapi-typescript-helpers";
 
@@ -82,14 +83,14 @@ export interface DefaultParamsOption {
 export type ParamsOption<T> = T extends {
   parameters: any;
 }
-  ? HasRequiredKeys<T["parameters"]> extends never
+  ? RequiredKeysOf<T["parameters"]> extends never
     ? { params?: T["parameters"] }
     : { params: T["parameters"] }
   : DefaultParamsOption;
 
 export type RequestBodyOption<T> = OperationRequestBodyContent<T> extends never
   ? { body?: never }
-  : undefined extends OperationRequestBodyContent<T>
+  : IsOperationRequestBodyOptional<T> extends true
     ? { body?: OperationRequestBodyContent<T> }
     : { body: OperationRequestBodyContent<T> };
 
@@ -150,7 +151,7 @@ export interface Middleware {
 }
 
 /** This type helper makes the 2nd function param required if params/requestBody are required; otherwise, optional */
-export type MaybeOptionalInit<Params extends Record<HttpMethod, {}>, Location extends keyof Params> = HasRequiredKeys<
+export type MaybeOptionalInit<Params extends Record<HttpMethod, {}>, Location extends keyof Params> = RequiredKeysOf<
   FetchOptions<FilterKeys<Params, Location>>
 > extends never
   ? FetchOptions<FilterKeys<Params, Location>> | undefined
@@ -160,7 +161,7 @@ export type MaybeOptionalInit<Params extends Record<HttpMethod, {}>, Location ex
 // - Determines if the param is optional or not.
 // - Performs arbitrary [key: string] addition.
 // Note: the addition It MUST happen after all the inference happens (otherwise TS can’t infer if init is required or not).
-type InitParam<Init> = HasRequiredKeys<Init> extends never
+type InitParam<Init> = RequiredKeysOf<Init> extends never
   ? [(Init & { [key: string]: unknown })?]
   : [Init & { [key: string]: unknown }];
 

packages/openapi-react-query/src/index.ts

@@ -11,7 +11,7 @@ import {
   useSuspenseQuery,
 } from "@tanstack/react-query";
 import type { ClientMethod, FetchResponse, MaybeOptionalInit, Client as FetchClient } from "openapi-fetch";
-import type { HasRequiredKeys, HttpMethod, MediaType, PathsWithMethod } from "openapi-typescript-helpers";
+import type { HttpMethod, MediaType, PathsWithMethod, RequiredKeysOf } from "openapi-typescript-helpers";
 
 export type UseQueryMethod<Paths extends Record<string, Record<HttpMethod, {}>>, Media extends MediaType> = <
   Method extends HttpMethod,
@@ -22,7 +22,7 @@ export type UseQueryMethod<Paths extends Record<string, Record<HttpMethod, {}>>,
 >(
   method: Method,
   url: Path,
-  ...[init, options, queryClient]: HasRequiredKeys<Init> extends never
+  ...[init, options, queryClient]: RequiredKeysOf<Init> extends never
     ? [(Init & { [key: string]: unknown })?, Options?, QueryClient?]
     : [Init & { [key: string]: unknown }, Options?, QueryClient?]
 ) => UseQueryResult<Response["data"], Response["error"]>;
@@ -36,7 +36,7 @@ export type UseSuspenseQueryMethod<Paths extends Record<string, Record<HttpMetho
 >(
   method: Method,
   url: Path,
-  ...[init, options, queryClient]: HasRequiredKeys<Init> extends never
+  ...[init, options, queryClient]: RequiredKeysOf<Init> extends never
     ? [(Init & { [key: string]: unknown })?, Options?, QueryClient?]
     : [Init & { [key: string]: unknown }, Options?, QueryClient?]
 ) => UseSuspenseQueryResult<Response["data"], Response["error"]>;

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

@@ -97,11 +97,17 @@ export type ResponseObjectMap<T> = T extends { responses: any } ? T["responses"]
 /** Return `content` for a Response Object */
 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;
+/** Return type of `requestBody` for an Operation Object */
+export type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+
+/** Internal helper to get object type with only the `requestBody` property */
+type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+
+/** Resolve to `true` if request body is optional, else `false` */
+export type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
 
 /** Internal helper used in OperationRequestBodyContent */
-export type OperationRequestBodyMediaContent<T> = undefined extends OperationRequestBody<T>
+export type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true
   ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined
   : ResponseContent<OperationRequestBody<T>>;
 
@@ -152,7 +158,22 @@ export type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends any
 export type MediaType = `${string}/${string}`;
 /** Return any media type containing "json" (works for "application/json", "application/vnd.api+json", "application/vnd.oai.openapi+json") */
 export type JSONLike<T> = FilterKeys<T, `${string}/json`>;
-/** Filter objects that have required keys */
+
+/**
+ * Filter objects that have required keys
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 export type FindRequiredKeys<T, K extends keyof T> = K extends unknown ? (undefined extends T[K] ? never : K) : K;
-/** Does this object contain required keys? */
+/**
+ * Does this object contain required keys?
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 export type HasRequiredKeys<T> = FindRequiredKeys<T, keyof T>;
+
+/** Helper to get the required keys of an object. If no keys are required, will be `undefined` with strictNullChecks enabled, else `never` */
+type RequiredKeysOfHelper<T> = {
+  // biome-ignore lint/complexity/noBannedTypes: `{}` is necessary here
+  [K in keyof T]: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
+export type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;