@orpc/experimental-publisher 0.0.0 → 0.0.1

package/dist/adapters/ioredis.d.mts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions, StandardRPCJsonSerializer, StandardRPCJsonSerializedMetaItem } from '@orpc/client/standard';
+import { ThrowableError } from '@orpc/shared';
 import Redis from 'ioredis';
 import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '../index.mjs';
 import { getEventMeta } from '@orpc/standard-server';
-import '@orpc/shared';
 
 type SerializedPayload = {
     json: object;
@@ -46,9 +46,13 @@ declare class IORedisPublisher<T extends Record<string, object>> extends Publish
     protected readonly prefix: string;
     protected readonly serializer: StandardRPCJsonSerializer;
     protected readonly retentionSeconds: number;
-    protected readonly listenerPromiseMap: Map<string, Promise<any>>;
-    protected readonly listenersMap: Map<string, Set<(payload: any) => void>>;
-    protected redisListener: ((channel: string, message: string) => void) | undefined;
+    protected readonly subscriptionPromiseMap: Map<string, Promise<any>>;
+    protected readonly listenersMap: Map<string, ((payload: any) => void)[]>;
+    protected readonly onErrorsMap: Map<string, ((error: ThrowableError) => void)[]>;
+    protected redisListenerAndOnError: undefined | {
+        listener: (channel: string, message: string) => void;
+        onError: (error: ThrowableError) => void;
+    };
     protected get isResumeEnabled(): boolean;
     /**
      * The exactness of the `XTRIM` command.
@@ -64,9 +68,9 @@ declare class IORedisPublisher<T extends Record<string, object>> extends Publish
      */
     get size(): number;
     constructor({ commander, listener, resumeRetentionSeconds, prefix, ...options }: IORedisPublisherOptions);
-    protected lastCleanupTimes: Map<string, number>;
+    protected lastCleanupTimeMap: Map<string, number>;
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     protected prefixKey(key: string): string;
     protected serializePayload(payload: object): SerializedPayload;
     protected deserializePayload(id: string | undefined, { json, meta, eventMeta }: SerializedPayload): any;

package/dist/adapters/ioredis.d.ts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions, StandardRPCJsonSerializer, StandardRPCJsonSerializedMetaItem } from '@orpc/client/standard';
+import { ThrowableError } from '@orpc/shared';
 import Redis from 'ioredis';
 import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '../index.js';
 import { getEventMeta } from '@orpc/standard-server';
