@pyreon/query 0.10.0 → 0.11.0

package/src/tests/subscription.test.tsx

@@ -1,11 +1,7 @@
-import { signal } from '@pyreon/reactivity'
-import { mount } from '@pyreon/runtime-dom'
-import { QueryClient } from '@tanstack/query-core'
-import {
-  QueryClientProvider,
-  type UseSubscriptionResult,
-  useSubscription,
-} from '../index'
+import { signal } from "@pyreon/reactivity"
+import { mount } from "@pyreon/runtime-dom"
+import { QueryClient } from "@tanstack/query-core"
+import { QueryClientProvider, type UseSubscriptionResult, useSubscription } from "../index"
 
 // ─── Mock WebSocket ──────────────────────────────────────────────────────────
 
@@ -58,20 +54,20 @@ class MockWebSocketClass {
 
   _simulateOpen() {
     this.readyState = MockWebSocketClass.OPEN
-    this.onopen?.({ type: 'open' })
+    this.onopen?.({ type: "open" })
   }
 
   _simulateMessage(data: string) {
-    this.onmessage?.({ type: 'message', data } as unknown as MessageEvent)
+    this.onmessage?.({ type: "message", data } as unknown as MessageEvent)
   }
 
-  _simulateClose(code = 1000, reason = '') {
+  _simulateClose(code = 1000, reason = "") {
     this.readyState = MockWebSocketClass.CLOSED
-    this.onclose?.({ type: 'close', code, reason } as unknown as CloseEvent)
+    this.onclose?.({ type: "close", code, reason } as unknown as CloseEvent)
   }
 
   _simulateError() {
-    this.onerror?.({ type: 'error' })
+    this.onerror?.({ type: "error" })
   }
 }
 
@@ -96,7 +92,7 @@ function makeClient() {
 }
 
 function withProvider(client: QueryClient, component: () => void): () => void {
-  const el = document.createElement('div')
+  const el = document.createElement("div")
   document.body.appendChild(el)
   const unmount = mount(
     <QueryClientProvider client={client}>
@@ -119,53 +115,53 @@ function lastMockWS(): MockWebSocket {
 
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
-describe('useSubscription', () => {
+describe("useSubscription", () => {
   beforeEach(() => {
     mockInstances = []
   })
 
-  it('connects to the WebSocket URL', () => {
+  it("connects to the WebSocket URL", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
 
     expect(mockInstances).toHaveLength(1)
-    expect(lastMockWS().url).toBe('wss://example.com/ws')
-    expect(sub!.status()).toBe('connecting')
+    expect(lastMockWS().url).toBe("wss://example.com/ws")
+    expect(sub!.status()).toBe("connecting")
 
     unmount()
   })
 
-  it('status transitions to connected on open', () => {
+  it("status transitions to connected on open", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
 
     lastMockWS()._simulateOpen()
-    expect(sub!.status()).toBe('connected')
+    expect(sub!.status()).toBe("connected")
 
     unmount()
   })
 
-  it('calls onMessage with event and queryClient', () => {
+  it("calls onMessage with event and queryClient", () => {
     const client = makeClient()
     const messages: string[] = []
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: (event, qc) => {
           messages.push(event.data as string)
           expect(qc).toBe(client)
@@ -174,75 +170,75 @@ describe('useSubscription', () => {
     })
 
     lastMockWS()._simulateOpen()
-    lastMockWS()._simulateMessage('hello')
-    lastMockWS()._simulateMessage('world')
+    lastMockWS()._simulateMessage("hello")
+    lastMockWS()._simulateMessage("world")
 
-    expect(messages).toEqual(['hello', 'world'])
+    expect(messages).toEqual(["hello", "world"])
     unmount()
   })
 
-  it('invalidates queries on message', () => {
+  it("invalidates queries on message", () => {
     const client = makeClient()
-    const invalidateSpy = vi.spyOn(client, 'invalidateQueries')
+    const invalidateSpy = vi.spyOn(client, "invalidateQueries")
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: (_event, qc) => {
-          qc.invalidateQueries({ queryKey: ['orders'] })
+          qc.invalidateQueries({ queryKey: ["orders"] })
         },
       })
     })
 
     lastMockWS()._simulateOpen()
-    lastMockWS()._simulateMessage('order-updated')
+    lastMockWS()._simulateMessage("order-updated")
 
-    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ['orders'] })
+    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ["orders"] })
     unmount()
   })
 
-  it('send() sends data through WebSocket', () => {
+  it("send() sends data through WebSocket", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
 
     lastMockWS()._simulateOpen()
-    sub!.send('test-message')
+    sub!.send("test-message")
 
-    expect(lastMockWS().send).toHaveBeenCalledWith('test-message')
+    expect(lastMockWS().send).toHaveBeenCalledWith("test-message")
     unmount()
   })
 
-  it('send() is a no-op when not connected', () => {
+  it("send() is a no-op when not connected", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
 
     // Still connecting — send should not throw
-    sub!.send('ignored')
+    sub!.send("ignored")
     expect(lastMockWS().send).not.toHaveBeenCalled()
     unmount()
   })
 
-  it('close() disconnects and sets status', () => {
+  it("close() disconnects and sets status", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
@@ -250,18 +246,18 @@ describe('useSubscription', () => {
     lastMockWS()._simulateOpen()
     sub!.close()
 
-    expect(sub!.status()).toBe('disconnected')
+    expect(sub!.status()).toBe("disconnected")
     expect(lastMockWS().close).toHaveBeenCalled()
     unmount()
   })
 
-  it('status transitions to disconnected on close', () => {
+  it("status transitions to disconnected on close", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: false,
       })
@@ -270,18 +266,18 @@ describe('useSubscription', () => {
     lastMockWS()._simulateOpen()
     lastMockWS()._simulateClose()
 
-    expect(sub!.status()).toBe('disconnected')
+    expect(sub!.status()).toBe("disconnected")
     unmount()
   })
 
-  it('status transitions to error on error', () => {
+  it("status transitions to error on error", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
     const errors: Event[] = []
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: false,
         onError: (e) => errors.push(e as Event),
@@ -289,18 +285,18 @@ describe('useSubscription', () => {
     })
 
     lastMockWS()._simulateError()
-    expect(sub!.status()).toBe('error')
+    expect(sub!.status()).toBe("error")
     expect(errors).toHaveLength(1)
     unmount()
   })
 
-  it('calls onOpen callback', () => {
+  it("calls onOpen callback", () => {
     const client = makeClient()
     let opened = false
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         onOpen: () => {
           opened = true
@@ -313,13 +309,13 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('calls onClose callback', () => {
+  it("calls onClose callback", () => {
     const client = makeClient()
     let closed = false
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: false,
         onClose: () => {
@@ -334,12 +330,12 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('auto-reconnects on unexpected close', async () => {
+  it("auto-reconnects on unexpected close", async () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: true,
         reconnectDelay: 50,
@@ -357,12 +353,12 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('does not reconnect when reconnect is false', async () => {
+  it("does not reconnect when reconnect is false", async () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: false,
       })
@@ -376,13 +372,13 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('does not reconnect after intentional close()', async () => {
+  it("does not reconnect after intentional close()", async () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: true,
         reconnectDelay: 50,
@@ -397,12 +393,12 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('respects maxReconnectAttempts', async () => {
+  it("respects maxReconnectAttempts", async () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: true,
         reconnectDelay: 10,
@@ -431,13 +427,13 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('reconnect() resets attempts and reconnects', async () => {
+  it("reconnect() resets attempts and reconnects", async () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: false,
       })
@@ -450,35 +446,35 @@ describe('useSubscription', () => {
 
     sub!.reconnect()
     expect(mockInstances).toHaveLength(2)
-    expect(sub!.status()).toBe('connecting')
+    expect(sub!.status()).toBe("connecting")
 
     unmount()
   })
 
-  it('enabled: false prevents connection', () => {
+  it("enabled: false prevents connection", () => {
     const client = makeClient()
     let sub: UseSubscriptionResult | null = null
 
     const unmount = withProvider(client, () => {
       sub = useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         enabled: false,
       })
     })
 
     expect(mockInstances).toHaveLength(0)
-    expect(sub!.status()).toBe('disconnected')
+    expect(sub!.status()).toBe("disconnected")
     unmount()
   })
 
-  it('reactive enabled signal controls connection', async () => {
+  it("reactive enabled signal controls connection", async () => {
     const client = makeClient()
     const enabled = signal(false)
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         enabled: () => enabled(),
       })
@@ -493,9 +489,9 @@ describe('useSubscription', () => {
     unmount()
   })
 
-  it('reactive URL reconnects when URL changes', () => {
+  it("reactive URL reconnects when URL changes", () => {
     const client = makeClient()
-    const url = signal('wss://example.com/ws1')
+    const url = signal("wss://example.com/ws1")
 
     const unmount = withProvider(client, () => {
       useSubscription({
@@ -505,37 +501,37 @@ describe('useSubscription', () => {
     })
 
     expect(mockInstances).toHaveLength(1)
-    expect(lastMockWS().url).toBe('wss://example.com/ws1')
+    expect(lastMockWS().url).toBe("wss://example.com/ws1")
 
-    url.set('wss://example.com/ws2')
+    url.set("wss://example.com/ws2")
 
     expect(mockInstances).toHaveLength(2)
-    expect(lastMockWS().url).toBe('wss://example.com/ws2')
+    expect(lastMockWS().url).toBe("wss://example.com/ws2")
 
     unmount()
   })
 
-  it('supports WebSocket protocols', () => {
+  it("supports WebSocket protocols", () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
-        protocols: ['graphql-ws'],
+        url: "wss://example.com/ws",
+        protocols: ["graphql-ws"],
         onMessage: noop,
       })
     })
 
-    expect(lastMockWS().protocols).toEqual(['graphql-ws'])
+    expect(lastMockWS().protocols).toEqual(["graphql-ws"])
     unmount()
   })
 
-  it('cleans up on unmount', () => {
+  it("cleans up on unmount", () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
       })
     })
@@ -547,12 +543,134 @@ describe('useSubscription', () => {
     expect(ws.close).toHaveBeenCalled()
   })
 
-  it('resets reconnect count on successful connection', async () => {
+  // ─── Error handling & cleanup ──────────────────────────────────────────────
+
+  it("reconnects after connection drop (simulated close)", async () => {
+    const client = makeClient()
+    let sub: UseSubscriptionResult | null = null
+
+    const unmount = withProvider(client, () => {
+      sub = useSubscription({
+        url: "wss://example.com/ws",
+        onMessage: noop,
+        reconnect: true,
+        reconnectDelay: 20,
+      })
+    })
+
+    // Establish connection then drop it
+    lastMockWS()._simulateOpen()
+    expect(sub!.status()).toBe("connected")
+
+    // Simulate unexpected connection drop
+    lastMockWS()._simulateClose(1006, "abnormal closure")
+
+    // Wait for reconnect attempt
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(mockInstances).toHaveLength(2)
+    expect(lastMockWS().url).toBe("wss://example.com/ws")
+    expect(sub!.status()).toBe("connecting")
+
+    unmount()
+  })
+
+  it("message handler that throws does not crash the subscription", () => {
+    const client = makeClient()
+    let sub: UseSubscriptionResult | null = null
+
+    const unmount = withProvider(client, () => {
+      sub = useSubscription({
+        url: "wss://example.com/ws",
+        onMessage: () => {
+          throw new Error("handler boom")
+        },
+      })
+    })
+
+    lastMockWS()._simulateOpen()
+
+    // Should not throw — the error is caught internally
+    expect(() => lastMockWS()._simulateMessage("test")).not.toThrow()
+
+    // Subscription should still be connected
+    expect(sub!.status()).toBe("connected")
+
+    unmount()
+  })
+
+  it("WebSocket is closed on unmount (cleanup)", () => {
+    const client = makeClient()
+
+    const unmount = withProvider(client, () => {
+      useSubscription({
+        url: "wss://example.com/ws",
+        onMessage: noop,
+      })
+    })
+
+    lastMockWS()._simulateOpen()
+    const ws = lastMockWS()
+
+    expect(ws.readyState).toBe(MockWebSocketClass.OPEN)
+
+    unmount()
+
+    expect(ws.close).toHaveBeenCalled()
+    expect(ws.readyState).toBe(MockWebSocketClass.CLOSED)
+  })
+
+  it("no reconnect attempts after unmount", async () => {
+    const client = makeClient()
+
+    const unmount = withProvider(client, () => {
+      useSubscription({
+        url: "wss://example.com/ws",
+        onMessage: noop,
+        reconnect: true,
+        reconnectDelay: 20,
+      })
+    })
+
+    lastMockWS()._simulateOpen()
+    unmount()
+
+    // Wait longer than reconnectDelay — should not create new connections
+    await new Promise((r) => setTimeout(r, 80))
+    expect(mockInstances).toHaveLength(1)
+  })
+
+  it("send when disconnected does not crash", () => {
+    const client = makeClient()
+    let sub: UseSubscriptionResult | null = null
+
+    const unmount = withProvider(client, () => {
+      sub = useSubscription({
+        url: "wss://example.com/ws",
+        onMessage: noop,
+        reconnect: false,
+      })
+    })
+
+    lastMockWS()._simulateOpen()
+    lastMockWS()._simulateClose()
+
+    expect(sub!.status()).toBe("disconnected")
+
+    // Should not throw
+    expect(() => sub!.send("test")).not.toThrow()
+    // The underlying WS send should not have been called (only the one from close)
+    expect(lastMockWS().send).not.toHaveBeenCalled()
+
+    unmount()
+  })
+
+  it("resets reconnect count on successful connection", async () => {
     const client = makeClient()
 
     const unmount = withProvider(client, () => {
       useSubscription({
-        url: 'wss://example.com/ws',
+        url: "wss://example.com/ws",
         onMessage: noop,
         reconnect: true,
         reconnectDelay: 10,

package/src/use-infinite-query.ts

@@ -1,6 +1,6 @@
-import { onUnmount } from '@pyreon/core'
-import type { Signal } from '@pyreon/reactivity'
-import { batch, effect, signal } from '@pyreon/reactivity'
+import { onUnmount } from "@pyreon/core"
+import type { Signal } from "@pyreon/reactivity"
+import { batch, effect, signal } from "@pyreon/reactivity"
 import type {
   DefaultError,
   InfiniteData,
@@ -8,18 +8,16 @@ import type {
   InfiniteQueryObserverResult,
   QueryKey,
   QueryObserverResult,
-} from '@tanstack/query-core'
-import { InfiniteQueryObserver } from '@tanstack/query-core'
-import { useQueryClient } from './query-client'
+} from "@tanstack/query-core"
+import { InfiniteQueryObserver } from "@tanstack/query-core"
+import { useQueryClient } from "./query-client"
 
 export interface UseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
   /** Raw signal — full observer result. */
-  result: Signal<
-    InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>
-  >
+  result: Signal<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>
   data: Signal<InfiniteData<TQueryFnData> | undefined>
   error: Signal<TError | null>
-  status: Signal<'pending' | 'error' | 'success'>
+  status: Signal<"pending" | "error" | "success">
   isPending: Signal<boolean>
   isLoading: Signal<boolean>
   isFetching: Signal<boolean>
@@ -29,15 +27,9 @@ export interface UseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
   isSuccess: Signal<boolean>
   hasNextPage: Signal<boolean>
   hasPreviousPage: Signal<boolean>
-  fetchNextPage: () => Promise<
-    InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>
-  >
-  fetchPreviousPage: () => Promise<
-    InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>
-  >
-  refetch: () => Promise<
-    QueryObserverResult<InfiniteData<TQueryFnData>, TError>
-  >
+  fetchNextPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>
+  fetchPreviousPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>
+  refetch: () => Promise<QueryObserverResult<InfiniteData<TQueryFnData>, TError>>
 }
 
 /**

package/src/use-is-fetching.ts

@@ -1,8 +1,8 @@
-import { onUnmount } from '@pyreon/core'
-import type { Signal } from '@pyreon/reactivity'
-import { signal } from '@pyreon/reactivity'
-import type { MutationFilters, QueryFilters } from '@tanstack/query-core'
-import { useQueryClient } from './query-client'
+import { onUnmount } from "@pyreon/core"
+import type { Signal } from "@pyreon/reactivity"
+import { signal } from "@pyreon/reactivity"
+import type { MutationFilters, QueryFilters } from "@tanstack/query-core"
+import { useQueryClient } from "./query-client"
 
 /**
  * Returns a signal that tracks how many queries are currently in-flight.