@openapi-qraft/react 1.3.2 → 1.5.0

package/src/callbacks/getInfiniteQueryState.ts

@@ -0,0 +1,23 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientMethodWithQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export function getInfiniteQueryState<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationQuery<
+      OperationSchema,
+      unknown,
+      TData
+    >['getInfiniteQueryState']
+  >
+): TData | undefined {
+  return callQueryClientMethodWithQueryKey(
+    'getQueryState',
+    schema,
+    true,
+    args as never
+  ) as never;
+}

package/src/callbacks/getQueriesData.ts

@@ -0,0 +1,18 @@
+import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export function getQueriesData<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationQuery<OperationSchema, unknown, TData>['getQueriesData']
+  >
+): TData | undefined {
+  return callQueryClientMethodWithQueryFilters(
+    'getQueriesData',
+    schema,
+    args as never
+  ) as never;
+}

package/src/callbacks/getQueryState.ts

@@ -0,0 +1,19 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientMethodWithQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export function getQueryState<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationQuery<OperationSchema, unknown, TData>['getQueryState']
+  >
+): TData | undefined {
+  return callQueryClientMethodWithQueryKey(
+    'getQueryState',
+    schema,
+    false,
+    args as never
+  ) as never;
+}

package/src/callbacks/isMutating.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithMutationFilters } from '../lib/callQueryClientMethodWithMutationFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationIsMutatingQueriesCallback } from '../ServiceOperation.js';
+
+export function isMutating<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationIsMutatingQueriesCallback<
+      OperationSchema,
+      unknown,
+      TData
+    >['isMutating']
+  >
+): Promise<void> {
+  return callQueryClientMethodWithMutationFilters(
+    'isMutating',
+    schema,
+    args as never
+  ) as never;
+}

package/src/callbacks/removeQueries.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationRemoveQueriesCallback } from '../ServiceOperation.js';
+
+export function removeQueries<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationRemoveQueriesCallback<
+      OperationSchema,
+      unknown,
+      TData
+    >['removeQueries']
+  >
+): Promise<void> {
+  return callQueryClientMethodWithQueryFilters(
+    'removeQueries',
+    schema,
+    args as never
+  ) as never;
+}

package/src/callbacks/setQueriesData.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import type { ServiceOperationSetQueriesDataCallback } from '../ServiceOperation.js';
+
+export function setQueriesData<TData>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationSetQueriesDataCallback<
+      OperationSchema,
+      unknown,
+      TData
+    >['setQueriesData']
+  >
+): TData | undefined {
+  return callQueryClientMethodWithQueryFilters(
+    'setQueriesData',
+    schema,
+    args as never
+  ) as never;
+}

package/src/callbacks/useIsFetching.ts

@@ -23,7 +23,7 @@ export const useIsFetching: <TVariables = unknown>(
   const [filters, queryClientByArg] = args;
 
   return useIsFetchingTanstack(
-    composeQueryFilters(schema, filters) as never,
+    composeQueryFilters(schema, filters as never) as never,
     useQueryClient(qraftOptions, queryClientByArg)
   ) as never;
 };

package/src/callbacks/useIsMutating.ts

@@ -0,0 +1,42 @@
+'use client';
+
+import type { DefaultError } from '@tanstack/query-core';
+import {
+  UseMutationResult,
+  useIsMutating as useIsMutatingStateTanstack,
+} from '@tanstack/react-query';
+
+import { composeMutationFilters } from '../lib/composeMutationFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
+import { useQueryClient } from '../lib/useQueryClient.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationMutation } from '../ServiceOperation.js';
+
+export const useIsMutating: <
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+>(
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
+  args: Parameters<
+    ServiceOperationMutation<
+      OperationSchema,
+      object | undefined,
+      TVariables,
+      TData
+    >['useIsMutating']
+  >
+) => UseMutationResult<TData, TError, TVariables, TContext> = (
+  qraftOptions,
+  schema,
+  args
+) => {
+  const [filters, queryClientByArg] = args;
+
+  return useIsMutatingStateTanstack(
+    composeMutationFilters(schema, filters) as never,
+    useQueryClient(qraftOptions, queryClientByArg)
+  ) as never;
+};

package/src/callbacks/useMutationState.ts

@@ -1,14 +1,12 @@
 'use client';
 
-import { useContext } from 'react';
-
 import type { DefaultError } from '@tanstack/query-core';
 import {
   UseMutationResult,
   useMutationState as useMutationStateTanstack,
 } from '@tanstack/react-query';
 
-import { composeMutationKey } from '../lib/composeMutationKey.js';
+import { composeMutationFilters } from '../lib/composeMutationFilters.js';
 import type { OperationSchema } from '../lib/requestFn.js';
 import { useQueryClient } from '../lib/useQueryClient.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
@@ -37,33 +35,10 @@ export const useMutationState: <
 ) => {
   const [options, queryClientByArg] = args;
 
-  if (
-    options?.filters &&
-    'parameters' in options.filters &&
-    'mutationKey' in options.filters
-  ) {
-    throw new Error(
-      `'useMutationState': 'parameters' and 'mutationKey' cannot be used together`
-    );
-  }
-
-  const filters = options?.filters;
-
   return useMutationStateTanstack(
     {
       ...options,
-      filters:
-        filters && 'mutationKey' in filters
-          ? filters
-          : {
-              ...filters,
-              mutationKey: composeMutationKey(
-                schema,
-                filters && 'parameters' in filters
-                  ? filters.parameters
-                  : undefined
-              ),
-            },
+      filters: composeMutationFilters(schema, options?.filters),
     } as never,
     useQueryClient(qraftOptions, queryClientByArg)
   ) as never;

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.length > 1 ? args[0] : undefined;
+  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

@@ -14,7 +14,7 @@ export function callQueryClientMethodWithQueryFilters<
   schema: OperationSchema,
   args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]
 ): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
-  const filters = args[0];
+  const filters = args.length > 1 ? args[0] : undefined;
   const queryClient = args[args.length - 1] as QueryClient | undefined;
 
   if (!queryClient) throw new Error('queryClient is required');

package/src/lib/callQueryClientMethodWithQueryKey.ts

@@ -16,7 +16,7 @@ export function callQueryClientMethodWithQueryKey<
   infinite: boolean,
   args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]
 ): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {
-  const parameters = args[0];
+  const parameters = args.length > 1 ? args[0] : undefined;
   const queryClient = args[args.length - 1] as QueryClient | undefined;
 
   if (!queryClient) throw new Error('queryClient is required');

package/src/lib/composeBaseQueryKey.ts

@@ -0,0 +1,34 @@
+import {
+  ServiceOperationInfiniteQueryKey,
+  ServiceOperationQueryKey,
+} from '../ServiceOperation.js';
+import type { OperationSchema } from './requestFn.js';
+
+export function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(
+  schema: TSchema,
+  parameters: TParams | undefined,
+  infinite: undefined
+): [TSchema, TParams];
+export function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(
+  schema: TSchema,
+  parameters: TParams | undefined,
+  infinite: true
+): ServiceOperationInfiniteQueryKey<TSchema, TParams>;
+export function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(
+  schema: TSchema,
+  parameters: TParams | undefined,
+  infinite: false
+): ServiceOperationQueryKey<TSchema, TParams>;
+export function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(
+  schema: TSchema,
+  parameters: TParams | undefined,
+  infinite: boolean | undefined
+):
+  | ServiceOperationQueryKey<TSchema, TParams>
+  | ServiceOperationInfiniteQueryKey<TSchema, TParams>
+  | [TSchema, TParams] {
+  return [
+    typeof infinite === 'boolean' ? { ...schema, infinite } : schema,
+    parameters ?? ({} as TParams),
+  ];
+}

package/src/lib/composeInfiniteQueryKey.ts

@@ -1,4 +1,5 @@
 import type { ServiceOperationInfiniteQueryKey } from '../ServiceOperation.js';
+import { composeBaseQueryKey } from './composeBaseQueryKey.js';
 import type { OperationSchema } from './requestFn.js';
 
 export function composeInfiniteQueryKey<
@@ -8,5 +9,5 @@ export function composeInfiniteQueryKey<
   schema: TSchema,
   parameters: TParams | undefined
 ): ServiceOperationInfiniteQueryKey<TSchema, TParams> {
-  return [{ ...schema, infinite: true }, parameters ?? ({} as TParams)];
+  return composeBaseQueryKey(schema, parameters, true);
 }

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

@@ -21,7 +21,7 @@ export function composeMutationKey<
   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,3 +1,5 @@
+import { composeBaseQueryKey } from './composeBaseQueryKey.js';
+import { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';
 import { composeQueryKey } from './composeQueryKey.js';
 import type { OperationSchema } from './requestFn.js';
 
@@ -7,38 +9,44 @@ import type { OperationSchema } from './requestFn.js';
  * @param schema
  * @param filters
  */
-export function composeQueryFilters<Filters extends object>(
-  schema: OperationSchema,
-  filters: Filters | undefined
-) {
+export function composeQueryFilters<
+  Filters extends {
+    infinite: boolean;
+    parameters?: object;
+  } & Record<string, unknown>,
+>(schema: OperationSchema, filters: Filters | undefined) {
   if (!filters) {
     return {
-      queryKey: composeQueryKey(schema, undefined),
+      queryKey: composeBaseQueryKey(schema, undefined, undefined),
     };
   }
 
-  if (filters && 'queryKey' in filters && 'parameters' in filters) {
+  if ('queryKey' in filters && 'parameters' in filters) {
     throw new Error(
       `'composeQueryFilters': 'queryKey' and 'parameters' cannot be used together`
     );
   }
 
-  if ('queryKey' in filters) {
-    return filters;
-  }
+  const { infinite, parameters, ...filtersRest } = filters;
 
-  if ('parameters' in filters) {
-    const { parameters, ...filtersWithoutParameters } = filters;
+  if ('queryKey' in filtersRest) {
+    return filtersRest;
+  }
 
-    Object.assign(filtersWithoutParameters, {
-      queryKey: composeQueryKey(schema, parameters),
+  if (parameters) {
+    Object.assign(filtersRest, {
+      queryKey: infinite
+        ? composeInfiniteQueryKey(schema, parameters)
+        : composeQueryKey(schema, parameters),
     });
 
-    return filtersWithoutParameters;
+    return filtersRest;
   }
 
   return {
-    ...filters,
-    queryKey: composeQueryKey(schema, undefined),
+    ...filtersRest,
+    queryKey: infinite
+      ? composeInfiniteQueryKey(schema, undefined)
+      : composeQueryKey(schema, undefined),
   };
 }

package/src/lib/composeQueryKey.ts

@@ -1,9 +1,10 @@
 import type { ServiceOperationQueryKey } from '../ServiceOperation.js';
+import { composeBaseQueryKey } from './composeBaseQueryKey.js';
 import type { OperationSchema } from './requestFn.js';
 
 export function composeQueryKey<TSchema extends OperationSchema, TParams>(
   schema: TSchema,
   parameters: TParams | undefined
 ): ServiceOperationQueryKey<TSchema, TParams> {
-  return [schema, parameters ?? ({} as TParams)];
+  return composeBaseQueryKey(schema, parameters, false);
 }