@openapi-qraft/react 1.2.0 → 1.4.0

package/src/callbacks/useQuery.ts

@@ -1,61 +1,25 @@
 'use client';
 
-import { useContext } from 'react';
-
 import type { DefaultError } from '@tanstack/query-core';
 import {
   useQuery as useQueryTanstack,
   type UseQueryResult,
 } from '@tanstack/react-query';
 
-import { composeQueryKey } from '../lib/composeQueryKey.js';
-import type { OperationRequestSchema } from '../lib/request.js';
-import { useQueryClient } from '../lib/useQueryClient.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import { useComposeUseQueryOptions } from '../lib/useComposeUseQueryOptions.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import { QraftContext } from '../QraftContext.js';
-import {
-  ServiceOperationQuery,
-  ServiceOperationQueryKey,
-} from '../ServiceOperation.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const useQuery: <TData = unknown, TError = DefaultError>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: OperationRequestSchema,
+  schema: OperationSchema,
   args: Parameters<
-    ServiceOperationQuery<OperationRequestSchema, unknown, unknown>['useQuery']
+    ServiceOperationQuery<OperationSchema, unknown, unknown>['useQuery']
   >
 ) => UseQueryResult<TData, TError> = (qraftOptions, schema, args) => {
-  const [parameters, options, queryClientByArg] = args;
-
-  const contextValue = useContext(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.request) throw new Error(`QraftContext.request not found`);
-
-  const queryKey: ServiceOperationQueryKey<OperationRequestSchema, unknown> =
-    Array.isArray(parameters)
-      ? (parameters as ServiceOperationQueryKey<
-          OperationRequestSchema,
-          unknown
-        >)
-      : composeQueryKey(schema, parameters);
-
   return useQueryTanstack(
-    {
-      ...options,
-      queryKey,
-      queryFn:
-        options?.queryFn ??
-        function ({ queryKey: [, queryParams], signal, meta }) {
-          return contextValue.request(
-            { baseUrl: contextValue.baseUrl },
-            schema,
-            {
-              parameters: queryParams as never,
-              signal,
-              meta,
-            }
-          );
-        },
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
+    // @ts-expect-error
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
   ) as never;
 };

package/src/callbacks/useSuspenseInfiniteQuery.ts

@@ -1,23 +1,15 @@
 'use client';
 
-import { useContext } from 'react';
-
 import type { DefaultError, InfiniteData } from '@tanstack/query-core';
 import {
   useSuspenseInfiniteQuery as useSuspenseInfiniteQueryTanstack,
-  UseSuspenseInfiniteQueryResult,
+  type UseSuspenseInfiniteQueryResult,
 } from '@tanstack/react-query';
 
-import { composeInfiniteQueryKey } from '../lib/composeInfiniteQueryKey.js';
-import type { OperationRequestSchema } from '../lib/request.js';
-import { shelfMerge } from '../lib/shelfMerge.js';
-import { useQueryClient } from '../lib/useQueryClient.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import { useComposeUseQueryOptions } from '../lib/useComposeUseQueryOptions.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import { QraftContext } from '../QraftContext.js';
-import {
-  ServiceOperationInfiniteQueryKey,
-  ServiceOperationQuery,
-} from '../ServiceOperation.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const useSuspenseInfiniteQuery: <
   TQueryFnData,
@@ -25,10 +17,10 @@ export const useSuspenseInfiniteQuery: <
   TData = InfiniteData<TQueryFnData>,
 >(
   qraftOptions: QraftClientOptions | undefined,
-  schema: OperationRequestSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationQuery<
-      OperationRequestSchema,
+      OperationSchema,
       unknown,
       unknown
     >['useSuspenseInfiniteQuery']
@@ -38,36 +30,8 @@ export const useSuspenseInfiniteQuery: <
   schema,
   args
 ) => {
-  const [parameters, options, queryClientByArg] = args;
-
-  const contextValue = useContext(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.request) throw new Error(`QraftContext.request not found`);
-
-  const queryKey: ServiceOperationInfiniteQueryKey<
-    OperationRequestSchema,
-    unknown
-  > = Array.isArray(parameters)
-    ? (parameters as never)
-    : composeInfiniteQueryKey(schema, parameters);
-
   return useSuspenseInfiniteQueryTanstack(
-    {
-      ...options,
-      queryKey,
-      queryFn:
-        options?.queryFn ??
-        function ({ queryKey: [, queryParams], signal, meta, pageParam }) {
-          return contextValue.request(
-            { baseUrl: contextValue.baseUrl },
-            schema,
-            {
-              parameters: shelfMerge(2, queryParams, pageParam) as never,
-              signal,
-              meta,
-            }
-          );
-        },
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
+    // @ts-expect-error
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, true)
   ) as never;
 };

package/src/callbacks/useSuspenseQueries.ts

@@ -8,7 +8,7 @@ import {
 } from '@tanstack/react-query';
 
 import { composeQueryKey } from '../lib/composeQueryKey.js';
-import type { OperationRequestSchema } from '../lib/request.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import { useQueryClient } from '../lib/useQueryClient.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
 import { QraftContext } from '../QraftContext.js';
@@ -16,10 +16,10 @@ import { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const useSuspenseQueries: (
   qraftOptions: QraftClientOptions | undefined,
-  schema: OperationRequestSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationQuery<
-      OperationRequestSchema,
+      OperationSchema,
       unknown,
       unknown
     >['useSuspenseQueries']
@@ -28,7 +28,8 @@ export const useSuspenseQueries: (
   const [options, queryClientByArg] = args;
 
   const contextValue = useContext(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.request) throw new Error(`QraftContext.request not found`);
+  if (!contextValue?.requestFn)
+    throw new Error(`QraftContext.requestFn not found`);
 
   return useSuspenseQueriesTanstack(
     {
@@ -43,6 +44,7 @@ export const useSuspenseQueries: (
                   },
                   queryOptions
                 );
+                // @ts-expect-error
                 delete queryOptionsCopy.parameters;
                 return queryOptionsCopy;
               })()
@@ -53,15 +55,12 @@ export const useSuspenseQueries: (
           queryFn:
             optionsWithQueryKey.queryFn ??
             function ({ queryKey: [, queryParams], signal, meta }) {
-              return contextValue.request(
-                { baseUrl: contextValue.baseUrl },
-                schema,
-                {
-                  parameters: queryParams as never,
-                  signal,
-                  meta,
-                }
-              );
+              return contextValue.requestFn(schema, {
+                parameters: queryParams as never,
+                baseUrl: contextValue.baseUrl,
+                signal,
+                meta,
+              });
             },
         };
       }),

package/src/callbacks/useSuspenseQuery.ts

@@ -1,22 +1,15 @@
 'use client';
 
-import { useContext } from 'react';
-
 import type { DefaultError } from '@tanstack/query-core';
 import {
-  UseQueryResult,
+  type UseQueryResult,
   useSuspenseQuery as useSuspenseQueryTanstack,
 } from '@tanstack/react-query';
 
-import { composeQueryKey } from '../lib/composeQueryKey.js';
-import type { OperationRequestSchema } from '../lib/request.js';
-import { useQueryClient } from '../lib/useQueryClient.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import { useComposeUseQueryOptions } from '../lib/useComposeUseQueryOptions.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import { QraftContext } from '../QraftContext.js';
-import {
-  ServiceOperationQuery,
-  ServiceOperationQueryKey,
-} from '../ServiceOperation.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const useSuspenseQuery: <
   TQueryFnData = unknown,
@@ -24,43 +17,13 @@ export const useSuspenseQuery: <
   TData = TQueryFnData,
 >(
   qraftOptions: QraftClientOptions | undefined,
-  schema: OperationRequestSchema,
+  schema: OperationSchema,
   args: Parameters<
-    ServiceOperationQuery<
-      OperationRequestSchema,
-      unknown,
-      unknown
-    >['useSuspenseQuery']
+    ServiceOperationQuery<OperationSchema, unknown, unknown>['useSuspenseQuery']
   >
 ) => UseQueryResult<TData, TError> = (qraftOptions, schema, args) => {
-  const [parameters, options, queryClientByArg] = args;
-
-  const contextValue = useContext(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.request) throw new Error(`QraftContext.request not found`);
-
-  const queryKey: ServiceOperationQueryKey<OperationRequestSchema, unknown> =
-    Array.isArray(parameters)
-      ? (parameters as never)
-      : composeQueryKey(schema, parameters);
-
   return useSuspenseQueryTanstack(
-    {
-      ...options,
-      queryKey,
-      queryFn:
-        options?.queryFn ??
-        function ({ queryKey: [, queryParams], signal, meta }) {
-          return contextValue.request(
-            { baseUrl: contextValue.baseUrl },
-            schema,
-            {
-              parameters: queryParams as never,
-              signal,
-              meta,
-            }
-          );
-        },
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
+    // @ts-expect-error
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
   ) as never;
 };

package/src/index.ts

@@ -1,15 +1,15 @@
 export { qraftAPIClient, type QraftClientOptions } from './qraftAPIClient.js';
 export { QraftContext, type QraftContextValue } from './QraftContext.js';
 export {
-  request,
-  baseRequest,
+  requestFn,
+  baseRequestFn,
   urlSerializer,
   bodySerializer,
-  type OperationRequestInfo,
-  type OperationRequestSchema,
-  type RequestOptions,
+  type RequestFnPayload,
+  type OperationSchema,
+  type RequestFnOptions,
   type HeadersOptions,
-} from './lib/request.js';
+} from './lib/requestFn.js';
 export type {
   ServiceOperationQuery,
   ServiceOperationMutation,

package/src/lib/callQueryClientFetchMethod.ts

@@ -0,0 +1,90 @@
+import type { QueryClient } from '@tanstack/query-core';
+
+import { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';
+import { composeQueryKey } from './composeQueryKey.js';
+import type { OperationSchema, RequestFn } from './requestFn.js';
+import { shelfMerge } from './shelfMerge.js';
+
+/**
+ * Calls a query client fetch method with parameters and options,
+ * and automatically composes the `QueryKey` based on the schema and parameters.
+ */
+export function callQueryClientMethodWithQueryKey<
+  QFMethod extends QueryKeyMethods,
+>(
+  queryFilterMethod: QFMethod,
+  schema: OperationSchema,
+  infinite: boolean,
+  args: QueryClientMethodArgs<QFMethod>
+): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
+  const [{ requestFn, baseUrl, parameters, ...options }, queryClient] = args;
+
+  if (!queryClient) throw new Error('queryClient is required');
+  if (!queryClient[queryFilterMethod])
+    throw new Error(
+      `queryClient is invalid, ${queryFilterMethod} method does not exist`
+    );
+
+  if (options.queryKey && parameters) {
+    throw new Error(
+      'callQueryClientMethodWithQueryKey: options.queryKey and options.parameters are mutually exclusive'
+    );
+  }
+
+  if (options.queryFn && requestFn) {
+    throw new Error(
+      'callQueryClientMethodWithQueryKey: options.queryFn and requestFn are mutually exclusive'
+    );
+  }
+
+  const queryFn =
+    options.queryFn ??
+    (requestFn
+      ? // @ts-expect-error
+        function ({ queryKey: [, queryParams], signal, meta, pageParam }) {
+          return requestFn(schema, {
+            parameters: infinite
+              ? (shelfMerge(2, queryParams, pageParam) as never)
+              : queryParams,
+            baseUrl,
+            signal,
+            meta,
+          });
+        }
+      : undefined);
+
+  if (parameters) {
+    // @ts-expect-error
+    return queryClient[queryFilterMethod]({
+      ...options,
+      // Event if queryFn is undefined, it will override the default queryFn from `setQueryDefaults(...)`
+      ...(queryFn ? { queryFn } : {}),
+      queryKey: infinite
+        ? composeInfiniteQueryKey(schema, parameters)
+        : composeQueryKey(schema, parameters),
+    });
+  }
+
+  // @ts-expect-error
+  return queryClient[queryFilterMethod]({ ...options, queryFn });
+}
+
+type QueryClientMethodArgs<QMethod extends keyof QueryClientPrototype> = [
+  options: Parameters<QueryClientPrototype[QMethod]>[0] & {
+    parameters?: unknown;
+    baseUrl?: string;
+    requestFn?: RequestFn<unknown>;
+  },
+  queryClient: QueryClient,
+];
+
+type QueryKeyMethods =
+  | QueryKeyMethod<'fetchQuery'>
+  | QueryKeyMethod<'prefetchQuery'>
+  | QueryKeyMethod<'fetchInfiniteQuery'>
+  | QueryKeyMethod<'prefetchInfiniteQuery'>;
+
+type QueryClientPrototype = typeof QueryClient.prototype;
+
+type QueryKeyMethod<QFMethod extends keyof typeof QueryClient.prototype> =
+  QFMethod;

package/src/lib/callQueryClientMethodWithMutationFilters.ts

@@ -0,0 +1,37 @@
+import type { QueryClient } from '@tanstack/query-core';
+
+import { composeMutationFilters } from './composeMutationFilters.js';
+import type { OperationSchema } from './requestFn.js';
+
+/**
+ * Calls a query client method with mutation filters and options,
+ * and automatically composes the `MutationKey` based on the schema and parameters.
+ */
+export function callQueryClientMethodWithMutationFilters<
+  QFMethod extends QueryFilterMethods,
+>(
+  queryFilterMethod: QFMethod,
+  schema: OperationSchema,
+  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]
+): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
+  const filters = args[0];
+  const queryClient = args[args.length - 1] as QueryClient | undefined;
+
+  if (!queryClient) throw new Error('queryClient is required');
+  if (!queryClient[queryFilterMethod])
+    throw new Error(
+      `queryClient is invalid, ${queryFilterMethod} method does not exist`
+    );
+
+  // @ts-expect-error
+  return queryClient[queryFilterMethod](
+    composeMutationFilters(schema, filters as never),
+    // @ts-expect-error
+    ...args.slice(1, -1)
+  );
+}
+
+type QueryFiltersMethod<QFMethod extends keyof typeof QueryClient.prototype> =
+  QFMethod;
+
+type QueryFilterMethods = QueryFiltersMethod<'isMutating'>;

package/src/lib/callQueryClientMethodWithQueryFilters.ts

@@ -1,7 +1,7 @@
 import type { QueryClient } from '@tanstack/query-core';
 
 import { composeQueryFilters } from './composeQueryFilters.js';
-import type { OperationRequestSchema } from './request.js';
+import type { OperationSchema } from './requestFn.js';
 
 /**
  * Calls a query client method with query filters and options,
@@ -11,24 +11,11 @@ export function callQueryClientMethodWithQueryFilters<
   QFMethod extends QueryFilterMethods,
 >(
   queryFilterMethod: QFMethod,
-  schema: OperationRequestSchema,
-  args: [QueryClient, ...Parameters<(typeof QueryClient.prototype)[QFMethod]>]
+  schema: OperationSchema,
+  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]
 ): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
-  const queryClient = (
-    args.length === 1
-      ? args[0]
-      : args.length === 2
-        ? args[1]
-        : args.length === 3
-          ? args[2]
-          : undefined
-  ) as QueryClient | undefined;
-
-  const filters = composeQueryFilters(
-    schema,
-    args.length === 1 ? undefined : args[0]
-  );
-  const options = args.length === 3 ? args[1] : undefined;
+  const filters = args[0];
+  const queryClient = args[args.length - 1] as QueryClient | undefined;
 
   if (!queryClient) throw new Error('queryClient is required');
   if (!queryClient[queryFilterMethod])
@@ -36,12 +23,12 @@ export function callQueryClientMethodWithQueryFilters<
       `queryClient is invalid, ${queryFilterMethod} method does not exist`
     );
 
-  if (options)
-    // @ts-expect-error
-    return queryClient[queryFilterMethod](filters, options);
-
   // @ts-expect-error
-  return queryClient[queryFilterMethod](filters);
+  return queryClient[queryFilterMethod](
+    composeQueryFilters(schema, filters as never),
+    // @ts-expect-error
+    ...args.slice(1, -1)
+  );
 }
 
 type QueryFiltersMethod<QFMethod extends keyof typeof QueryClient.prototype> =

package/src/lib/callQueryClientMethodWithQueryKey.ts

@@ -0,0 +1,46 @@
+import type { QueryClient } from '@tanstack/query-core';
+
+import { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';
+import { composeQueryKey } from './composeQueryKey.js';
+import type { OperationSchema } from './requestFn.js';
+
+/**
+ * Calls a query client method with parameters and options,
+ * and automatically composes the `QueryKey` based on the schema and parameters.
+ */
+export function callQueryClientMethodWithQueryKey<
+  QFMethod extends QueryKeyMethods,
+>(
+  queryFilterMethod: QFMethod,
+  schema: OperationSchema,
+  infinite: boolean,
+  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]
+): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
+  const parameters = args[0];
+  const queryClient = args[args.length - 1] as QueryClient | undefined;
+
+  if (!queryClient) throw new Error('queryClient is required');
+  if (!queryClient[queryFilterMethod])
+    throw new Error(
+      `queryClient is invalid, ${queryFilterMethod} method does not exist`
+    );
+
+  const queryKey = Array.isArray(parameters)
+    ? parameters
+    : infinite
+      ? composeInfiniteQueryKey(schema, parameters)
+      : composeQueryKey(schema, parameters);
+
+  // @ts-expect-error
+  return queryClient[queryFilterMethod](queryKey, ...args.slice(1, -1));
+}
+
+type QueryKeyMethod<QFMethod extends keyof typeof QueryClient.prototype> =
+  QFMethod;
+
+type QueryKeyMethods =
+  | QueryKeyMethod<'setQueryData'>
+  | QueryKeyMethod<'getQueryData'>
+  | QueryKeyMethod<'getQueryState'>
+  | QueryKeyMethod<'setQueryDefaults'>
+  | QueryKeyMethod<'getQueryDefaults'>;

