@navios/react-query 0.1.0

package/src/utils/mutation-key.creator.mts

@@ -0,0 +1,61 @@
+import type { AnyEndpointConfig, UrlHasParams, UrlParams } from '@navios/common'
+import type { DataTag } from '@tanstack/react-query'
+
+import type { BaseQueryParams } from '../types.mjs'
+
+import { queryKeyCreator } from './query-key-creator.mjs'
+
+/**
+ * Creates a mutation key for a given endpoint configuration and options.
+ *
+ * @param {config: Config } config - The endpoint object containing the configuration.
+ * @param {Options} [options] - Optional query parameters with a default `processResponse` function that processes the response data.
+ *
+ * @returns {Object} An object containing the `mutationKey` function.
+ *
+ * The `mutationKey` function generates a mutation key based on the provided parameters:
+ * - If the URL has parameters (`HasParams` is `true`), it expects an object with `urlParams`.
+ * - The return type of the `mutationKey` function depends on the `processResponse` function in `options`.
+ *   If `processResponse` is defined, the return type is a `DataTag` containing the processed result and an error type.
+ *
+ * @example Example usage:
+ * ```typescript
+ * const createMutationKey = mutationKeyCreator(endpoint.config);
+ * const mutationKey = createMutationKey({ urlParams: { id: 123 } });
+ * ```
+ *
+ * @example Advanced usage:
+ * ```ts
+ * const createMutationKey = mutationKeyCreator(endpoint.config, {
+ *   processResponse: (data) => {
+ *     if (!data.success) {
+ *      throw new Error(data.message);
+ *     }
+ *     return data.data;
+ *   },
+ * });
+ * // We create a mutation that will be shared across the project for all passed userId
+ * const mutationKey = createMutationKey({ urlParams: { projectId: 123, userId: 'wildcard' } });
+ */
+export function mutationKeyCreator<
+  Config extends AnyEndpointConfig,
+  Options extends BaseQueryParams<Config>,
+  Url extends Config['url'] = Config['url'],
+  HasParams extends UrlHasParams<Url> = UrlHasParams<Url>,
+>(
+  config: Config,
+  options: Options = {
+    processResponse: (data) => data,
+  } as Options,
+): (
+  params: HasParams extends true ? { urlParams: UrlParams<Url> } : {},
+) => Options['processResponse'] extends (...args: any[]) => infer Result
+  ? DataTag<[Config['url']], Result, Error>
+  : never {
+  const queryKey = queryKeyCreator(config, options, false)
+
+  // @ts-expect-error We have correct types in return type
+  return (params) => {
+    return queryKey.filterKey(params)
+  }
+}

package/src/utils/query-key-creator.mts

@@ -0,0 +1,125 @@
+import type { AnyEndpointConfig, UrlHasParams, UrlParams } from '@navios/common'
+import type { DataTag, InfiniteData } from '@tanstack/react-query'
+import type { AnyZodObject, z } from 'zod'
+
+import { bindUrlParams } from '@navios/common'
+
+import type { BaseQueryParams } from '../types.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 type QueryKeyCreatorResult<
+  QuerySchema = undefined,
+  Url extends string = string,
+  Result = unknown,
+  IsInfinite extends boolean = false,
+  HasParams extends UrlHasParams<Url> = UrlHasParams<Url>,
+> = {
+  template: Split<Url, '/'>
+  dataTag: (
+    params: (HasParams extends true ? { urlParams: UrlParams<Url> } : {}) &
+      (QuerySchema extends AnyZodObject
+        ? { params: z.input<QuerySchema> }
+        : {}),
+  ) => DataTag<
+    Split<Url, '/'>,
+    IsInfinite extends true ? InfiniteData<Result> : Result,
+    Error
+  >
+  filterKey: (
+    params: HasParams extends true ? { urlParams: UrlParams<Url> } : {},
+  ) => DataTag<
+    Split<Url, '/'>,
+    IsInfinite extends true ? InfiniteData<Result> : Result,
+    Error
+  >
+  bindToUrl: (
+    params: (HasParams extends true ? { urlParams: UrlParams<Url> } : {}) &
+      (QuerySchema extends AnyZodObject
+        ? { params: z.infer<QuerySchema> }
+        : {}),
+  ) => string
+}
+
+export function queryKeyCreator<
+  Config extends AnyEndpointConfig,
+  Options extends BaseQueryParams<Config>,
+  IsInfinite extends boolean,
+  Url extends Config['url'] = Config['url'],
+  HasParams extends UrlHasParams<Url> = UrlHasParams<Url>,
+>(
+  config: Config,
+  options: Options,
+  isInfinite: IsInfinite,
+): QueryKeyCreatorResult<
+  Config['querySchema'],
+  Url,
+  Options['processResponse'] extends (...args: any[]) => infer Result
+    ? Result
+    : never,
+  IsInfinite,
+  HasParams
+> {
+  const url = config.url as Url
+  const urlParts = url.split('/').filter(Boolean) as Split<Url, '/'>
+  return {
+    template: urlParts,
+    // @ts-expect-error We have correct types in return type
+    dataTag: (params) => {
+      const queryParams =
+        params && 'querySchema' in config && 'params' in params
+          ? config.querySchema?.parse(params.params)
+          : []
+      return [
+        ...(options.keyPrefix ?? []),
+        ...urlParts.map((part) =>
+          part.startsWith('$')
+            ? // @ts-expect-error TS2339 We know that the urlParams are defined only if the url has params
+              params.urlParams[part.slice(1)].toString()
+            : part,
+        ),
+        ...(options.keySuffix ?? []),
+        queryParams ?? [],
+      ] as unknown as DataTag<
+        Split<Url, '/'>,
+        Options['processResponse'] extends (...args: any[]) => infer Result
+          ? IsInfinite extends true
+            ? InfiniteData<Result>
+            : Result
+          : never,
+        Error
+      >
+    },
+    // @ts-expect-error We have correct types in return type
+    filterKey: (params) => {
+      return [
+        ...(options.keyPrefix ?? []),
+        ...urlParts.map((part) =>
+          part.startsWith('$')
+            ? // @ts-expect-error TS2339 We know that the urlParams are defined only if the url has params
+              params.urlParams[part.slice(1)].toString()
+            : part,
+        ),
+        ...(options.keySuffix ?? []),
+      ] as unknown as DataTag<
+        Split<Url, '/'>,
+        Options['processResponse'] extends (...args: any[]) => infer Result
+          ? IsInfinite extends true
+            ? InfiniteData<Result>
+            : Result
+          : never,
+        Error
+      >
+    },
+
+    bindToUrl: (params) => {
+      return bindUrlParams<Url>(url, params ?? ({} as any))
+    },
+  }
+}