@donkeylabs/adapter-sveltekit 2.0.2 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/adapter-sveltekit",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "type": "module",
   "description": "SvelteKit adapter for @donkeylabs/server - seamless SSR/browser API integration",
   "main": "./src/index.ts",
@@ -37,7 +37,7 @@
   },
   "peerDependencies": {
     "@sveltejs/kit": "^2.0.0",
-    "@donkeylabs/server": "^2.0.2"
+    "@donkeylabs/server": "^2.0.4"
   },
   "keywords": [
     "sveltekit",

package/src/client/index.ts

@@ -41,14 +41,39 @@ export interface SSEOptions {
   reconnectDelay?: number;
 }
 
+/**
+ * Options for SSE connection behavior.
+ */
+export interface SSEConnectionOptions {
+  /** Enable automatic reconnection on disconnect (default: true) */
+  autoReconnect?: boolean;
+  /** Delay in ms before attempting reconnect (default: 3000) */
+  reconnectDelay?: number;
+  /** Called when connection is established */
+  onConnect?: () => void;
+  /** Called when connection is lost */
+  onDisconnect?: () => void;
+}
+
 /**
  * Type-safe SSE connection wrapper.
  * Provides typed event handlers with automatic JSON parsing.
  *
  * @example
  * ```ts
+ * // With auto-reconnect (default)
  * const connection = api.notifications.subscribe({ userId: "123" });
  *
+ * // Disable auto-reconnect for manual control
+ * const connection = api.notifications.subscribe({ userId: "123" }, {
+ *   autoReconnect: false
+ * });
+ *
+ * // Custom reconnect delay
+ * const connection = api.notifications.subscribe({ userId: "123" }, {
+ *   reconnectDelay: 5000 // 5 seconds
+ * });
+ *
  * // Typed event handler - returns unsubscribe function
  * const unsubscribe = connection.on("notification", (data) => {
  *   console.log(data.message); // Fully typed!
@@ -62,11 +87,75 @@ export interface SSEOptions {
  * ```
  */
 export class SSEConnection<TEvents extends Record<string, any> = Record<string, any>> {
-  private eventSource: EventSource;
+  private eventSource: EventSource | null;
   private handlers = new Map<string, Set<(data: any) => void>>();
+  private url: string;
+  private options: SSEConnectionOptions;
+  private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
+  private closed = false;
+
+  constructor(url: string, options: SSEConnectionOptions = {}) {
+    this.url = url;
+    this.options = {
+      autoReconnect: true,
+      reconnectDelay: 3000,
+      ...options,
+    };
+    this.eventSource = this.createEventSource();
+  }
+
+  private createEventSource(): EventSource {
+    const es = new EventSource(this.url);
+
+    es.onopen = () => {
+      this.options.onConnect?.();
+    };
+
+    es.onerror = () => {
+      // Native EventSource auto-reconnects, but we want control
+      // Close it and handle reconnection ourselves
+      if (this.options.autoReconnect && !this.closed) {
+        this.options.onDisconnect?.();
+        es.close();
+        this.scheduleReconnect();
+      }
+    };
+
+    // Re-attach existing handlers to new EventSource
+    for (const [event] of this.handlers) {
+      es.addEventListener(event, (e: MessageEvent) => {
+        this.dispatchEvent(event, e.data);
+      });
+    }
+
+    return es;
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectTimeout || this.closed) return;
+
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      if (!this.closed) {
+        this.eventSource = this.createEventSource();
+      }
+    }, this.options.reconnectDelay);
+  }
+
+  private dispatchEvent(event: string, rawData: string): void {
+    const handlers = this.handlers.get(event);
+    if (!handlers) return;
+
+    let data: any;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+      data = rawData;
+    }
 
-  constructor(url: string) {
-    this.eventSource = new EventSource(url);
+    for (const h of handlers) {
+      h(data);
+    }
   }
 
   /**
@@ -77,23 +166,14 @@ export class SSEConnection<TEvents extends Record<string, any> = Record<string,
     event: K & string,
     handler: (data: TEvents[K]) => void
   ): () => void {
-    if (!this.handlers.has(event)) {
+    const isNewEvent = !this.handlers.has(event);
+
+    if (isNewEvent) {
       this.handlers.set(event, new Set());
 
       // Add EventSource listener for this event type
-      this.eventSource.addEventListener(event, (e: MessageEvent) => {
-        const handlers = this.handlers.get(event);
-        if (handlers) {
-          let data: any;
-          try {
-            data = JSON.parse(e.data);
-          } catch {
-            data = e.data;
-          }
-          for (const h of handlers) {
-            h(data);
-          }
-        }
+      this.eventSource?.addEventListener(event, (e: MessageEvent) => {
+        this.dispatchEvent(event, e.data);
       });
     }
 
@@ -132,12 +212,23 @@ export class SSEConnection<TEvents extends Record<string, any> = Record<string,
   }
 
   /**
-   * Register error handler
+   * Register error handler.
+   * Note: With autoReconnect enabled, errors trigger automatic reconnection.
    */
   onError(handler: (event: Event) => void): () => void {
-    this.eventSource.onerror = handler;
+    const wrappedHandler = (e: Event) => {
+      handler(e);
+    };
+    if (this.eventSource) {
+      const existingHandler = this.eventSource.onerror;
+      this.eventSource.onerror = (e) => {
+        // Call existing handler (for reconnection logic)
+        if (existingHandler) (existingHandler as (e: Event) => void)(e);
+        wrappedHandler(e);
+      };
+    }
     return () => {
-      this.eventSource.onerror = null;
+      // Can't easily remove, but handler will be replaced on reconnect
     };
   }
 
@@ -145,9 +236,15 @@ export class SSEConnection<TEvents extends Record<string, any> = Record<string,
    * Register open handler (connection established)
    */
   onOpen(handler: (event: Event) => void): () => void {
-    this.eventSource.onopen = handler;
+    if (this.eventSource) {
+      const existingHandler = this.eventSource.onopen;
+      this.eventSource.onopen = (e) => {
+        if (existingHandler) (existingHandler as (e: Event) => void)(e);
+        handler(e);
+      };
+    }
     return () => {
-      this.eventSource.onopen = null;
+      if (this.eventSource) this.eventSource.onopen = null;
     };
   }
 
@@ -155,21 +252,34 @@ export class SSEConnection<TEvents extends Record<string, any> = Record<string,
    * Get connection state
    */
   get readyState(): number {
-    return this.eventSource.readyState;
+    return this.eventSource?.readyState ?? EventSource.CLOSED;
   }
 
   /**
    * Check if connected
    */
   get connected(): boolean {
-    return this.eventSource.readyState === EventSource.OPEN;
+    return this.eventSource?.readyState === EventSource.OPEN;
   }
 
   /**
-   * Close the SSE connection
+   * Check if reconnecting
+   */
+  get reconnecting(): boolean {
+    return this.reconnectTimeout !== null;
+  }
+
+  /**
+   * Close the SSE connection and stop reconnection attempts
    */
   close(): void {
-    this.eventSource.close();
+    this.closed = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.eventSource?.close();
+    this.eventSource = null;
     this.handlers.clear();
   }
 }
@@ -331,7 +441,8 @@ export class UnifiedApiClientBase {
    */
   protected sseConnect<TInput, TEvents extends Record<string, any> = Record<string, any>>(
     route: string,
-    input?: TInput
+    input?: TInput,
+    options?: SSEConnectionOptions
   ): SSEConnection<TEvents> {
     let url = `${this.baseUrl}/${route}`;
 
@@ -344,7 +455,7 @@ export class UnifiedApiClientBase {
       url += `?${params.toString()}`;
     }
 
-    return new SSEConnection<TEvents>(url);
+    return new SSEConnection<TEvents>(url, options);
   }
 
   /**
@@ -355,11 +466,16 @@ export class UnifiedApiClientBase {
   protected connectToSSERoute<TEvents extends Record<string, any>>(
     route: string,
     input: Record<string, any> = {},
-    _options?: Omit<SSEOptions, "endpoint" | "channels">
+    options?: Omit<SSEOptions, "endpoint" | "channels">
   ): SSEConnection<TEvents> {
-    // Note: options (onConnect, onDisconnect, etc.) are not used by SSEConnection
-    // but we accept them for API compatibility with @donkeylabs/server/client
-    return this.sseConnect<Record<string, any>, TEvents>(route, input);
+    // Map SSEOptions to SSEConnectionOptions
+    const connectionOptions: SSEConnectionOptions | undefined = options ? {
+      autoReconnect: options.autoReconnect,
+      reconnectDelay: options.reconnectDelay,
+      onConnect: options.onConnect,
+      onDisconnect: options.onDisconnect,
+    } : undefined;
+    return this.sseConnect<Record<string, any>, TEvents>(route, input, connectionOptions);
   }
 
   /**