-import '@orpc/shared';
 
 type SerializedPayload = {
     json: object;
@@ -46,9 +46,13 @@ declare class IORedisPublisher<T extends Record<string, object>> extends Publish
     protected readonly prefix: string;
     protected readonly serializer: StandardRPCJsonSerializer;
     protected readonly retentionSeconds: number;
-    protected readonly listenerPromiseMap: Map<string, Promise<any>>;
-    protected readonly listenersMap: Map<string, Set<(payload: any) => void>>;
-    protected redisListener: ((channel: string, message: string) => void) | undefined;
+    protected readonly subscriptionPromiseMap: Map<string, Promise<any>>;
+    protected readonly listenersMap: Map<string, ((payload: any) => void)[]>;
+    protected readonly onErrorsMap: Map<string, ((error: ThrowableError) => void)[]>;
+    protected redisListenerAndOnError: undefined | {
+        listener: (channel: string, message: string) => void;
+        onError: (error: ThrowableError) => void;
+    };
     protected get isResumeEnabled(): boolean;
     /**
      * The exactness of the `XTRIM` command.
@@ -64,9 +68,9 @@ declare class IORedisPublisher<T extends Record<string, object>> extends Publish
      */
     get size(): number;
     constructor({ commander, listener, resumeRetentionSeconds, prefix, ...options }: IORedisPublisherOptions);
-    protected lastCleanupTimes: Map<string, number>;
+    protected lastCleanupTimeMap: Map<string, number>;
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     protected prefixKey(key: string): string;
     protected serializePayload(payload: object): SerializedPayload;
     protected deserializePayload(id: string | undefined, { json, meta, eventMeta }: SerializedPayload): any;

package/dist/adapters/ioredis.mjs

@@ -1,7 +1,7 @@
 import { StandardRPCJsonSerializer } from '@orpc/client/standard';
-import { stringifyJSON } from '@orpc/shared';
+import { fallback, stringifyJSON, once } from '@orpc/shared';
 import { getEventMeta, withEventMeta } from '@orpc/standard-server';
-import { P as Publisher } from '../shared/experimental-publisher.BOyYBkgn.mjs';
+import { P as Publisher } from '../shared/experimental-publisher.BtlOkhPO.mjs';
 
 class IORedisPublisher extends Publisher {
   commander;
@@ -9,9 +9,10 @@ class IORedisPublisher extends Publisher {
   prefix;
   serializer;
   retentionSeconds;
-  listenerPromiseMap = /* @__PURE__ */ new Map();
+  subscriptionPromiseMap = /* @__PURE__ */ new Map();
   listenersMap = /* @__PURE__ */ new Map();
-  redisListener;
+  onErrorsMap = /* @__PURE__ */ new Map();
+  redisListenerAndOnError;
   get isResumeEnabled() {
     return Number.isFinite(this.retentionSeconds) && this.retentionSeconds > 0;
   }
@@ -28,9 +29,12 @@ class IORedisPublisher extends Publisher {
    *
    */
   get size() {
-    let size = this.redisListener ? 1 : 0;
+    let size = this.redisListenerAndOnError ? 1 : 0;
     for (const listeners of this.listenersMap) {
-      size += listeners[1].size || 1;
+      size += listeners[1].length || 1;
+    }
+    for (const onErrors of this.onErrorsMap) {
+      size += onErrors[1].length || 1;
     }
     return size;
   }
@@ -38,24 +42,24 @@ class IORedisPublisher extends Publisher {
     super(options);
     this.commander = commander;
     this.listener = listener;
-    this.prefix = prefix ?? "orpc:publisher:";
+    this.prefix = fallback(prefix, "orpc:publisher:");
     this.retentionSeconds = resumeRetentionSeconds ?? Number.NaN;
     this.serializer = new StandardRPCJsonSerializer(options);
   }
-  lastCleanupTimes = /* @__PURE__ */ new Map();
+  lastCleanupTimeMap = /* @__PURE__ */ new Map();
   async publish(event, payload) {
     const key = this.prefixKey(event);
     const serialized = this.serializePayload(payload);
     let id;
     if (this.isResumeEnabled) {
       const now = Date.now();
-      for (const [key2, lastCleanupTime] of this.lastCleanupTimes) {
+      for (const [mapKey, lastCleanupTime] of this.lastCleanupTimeMap) {
         if (lastCleanupTime + this.retentionSeconds * 1e3 < now) {
-          this.lastCleanupTimes.delete(key2);
+          this.lastCleanupTimeMap.delete(mapKey);
         }
       }
-      if (!this.lastCleanupTimes.has(key)) {
-        this.lastCleanupTimes.set(key, now);
+      if (!this.lastCleanupTimeMap.has(key)) {
+        this.lastCleanupTimeMap.set(key, now);
         const result = await this.commander.multi().xadd(key, "*", "data", stringifyJSON(serialized)).xtrim(key, "MINID", this.xtrimExactness, `${now - this.retentionSeconds * 1e3}-0`).expire(key, this.retentionSeconds * 2).exec();
         if (result) {
           for (const [error] of result) {
@@ -72,9 +76,8 @@ class IORedisPublisher extends Publisher {
     }
     await this.commander.publish(key, stringifyJSON({ ...serialized, id }));
   }
-  async subscribeListener(event, originalListener, options) {
+  async subscribeListener(event, originalListener, { lastEventId, onError } = {}) {
     const key = this.prefixKey(event);
-    const lastEventId = options?.lastEventId;
     let pendingPayloads = [];
     const resumePayloadIds = /* @__PURE__ */ new Set();
     const listener = (payload) => {
@@ -88,8 +91,15 @@ class IORedisPublisher extends Publisher {
       }
       originalListener(payload);
     };
-    if (!this.redisListener) {
-      this.redisListener = (channel, message) => {
+    if (!this.redisListenerAndOnError) {
+      const redisOnError = (error) => {
+        for (const [_, onErrors] of this.onErrorsMap) {
+          for (const onError2 of onErrors) {
+            onError2(error);
+          }
+        }
+      };
+      const redisListener = (channel, message) => {
         try {
           const listeners2 = this.listenersMap.get(channel);
           if (listeners2) {
@@ -99,24 +109,47 @@ class IORedisPublisher extends Publisher {
               listener2(payload);
             }
           }
-        } catch {
+        } catch (error) {
+          const onErrors = this.onErrorsMap.get(channel);
+          if (onErrors) {
+            for (const onError2 of onErrors) {
+              onError2(error);
+            }
+          }
         }
       };
-      this.listener.on("message", this.redisListener);
+      this.redisListenerAndOnError = { listener: redisListener, onError: redisOnError };
+      this.listener.on("message", redisListener);
+      this.listener.on("error", redisOnError);
+    }
+    const subscriptionPromise = this.subscriptionPromiseMap.get(key);
+    if (subscriptionPromise) {
+      await subscriptionPromise;
     }
-    await this.listenerPromiseMap.get(key);
     let listeners = this.listenersMap.get(key);
     if (!listeners) {
       try {
         const promise = this.listener.subscribe(key);
-        this.listenerPromiseMap.set(key, promise);
+        this.subscriptionPromiseMap.set(key, promise);
         await promise;
-        this.listenersMap.set(key, listeners = /* @__PURE__ */ new Set());
+        this.listenersMap.set(key, listeners = []);
       } finally {
-        this.listenerPromiseMap.delete(key);
+        this.subscriptionPromiseMap.delete(key);
+        if (this.listenersMap.size === 0) {
+          this.listener.off("message", this.redisListenerAndOnError.listener);
+          this.listener.off("error", this.redisListenerAndOnError.onError);
+          this.redisListenerAndOnError = void 0;
+        }
+      }
+    }
+    listeners.push(listener);
+    if (onError) {
+      let onErrors = this.onErrorsMap.get(key);
+      if (!onErrors) {
+        this.onErrorsMap.set(key, onErrors = []);
       }
+      onErrors.push(onError);
     }
-    listeners.add(listener);
     void (async () => {
       try {
         if (this.isResumeEnabled && typeof lastEventId === "string") {
@@ -131,7 +164,8 @@ class IORedisPublisher extends Publisher {
             }
           }
         }
-      } catch {
+      } catch (error) {
+        onError?.(error);
       } finally {
         const pending = pendingPayloads;
         pendingPayloads = void 0;
@@ -140,13 +174,27 @@ class IORedisPublisher extends Publisher {
         }
       }
     })();
+    const cleanupListeners = once(() => {
+      listeners.splice(listeners.indexOf(listener), 1);
+      if (onError) {
+        const onErrors = this.onErrorsMap.get(key);
+        if (onErrors) {
+          const index = onErrors.indexOf(onError);
+          if (index !== -1) {
+            onErrors.splice(index, 1);
+          }
+        }
+      }
+    });
     return async () => {
-      listeners.delete(listener);
-      if (listeners.size === 0) {
+      cleanupListeners();
+      if (listeners.length === 0) {
         this.listenersMap.delete(key);
-        if (this.redisListener && this.listenersMap.size === 0) {
-          this.listener.off("message", this.redisListener);
-          this.redisListener = void 0;
+        this.onErrorsMap.delete(key);
+        if (this.redisListenerAndOnError && this.listenersMap.size === 0) {
+          this.listener.off("message", this.redisListenerAndOnError.listener);
+          this.listener.off("error", this.redisListenerAndOnError.onError);
+          this.redisListenerAndOnError = void 0;
         }
         await this.listener.unsubscribe(key);
       }

package/dist/adapters/memory.d.mts

@@ -19,7 +19,7 @@ declare class MemoryPublisher<T extends Record<string, object>> extends Publishe
     private readonly eventPublisher;
     private readonly idGenerator;
     private readonly retentionSeconds;
-    private readonly events;
+    private readonly eventsMap;
     /**
      * Useful for measuring memory usage.
      *

package/dist/adapters/memory.d.ts

@@ -19,7 +19,7 @@ declare class MemoryPublisher<T extends Record<string, object>> extends Publishe
     private readonly eventPublisher;
     private readonly idGenerator;
     private readonly retentionSeconds;
-    private readonly events;
+    private readonly eventsMap;
     /**
      * Useful for measuring memory usage.
      *

package/dist/adapters/memory.mjs

@@ -1,12 +1,12 @@
 import { EventPublisher, SequentialIdGenerator, compareSequentialIds } from '@orpc/shared';
 import { withEventMeta, getEventMeta } from '@orpc/standard-server';
-import { P as Publisher } from '../shared/experimental-publisher.BOyYBkgn.mjs';
+import { P as Publisher } from '../shared/experimental-publisher.BtlOkhPO.mjs';
 
 class MemoryPublisher extends Publisher {
   eventPublisher = new EventPublisher();
   idGenerator = new SequentialIdGenerator();
   retentionSeconds;
-  events = /* @__PURE__ */ new Map();
+  eventsMap = /* @__PURE__ */ new Map();
   /**
    * Useful for measuring memory usage.
    *
@@ -15,7 +15,7 @@ class MemoryPublisher extends Publisher {
    */
   get size() {
     let size = this.eventPublisher.size;
-    for (const events of this.events) {
+    for (const events of this.eventsMap) {
       size += events[1].length || 1;
     }
     return size;
@@ -32,9 +32,9 @@ class MemoryPublisher extends Publisher {
     if (this.isResumeEnabled) {
       const now = Date.now();
       const expiresAt = now + this.retentionSeconds * 1e3;
-      let events = this.events.get(event);
+      let events = this.eventsMap.get(event);
       if (!events) {
-        this.events.set(event, events = []);
+        this.eventsMap.set(event, events = []);
       }
       payload = withEventMeta(payload, { ...getEventMeta(payload), id: this.idGenerator.generate() });
       events.push({ expiresAt, payload });
@@ -43,7 +43,7 @@ class MemoryPublisher extends Publisher {
   }
   async subscribeListener(event, listener, options) {
     if (this.isResumeEnabled && typeof options?.lastEventId === "string") {
-      const events = this.events.get(event);
+      const events = this.eventsMap.get(event);
       if (events) {
         for (const { payload } of events) {
           const id = getEventMeta(payload)?.id;
@@ -68,12 +68,12 @@ class MemoryPublisher extends Publisher {
       return;
     }
     this.lastCleanupTime = now;
-    for (const [event, events] of this.events) {
+    for (const [event, events] of this.eventsMap) {
       const validEvents = events.filter((event2) => event2.expiresAt > now);
       if (validEvents.length > 0) {
-        this.events.set(event, validEvents);
+        this.eventsMap.set(event, validEvents);
       } else {
-        this.events.delete(event);
+        this.eventsMap.delete(event);
       }
     }
   }

package/dist/adapters/upstash-redis.d.mts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions, StandardRPCJsonSerializer, StandardRPCJsonSerializedMetaItem } from '@orpc/client/standard';
+import { ThrowableError } from '@orpc/shared';
 import { Redis } from '@upstash/redis';
 import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '../index.mjs';
 import { getEventMeta } from '@orpc/standard-server';
-import '@orpc/shared';
 
 type SerializedPayload = {
     json: object;
@@ -34,7 +34,8 @@ declare class UpstashRedisPublisher<T extends Record<string, object>> extends Pu
     protected readonly prefix: string;
     protected readonly serializer: StandardRPCJsonSerializer;
     protected readonly retentionSeconds: number;
-    protected readonly listenersMap: Map<string, Set<(payload: any) => void>>;
+    protected readonly listenersMap: Map<string, ((payload: any) => void)[]>;
+    protected readonly onErrorsMap: Map<string, ((error: ThrowableError) => void)[]>;
     protected readonly subscriptionPromiseMap: Map<string, Promise<void>>;
     protected readonly subscriptionsMap: Map<string, any>;
     protected get isResumeEnabled(): boolean;
@@ -52,9 +53,9 @@ declare class UpstashRedisPublisher<T extends Record<string, object>> extends Pu
      */
     get size(): number;
     constructor(redis: Redis, { resumeRetentionSeconds, prefix, ...options }?: UpstashRedisPublisherOptions);
-    protected lastCleanupTimes: Map<string, number>;
+    protected lastCleanupTimeMap: Map<string, number>;
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     protected prefixKey(key: string): string;
     protected serializePayload(payload: object): SerializedPayload;
     protected deserializePayload(id: string | undefined, { json, meta, eventMeta }: SerializedPayload): any;

package/dist/adapters/upstash-redis.d.ts

@@ -1,8 +1,8 @@
 import { StandardRPCJsonSerializerOptions, StandardRPCJsonSerializer, StandardRPCJsonSerializedMetaItem } from '@orpc/client/standard';
+import { ThrowableError } from '@orpc/shared';
 import { Redis } from '@upstash/redis';
 import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '../index.js';
 import { getEventMeta } from '@orpc/standard-server';
-import '@orpc/shared';
 
 type SerializedPayload = {
     json: object;
@@ -34,7 +34,8 @@ declare class UpstashRedisPublisher<T extends Record<string, object>> extends Pu
     protected readonly prefix: string;
     protected readonly serializer: StandardRPCJsonSerializer;
     protected readonly retentionSeconds: number;
-    protected readonly listenersMap: Map<string, Set<(payload: any) => void>>;
+    protected readonly listenersMap: Map<string, ((payload: any) => void)[]>;
+    protected readonly onErrorsMap: Map<string, ((error: ThrowableError) => void)[]>;
     protected readonly subscriptionPromiseMap: Map<string, Promise<void>>;
     protected readonly subscriptionsMap: Map<string, any>;
     protected get isResumeEnabled(): boolean;
@@ -52,9 +53,9 @@ declare class UpstashRedisPublisher<T extends Record<string, object>> extends Pu
      */
     get size(): number;
     constructor(redis: Redis, { resumeRetentionSeconds, prefix, ...options }?: UpstashRedisPublisherOptions);
-    protected lastCleanupTimes: Map<string, number>;
+    protected lastCleanupTimeMap: Map<string, number>;
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     protected prefixKey(key: string): string;
     protected serializePayload(payload: object): SerializedPayload;
     protected deserializePayload(id: string | undefined, { json, meta, eventMeta }: SerializedPayload): any;

package/dist/adapters/upstash-redis.mjs

@@ -1,13 +1,13 @@
 import { StandardRPCJsonSerializer } from '@orpc/client/standard';
+import { fallback, once } from '@orpc/shared';
 import { getEventMeta, withEventMeta } from '@orpc/standard-server';
-import { P as Publisher } from '../shared/experimental-publisher.BOyYBkgn.mjs';
-import '@orpc/shared';
+import { P as Publisher } from '../shared/experimental-publisher.BtlOkhPO.mjs';
 
 class UpstashRedisPublisher extends Publisher {
   constructor(redis, { resumeRetentionSeconds, prefix, ...options } = {}) {
     super(options);
     this.redis = redis;
-    this.prefix = prefix ?? "orpc:publisher:";
+    this.prefix = fallback(prefix, "orpc:publisher:");
     this.retentionSeconds = resumeRetentionSeconds ?? Number.NaN;
     this.serializer = new StandardRPCJsonSerializer(options);
   }
@@ -15,6 +15,7 @@ class UpstashRedisPublisher extends Publisher {
   serializer;
   retentionSeconds;
   listenersMap = /* @__PURE__ */ new Map();
+  onErrorsMap = /* @__PURE__ */ new Map();
   subscriptionPromiseMap = /* @__PURE__ */ new Map();
   subscriptionsMap = /* @__PURE__ */ new Map();
   // Upstash subscription objects
@@ -36,24 +37,27 @@ class UpstashRedisPublisher extends Publisher {
   get size() {
     let size = 0;
     for (const listeners of this.listenersMap) {
-      size += listeners[1].size || 1;
+      size += listeners[1].length || 1;
+    }
+    for (const onErrors of this.onErrorsMap) {
+      size += onErrors[1].length || 1;
     }
     return size;
   }
-  lastCleanupTimes = /* @__PURE__ */ new Map();
+  lastCleanupTimeMap = /* @__PURE__ */ new Map();
   async publish(event, payload) {
     const key = this.prefixKey(event);
     const serialized = this.serializePayload(payload);
     let id;
     if (this.isResumeEnabled) {
       const now = Date.now();
-      for (const [key2, lastCleanupTime] of this.lastCleanupTimes) {
+      for (const [mapKey, lastCleanupTime] of this.lastCleanupTimeMap) {
         if (lastCleanupTime + this.retentionSeconds * 1e3 < now) {
-          this.lastCleanupTimes.delete(key2);
+          this.lastCleanupTimeMap.delete(mapKey);
         }
       }
-      if (!this.lastCleanupTimes.has(key)) {
-        this.lastCleanupTimes.set(key, now);
+      if (!this.lastCleanupTimeMap.has(key)) {
+        this.lastCleanupTimeMap.set(key, now);
         const results = await this.redis.multi().xadd(key, "*", { data: serialized }).xtrim(key, { strategy: "MINID", exactness: this.xtrimExactness, threshold: `${now - this.retentionSeconds * 1e3}-0` }).expire(key, this.retentionSeconds * 2).exec();
         id = results[0];
       } else {
@@ -63,9 +67,8 @@ class UpstashRedisPublisher extends Publisher {
     }
     await this.redis.publish(key, { ...serialized, id });
   }
-  async subscribeListener(event, originalListener, options) {
+  async subscribeListener(event, originalListener, { lastEventId, onError } = {}) {
     const key = this.prefixKey(event);
-    const lastEventId = options?.lastEventId;
     let pendingPayloads = [];
     const resumePayloadIds = /* @__PURE__ */ new Set();
     const listener = (payload) => {
@@ -79,9 +82,20 @@ class UpstashRedisPublisher extends Publisher {
       }
       originalListener(payload);
     };
-    await this.subscriptionPromiseMap.get(key);
+    const subscriptionPromise = this.subscriptionPromiseMap.get(key);
+    if (subscriptionPromise) {
+      await subscriptionPromise;
+    }
     let subscription = this.subscriptionsMap.get(key);
     if (!subscription) {
+      const dispatchErrorForKey = (error) => {
+        const onErrors = this.onErrorsMap.get(key);
+        if (onErrors) {
+          for (const onError2 of onErrors) {
+            onError2(error);
+          }
+        }
+      };
       subscription = this.redis.subscribe(key);
       subscription.on("message", (event2) => {
         try {
@@ -93,7 +107,8 @@ class UpstashRedisPublisher extends Publisher {
               listener2(payload);
             }
           }
-        } catch {
+        } catch (error) {
+          dispatchErrorForKey(error);
         }
       });
       let resolvePromise;
@@ -104,6 +119,7 @@ class UpstashRedisPublisher extends Publisher {
       });
       subscription.on("error", (error) => {
         rejectPromise(error);
+        dispatchErrorForKey(error);
       });
       subscription.on("subscribe", () => {
         resolvePromise();
@@ -118,9 +134,16 @@ class UpstashRedisPublisher extends Publisher {
     }
     let listeners = this.listenersMap.get(key);
     if (!listeners) {
-      this.listenersMap.set(key, listeners = /* @__PURE__ */ new Set());
+      this.listenersMap.set(key, listeners = []);
+    }
+    listeners.push(listener);
+    if (onError) {
+      let onErrors = this.onErrorsMap.get(key);
+      if (!onErrors) {
+        this.onErrorsMap.set(key, onErrors = []);
+      }
+      onErrors.push(onError);
     }
-    listeners.add(listener);
     void (async () => {
       try {
         if (this.isResumeEnabled && typeof lastEventId === "string") {
@@ -135,7 +158,8 @@ class UpstashRedisPublisher extends Publisher {
             }
           }
         }
-      } catch {
+      } catch (error) {
+        onError?.(error);
       } finally {
         const pending = pendingPayloads;
         pendingPayloads = void 0;
@@ -144,10 +168,20 @@ class UpstashRedisPublisher extends Publisher {
         }
       }
     })();
+    const cleanupListeners = once(() => {
+      listeners.splice(listeners.indexOf(listener), 1);
+      if (onError) {
+        const onErrors = this.onErrorsMap.get(key);
+        if (onErrors) {
+          onErrors.splice(onErrors.indexOf(onError), 1);
+        }
+      }
+    });
     return async () => {
-      listeners.delete(listener);
-      if (listeners.size === 0) {
+      cleanupListeners();
+      if (listeners.length === 0) {
         this.listenersMap.delete(key);
+        this.onErrorsMap.delete(key);
         const subscription2 = this.subscriptionsMap.get(key);
         if (subscription2) {
           this.subscriptionsMap.delete(key);

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AsyncIteratorClass } from '@orpc/shared';
+import { ThrowableError, AsyncIteratorClass } from '@orpc/shared';
 
 interface PublisherOptions {
     /**
@@ -21,8 +21,12 @@ interface PublisherSubscribeListenerOptions {
      * Resume from a specific event ID
      */
     lastEventId?: string | undefined;
+    /**
+     * Triggered when an error occur
+     */
+    onError?: (error: ThrowableError) => void;
 }
-interface PublisherSubscribeIteratorOptions extends PublisherSubscribeListenerOptions, PublisherOptions {
+interface PublisherSubscribeIteratorOptions extends Pick<PublisherSubscribeListenerOptions, 'lastEventId'>, Pick<PublisherOptions, 'maxBufferedEvents'> {
     /**
      * Abort signal, automatically unsubscribes on abort
      */
@@ -51,6 +55,11 @@ declare abstract class Publisher<T extends Record<string, object>> {
      * ```ts
      * const unsubscribe = publisher.subscribe('event', (payload) => {
      *   console.log(payload)
+     * }, {
+     *   lastEventId,
+     *   onError: (error) => {
+     *     // handle error (consider unsubscribe if error can't be recovered)
+     *   }
      * })
      *
      * // Later
@@ -64,7 +73,7 @@ declare abstract class Publisher<T extends Record<string, object>> {
      *
      * @example
      * ```ts
-     * for await (const payload of publisher.subscribe('event', { signal })) {
+     * for await (const payload of publisher.subscribe('event', { signal, lastEventId })) {
      *   console.log(payload)
      * }
      * ```

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AsyncIteratorClass } from '@orpc/shared';
+import { ThrowableError, AsyncIteratorClass } from '@orpc/shared';
 
 interface PublisherOptions {
     /**
@@ -21,8 +21,12 @@ interface PublisherSubscribeListenerOptions {
      * Resume from a specific event ID
      */
     lastEventId?: string | undefined;
+    /**
+     * Triggered when an error occur
+     */
+    onError?: (error: ThrowableError) => void;
 }
-interface PublisherSubscribeIteratorOptions extends PublisherSubscribeListenerOptions, PublisherOptions {
+interface PublisherSubscribeIteratorOptions extends Pick<PublisherSubscribeListenerOptions, 'lastEventId'>, Pick<PublisherOptions, 'maxBufferedEvents'> {
     /**
      * Abort signal, automatically unsubscribes on abort
      */
@@ -51,6 +55,11 @@ declare abstract class Publisher<T extends Record<string, object>> {
      * ```ts
      * const unsubscribe = publisher.subscribe('event', (payload) => {
      *   console.log(payload)
+     * }, {
+     *   lastEventId,
+     *   onError: (error) => {
+     *     // handle error (consider unsubscribe if error can't be recovered)
+     *   }
      * })
      *
      * // Later
@@ -64,7 +73,7 @@ declare abstract class Publisher<T extends Record<string, object>> {
      *
      * @example
      * ```ts
-     * for await (const payload of publisher.subscribe('event', { signal })) {
+     * for await (const payload of publisher.subscribe('event', { signal, lastEventId })) {
      *   console.log(payload)
      * }
      * ```

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export { P as Publisher } from './shared/experimental-publisher.BOyYBkgn.mjs';
+export { P as Publisher } from './shared/experimental-publisher.BtlOkhPO.mjs';
 import '@orpc/shared';

package/dist/shared/{experimental-publisher.BOyYBkgn.mjs → experimental-publisher.BtlOkhPO.mjs}

@@ -14,6 +14,7 @@ class Publisher {
     signal?.throwIfAborted();
     const bufferedEvents = [];
     const pullResolvers = [];
+    let subscriptionError;
     const unsubscribePromise = this.subscribe(event, (payload) => {
       const resolver = pullResolvers.shift();
       if (resolver) {
@@ -24,20 +25,34 @@ class Publisher {
           bufferedEvents.shift();
         }
       }
+    }, {
+      lastEventId: listenerOrOptions?.lastEventId,
+      onError: (error) => {
+        subscriptionError = { error };
+        pullResolvers.forEach((resolver) => resolver[1](error));
+        signal?.removeEventListener("abort", abortListener);
+        pullResolvers.length = 0;
+        bufferedEvents.length = 0;
+        unsubscribePromise.then((unsubscribe) => unsubscribe()).catch(() => {
+        });
+      }
     });
-    const abortListener = (event2) => {
+    function abortListener(event2) {
       pullResolvers.forEach((resolver) => resolver[1](event2.target.reason));
       pullResolvers.length = 0;
       bufferedEvents.length = 0;
       unsubscribePromise.then((unsubscribe) => unsubscribe()).catch(() => {
       });
-    };
+    }
     signal?.addEventListener("abort", abortListener, { once: true });
     return new AsyncIteratorClass(async () => {
-      await unsubscribePromise;
+      if (subscriptionError) {
+        throw subscriptionError.error;
+      }
       if (signal?.aborted) {
         throw signal.reason;
       }
+      await unsubscribePromise;
       if (bufferedEvents.length > 0) {
         return { done: false, value: bufferedEvents.shift() };
       }
@@ -45,8 +60,8 @@ class Publisher {
         pullResolvers.push([resolve, reject]);
       });
     }, async () => {
-      signal?.removeEventListener("abort", abortListener);
       pullResolvers.forEach((resolver) => resolver[0]({ done: true, value: void 0 }));
+      signal?.removeEventListener("abort", abortListener);
       pullResolvers.length = 0;
       bufferedEvents.length = 0;
       await unsubscribePromise.then((unsubscribe) => unsubscribe());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/experimental-publisher",
   "type": "module",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {