@pixotope/query 0.7.0 → 0.9.0

package/src/useQuery.ts

@@ -7,7 +7,7 @@ export interface QueryOptions<
   TSelectData = TData,
   Stateless extends true | undefined = undefined,
 > {
-  queryFn: (params: TParams | undefined | void) => Promise<TData>;
+  queryFn: (params: TParams | undefined | void, queryInfo: {key: TQueryKey | undefined, lastFetchedAt: number | undefined}) => Promise<TData>;
   onSuccess?: (data: TData) => Promise<void> | void;
   onError?: (error: TQueryError<TError>) => Promise<void> | void;
   onSettled?: (
@@ -189,7 +189,7 @@ export const useQuery = <
 
       try {
         const promises: RacePromises<TData>[] = [
-          queryFnRef.current(params),
+          queryFnRef.current(params, { key: queryKeyPassed, lastFetchedAt: lastFetchedAt.current ?? undefined }),
           ...(internalOptionsRef.current.timeout
             ? [
                 new Promise<RaceErrorReason>((resolve) =>

package/src/useSubscription.test.ts

@@ -0,0 +1,79 @@
+import { renderHook } from "@testing-library/react";
+import { vi, describe, expect, it } from "vitest";
+
+import {
+  buildServiceSubscriptionHook,
+  useSubscription,
+} from "./useSubscription";
+
+describe("useSubscription", () => {
+  it("should call subscription handler", () => {
+    const subscriptionHandler = vi.fn();
+    renderHook(() =>
+      useSubscription(subscriptionHandler, {
+        topic: "test",
+        service: "test",
+      })
+    );
+    expect(subscriptionHandler).toBeCalledTimes(1);
+  });
+
+  it("should correctly pass options to subscription handler", () => {
+    const subscriptionHandler = vi.fn();
+    renderHook(() =>
+      useSubscription(subscriptionHandler, {
+        topic: "test",
+        service: "test",
+        meta: { foo: "bar" },
+        maxDownwardDepth: 100,
+      })
+    );
+    expect(subscriptionHandler).toBeCalledTimes(1);
+    expect(subscriptionHandler).toHaveBeenCalledWith({
+      service: "test",
+      name: "test",
+      callback: expect.any(Function),
+      maxDownwardDepth: 100,
+      meta: { foo: "bar" },
+    });
+  });
+});
+
+describe("buildServiceSubscriptionHook", () => {
+  it("should correctly pass options to subscription handler", () => {
+    const subscriptionHandler = vi.fn();
+    const useHook = buildServiceSubscriptionHook(
+      subscriptionHandler,
+      () => "test"
+    );
+    renderHook(() => useHook({ topic: "test", meta: { foo: "bar" } }));
+    expect(subscriptionHandler).toHaveBeenCalledTimes(1);
+    expect(subscriptionHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        service: "test",
+        name: "test",
+        meta: { foo: "bar" },
+      })
+    );
+  });
+
+  it("should correctly handle overridden machine", () => {
+    const subscriptionHandler = vi.fn();
+    const useHook = buildServiceSubscriptionHook(
+      subscriptionHandler,
+      (machine) => machine || "test"
+    );
+    renderHook(() =>
+      useHook({
+        topic: "test",
+        machine: "myCustomMachineName",
+      })
+    );
+    expect(subscriptionHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        service: "myCustomMachineName",
+        name: "test",
+      })
+    );
+  });
+});

package/src/useSubscription.ts

@@ -7,6 +7,7 @@ export type SubscriptionOptions<
   TData,
   TMessage = unknown,
   Stateless extends true | undefined = undefined,
+  TMetadata extends {} = {},
 > = Omit<
   SubscriptionCoreOptions<TData, TMessage, Stateless>,
   "subscriberFn"
@@ -14,27 +15,35 @@ export type SubscriptionOptions<
   service: string;
   topic: string;
   maxDownwardDepth?: number;
+} & {
+  meta?: TMetadata;
 };
 
-export type TSubscriptionHandlerFunction<TMessage> = (opts: {
-  service: string;
-  name: string;
-  callback: (message: TMessage) => void;
-  maxDownwardDepth?: number;
-}) => () => void;
+export type TSubscriptionHandlerFunction<
+  TMessage,
+  TMetadata extends {} = {},
+> = (
+  opts: {
+    service: string;
+    name: string;
+    callback: (message: TMessage) => void;
+    maxDownwardDepth?: number;
+  } & { meta?: TMetadata }
+) => () => void;
 
 export function useSubscription<
   TData = unknown,
   TMessage = TData,
   Stateless extends true | undefined = undefined,
+  TMetadata extends {} = {},
 >(
-  subscriptionHandler: TSubscriptionHandlerFunction<TMessage>,
-  options: SubscriptionOptions<TData, TMessage, Stateless>
+  subscriptionHandler: TSubscriptionHandlerFunction<TMessage, TMetadata>,
+  options: SubscriptionOptions<TData, TMessage, Stateless, TMetadata>
 ) {
-  const { topic, service, maxDownwardDepth = 1000 } = options;
+  const { topic, service, maxDownwardDepth = 1000, meta, ...rest } = options;
 
   return useSubscriptionCore<TData, TMessage, Stateless>({
-    ...options,
+    ...rest,
     subscriberFn: (handler) => {
       const unsubscribe = subscriptionHandler({
         service,
@@ -43,6 +52,7 @@ export function useSubscription<
           handler(message);
         },
         maxDownwardDepth,
+        meta,
       });
 
       return unsubscribe;
@@ -50,8 +60,8 @@ export function useSubscription<
   });
 }
 
-export function buildServiceSubscriptionHook(
-  subscriptionHandler: TSubscriptionHandlerFunction<unknown>,
+export function buildServiceSubscriptionHook<TMetadata extends {} = {}>(
+  subscriptionHandler: TSubscriptionHandlerFunction<unknown, TMetadata>,
   targetMachine: (machine: string | undefined) => string
 ) {
   return function useSubscriptionBuilder<
@@ -60,7 +70,7 @@ export function buildServiceSubscriptionHook(
     Stateless extends true | undefined = undefined,
   >(
     options: Omit<
-      SubscriptionOptions<TData, TMessage, Stateless>,
+      SubscriptionOptions<TData, TMessage, Stateless, TMetadata>,
       "service"
     > & {
       machine?: string;

package/src/useSubscriptionCore.ts

@@ -8,7 +8,8 @@
 import { shallowEqual } from "@pixotope/utils/comparison";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
-type SubscriptionState = "idle" | "subscribed" | "subscribing";
+type SubscriptionState = "idle" | "subscribed" | "subscribing" | "error";
+
 export type MessageHandler<TMessage> = (message: TMessage) => void;
 export type Connection = {
   acknowledge: () => void;
@@ -36,8 +37,9 @@ export type SubscriptionCoreOptions<
    */
   enabled?: boolean;
   /**
-   * @description Function that will be called to compare the message with the
-   * previous message. If the function returns true, the message will be ignored.
+   * @description Function that will be called before the message is processed.
+   * Returning `true` will cause the message to not be set to state and call {@link onError} if provided.
+   * Status will be set to `error`.
    */
   compareOrThrow?: (data: TMessage) => boolean;
   /**
@@ -165,6 +167,7 @@ export function useSubscriptionCore<
   const handler = useCallback(
     async (message: TMessage) => {
       if (internalCallbacksRef.current.compareOrThrow?.(message)) {
+        updateStatus("error");
         internalCallbacksRef.current.onError?.(message);
 
         return;