@navios/react-query 0.1.0

package/src/make-mutation.mts

@@ -0,0 +1,121 @@
+import type {
+  AbstractEndpoint,
+  AnyEndpointConfig,
+  UrlHasParams,
+  UrlParams,
+} from '@navios/common'
+import type { UseMutationResult } from '@tanstack/react-query'
+import type { z } from 'zod'
+
+import {
+  useIsMutating,
+  useMutation,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import type { BaseMutationArgs, BaseMutationParams } from './types.mjs'
+
+import { mutationKeyCreator } from './index.mjs'
+
+export function makeMutation<
+  Config extends AnyEndpointConfig,
+  TData = unknown,
+  TVariables extends BaseMutationArgs<Config> = BaseMutationArgs<Config>,
+  TResponse = z.output<Config['responseSchema']>,
+  TContext = unknown,
+  UseKey extends boolean = false,
+>(
+  endpoint: AbstractEndpoint<Config>,
+  options: BaseMutationParams<
+    Config,
+    TData,
+    TVariables,
+    TResponse,
+    TContext,
+    UseKey
+  >,
+) {
+  const config = endpoint.config
+
+  const mutationKey = mutationKeyCreator(config, options)
+  const result = (
+    keyParams: UseKey extends true
+      ? UrlHasParams<Config['url']> extends true
+        ? UrlParams<Config['url']>
+        : never
+      : never,
+  ): UseMutationResult<TData, Error, BaseMutationArgs<Config>> => {
+    const queryClient = useQueryClient()
+    const {
+      useKey,
+      useContext,
+      onError,
+      onSuccess,
+      keyPrefix,
+      keySuffix,
+      processResponse,
+      ...rest
+    } = options
+
+    const context = useContext?.() as TContext
+
+    // @ts-expect-error The types match
+    return useMutation(
+      {
+        ...rest,
+        mutationKey: useKey
+          ? mutationKey({
+              urlParams: keyParams,
+            })
+          : undefined,
+        scope: useKey
+          ? {
+              id: JSON.stringify(
+                mutationKey({
+                  urlParams: keyParams,
+                }),
+              ),
+            }
+          : undefined,
+        async mutationFn(params: TVariables) {
+          const response = await endpoint(params)
+
+          return processResponse(response) as TData
+        },
+        onSuccess: onSuccess
+          ? (data: TData, variables: TVariables) => {
+              return onSuccess?.(queryClient, data, variables, context)
+            }
+          : undefined,
+        onError: onError
+          ? (err: Error, variables: TVariables) => {
+              return onError?.(queryClient, err, variables, context)
+            }
+          : undefined,
+      },
+      queryClient,
+    )
+  }
+  result.useIsMutating = (
+    keyParams: UseKey extends true
+      ? UrlHasParams<Config['url']> extends true
+        ? UrlParams<Config['url']>
+        : never
+      : never,
+  ): boolean => {
+    if (!options.useKey) {
+      throw new Error(
+        'useIsMutating can only be used when useKey is set to true',
+      )
+    }
+    const isMutating = useIsMutating({
+      mutationKey: mutationKey({
+        urlParams: keyParams,
+      }),
+    })
+    return isMutating > 0
+  }
+  result.mutationKey = mutationKey
+
+  return result
+}

package/src/make-query-options.mts

@@ -0,0 +1,113 @@
+import type { AbstractEndpoint, AnyEndpointConfig } from '@navios/common'
+import type {
+  DataTag,
+  QueryClient,
+  UseQueryOptions,
+  UseSuspenseQueryOptions,
+} from '@tanstack/react-query'
+
+import {
+  queryOptions,
+  useInfiniteQuery,
+  useSuspenseInfiniteQuery,
+} from '@tanstack/react-query'
+
+import type { BaseQueryArgs, BaseQueryParams } from './types.mjs'
+import type { ClientQueryArgs } from './types/index.mjs'
+
+import { queryKeyCreator } from './utils/query-key-creator.mjs'
+
+type Split<S extends string, D extends string> = string extends S
+  ? string[]
+  : S extends ''
+    ? []
+    : S extends `${infer T}${D}${infer U}`
+      ? [T, ...Split<U, D>]
+      : [S]
+
+export function makeQueryOptions<
+  Config extends AnyEndpointConfig,
+  Options extends BaseQueryParams<Config>,
+  BaseQuery extends Omit<
+    UseQueryOptions<ReturnType<Options['processResponse']>, Error, any>,
+    | 'queryKey'
+    | 'queryFn'
+    | 'getNextPageParam'
+    | 'initialPageParam'
+    | 'enabled'
+    | 'throwOnError'
+    | 'placeholderData'
+  >,
+>(
+  endpoint: AbstractEndpoint<Config>,
+  options: Options,
+  baseQuery: BaseQuery = {} as BaseQuery,
+) {
+  const config = endpoint.config
+  // Let's hack the url to be a string for now
+  const queryKey = queryKeyCreator(config, options, false)
+  const processResponse = options.processResponse
+
+  const result = (
+    params: BaseQueryArgs<Config>,
+  ): Options['processResponse'] extends (...args: any[]) => infer Result
+    ? UseSuspenseQueryOptions<
+        Result,
+        Error,
+        BaseQuery['select'] extends (...args: any[]) => infer T ? T : Result,
+        DataTag<Split<Config['url'], '/'>, Result, Error>
+      >
+    : never => {
+    // @ts-expect-error TS2322 We know that the processResponse is defined
+    return queryOptions({
+      queryKey: queryKey.dataTag(params),
+      queryFn: async ({ signal }) => {
+        let result
+        try {
+          result = await endpoint({
+            signal,
+            ...params,
+          })
+        } catch (err) {
+          if (options.onFail) {
+            options.onFail(err)
+          }
+          throw err
+        }
+
+        return processResponse(result)
+      },
+      ...baseQuery,
+    })
+  }
+  result.queryKey = queryKey
+  result.use = (params: ClientQueryArgs) => {
+    // @ts-expect-error We add additional function to the result
+    return useInfiniteQuery(result(params))
+  }
+
+  result.useSuspense = (params: ClientQueryArgs) => {
+    // @ts-expect-error We add additional function to the result
+    return useSuspenseInfiniteQuery(result(params))
+  }
+
+  result.invalidate = (queryClient: QueryClient, params: ClientQueryArgs) => {
+    return queryClient.invalidateQueries({
+      // @ts-expect-error We add additional function to the result
+      queryKey: result.queryKey.dataTag(params),
+    })
+  }
+
+  result.invalidateAll = (
+    queryClient: QueryClient,
+    params: ClientQueryArgs,
+  ) => {
+    return queryClient.invalidateQueries({
+      // @ts-expect-error We add additional function to the result
+      queryKey: result.queryKey.filterKey(params),
+      exact: false,
+    })
+  }
+
+  return result
+}