package/src/lib/composeInfiniteQueryKey.ts

@@ -1,8 +1,8 @@
 import type { ServiceOperationInfiniteQueryKey } from '../ServiceOperation.js';
-import type { OperationRequestSchema } from './request.js';
+import type { OperationSchema } from './requestFn.js';
 
 export function composeInfiniteQueryKey<
-  TSchema extends OperationRequestSchema,
+  TSchema extends OperationSchema,
   TParams,
 >(
   schema: TSchema,

package/src/lib/composeMutationFilters.ts

@@ -0,0 +1,44 @@
+import { composeMutationKey } from './composeMutationKey.js';
+import type { OperationSchema } from './requestFn.js';
+
+/**
+ * Replaces the `parameters` field in the filters with a `mutationKey` field based on the schema.
+ * If no filters are provided, a `mutationKey` will be composed schema's base query key.
+ * @param schema
+ * @param filters
+ */
+export function composeMutationFilters<Filters extends object>(
+  schema: OperationSchema,
+  filters: Filters | undefined
+) {
+  if (!filters) {
+    return {
+      mutationKey: composeMutationKey(schema, undefined),
+    };
+  }
+
+  if (filters && 'mutationKey' in filters && 'parameters' in filters) {
+    throw new Error(
+      `'composeMutationFilters': 'mutationKey' and 'parameters' cannot be used together`
+    );
+  }
+
+  if ('mutationKey' in filters) {
+    return filters;
+  }
+
+  if ('parameters' in filters) {
+    const { parameters, ...filtersWithoutParameters } = filters;
+
+    Object.assign(filtersWithoutParameters, {
+      mutationKey: composeMutationKey(schema, parameters),
+    });
+
+    return filtersWithoutParameters;
+  }
+
+  return {
+    ...filters,
+    mutationKey: composeMutationKey(schema, undefined),
+  };
+}

package/src/lib/composeMutationKey.ts

@@ -1,30 +1,27 @@
 import type { ServiceOperationMutationKey } from '../ServiceOperation.js';
-import type { OperationRequestSchema } from './request.js';
+import type { OperationSchema } from './requestFn.js';
 
 /**
  * Omit `body` or `requestBody` from mutation parameters if exists
  * and return the rest of the parameters
  */
 export function composeMutationKey<
-  TSchema extends OperationRequestSchema,
+  TSchema extends OperationSchema,
   TParams = undefined,
 >(
   schema: TSchema,
   parameters: undefined
 ): ServiceOperationMutationKey<TSchema, undefined>;
-export function composeMutationKey<
-  TSchema extends OperationRequestSchema,
-  TParams,
->(
+export function composeMutationKey<TSchema extends OperationSchema, TParams>(
   schema: TSchema,
   parameters: TParams
 ): ServiceOperationMutationKey<TSchema, TParams>;
 export function composeMutationKey<
-  TSchema extends OperationRequestSchema,
+  TSchema extends OperationSchema,
   TParams = unknown,
 >(schema: TSchema, parameters: TParams | undefined) {
   return parameters === undefined
-    ? [{ url: schema.url, method: schema.method }]
+    ? [{ url: schema.url, method: schema.method }, {}]
     : [
         {
           url: schema.url,

package/src/lib/composeQueryFilters.ts

@@ -1,5 +1,5 @@
 import { composeQueryKey } from './composeQueryKey.js';
-import type { OperationRequestSchema } from './request.js';
+import type { OperationSchema } from './requestFn.js';
 
 /**
  * Replaces the `parameters` field in the filters with a `queryKey` field based on the schema.
@@ -8,7 +8,7 @@ import type { OperationRequestSchema } from './request.js';
  * @param filters
  */
 export function composeQueryFilters<Filters extends object>(
-  schema: OperationRequestSchema,
+  schema: OperationSchema,
   filters: Filters | undefined
 ) {
   if (!filters) {

package/src/lib/composeQueryKey.ts

@@ -1,10 +1,7 @@
 import type { ServiceOperationQueryKey } from '../ServiceOperation.js';
-import type { OperationRequestSchema } from './request.js';
+import type { OperationSchema } from './requestFn.js';
 
-export function composeQueryKey<
-  TSchema extends OperationRequestSchema,
-  TParams,
->(
+export function composeQueryKey<TSchema extends OperationSchema, TParams>(
   schema: TSchema,
   parameters: TParams | undefined
 ): ServiceOperationQueryKey<TSchema, TParams> {