@sylphx/lens-solid 2.3.8 → 2.3.9

package/dist/index.js

@@ -857,7 +857,6 @@ class ReconnectionMetricsTracker {
   totalFailures = 0;
   totalSubscriptionsProcessed = 0;
   totalBytesTransferred = 0;
-  totalBytesCompressed = 0;
   statusCounts = {
     current: 0,
     patched: 0,
@@ -962,10 +961,6 @@ class ReconnectionMetricsTracker {
       }
     });
   }
-  recordCompression(originalSize, compressedSize) {
-    this.totalBytesTransferred += compressedSize;
-    this.totalBytesCompressed += originalSize - compressedSize;
-  }
   getMetrics() {
     const avgLatency = this.latencies.length > 0 ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length : 0;
     const p50 = this.percentile(50);
@@ -982,9 +977,7 @@ class ReconnectionMetricsTracker {
       p99Latency: p99,
       totalSubscriptionsProcessed: this.totalSubscriptionsProcessed,
       statusBreakdown: { ...this.statusCounts },
-      bytesTransferred: this.totalBytesTransferred,
-      bytesSaved: this.totalBytesCompressed,
-      compressionRatio: this.totalBytesTransferred > 0 ? (this.totalBytesTransferred - this.totalBytesCompressed) / this.totalBytesTransferred : 1
+      bytesTransferred: this.totalBytesTransferred
     };
   }
   getHealth() {
@@ -1027,7 +1020,6 @@ class ReconnectionMetricsTracker {
     this.totalFailures = 0;
     this.totalSubscriptionsProcessed = 0;
     this.totalBytesTransferred = 0;
-    this.totalBytesCompressed = 0;
     this.statusCounts = { current: 0, patched: 0, snapshot: 0, deleted: 0, error: 0 };
     this.latencies = [];
   }
@@ -2474,6 +2466,7 @@ function createPollingObservable(baseUrl, op2, options) {
           if (isError(message)) {
             retries++;
             if (retries > options.maxRetries) {
+              active = false;
               observer.error?.(new Error(message.error));
               return;
             }
@@ -2494,6 +2487,7 @@ function createPollingObservable(baseUrl, op2, options) {
           }
         } catch (error) {
           if (active) {
+            active = false;
             observer.error?.(error);
           }
         }
@@ -2535,6 +2529,345 @@ http.server = function httpServer(options) {
     }
   };
 };
+class SseConnectionManager {
+  config;
+  subscriptions = new Map;
+  connectionState = "disconnected";
+  constructor(config) {
+    this.config = config;
+  }
+  getConnectionState() {
+    return this.connectionState;
+  }
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  setConnectionState(state) {
+    if (this.connectionState !== state) {
+      this.connectionState = state;
+      this.config.onConnectionStateChange?.(state);
+    }
+  }
+  getRetryDelay(attempt) {
+    const { baseDelay, maxDelay } = this.config.retry;
+    const exponentialDelay = baseDelay * Math.pow(2, attempt);
+    const jitter = Math.random() * 0.3 * exponentialDelay;
+    return Math.min(exponentialDelay + jitter, maxDelay);
+  }
+  createSubscription(op2) {
+    return {
+      subscribe: (observer) => {
+        const subId = op2.id;
+        let retryCount = 0;
+        const connect = () => {
+          const sseUrl = new URL(`${this.config.baseUrl}/${op2.path}`);
+          if (op2.input !== undefined) {
+            sseUrl.searchParams.set("input", JSON.stringify(op2.input));
+          }
+          sseUrl.searchParams.set("_sse", "1");
+          if (this.config.headers) {
+            for (const [key, value] of Object.entries(this.config.headers)) {
+              sseUrl.searchParams.set(`_h_${key}`, value);
+            }
+          }
+          const eventSource = new this.config.EventSource(sseUrl.toString());
+          this.subscriptions.set(subId, { eventSource, observer, retryCount });
+          if (this.subscriptions.size === 1) {
+            this.setConnectionState("connecting");
+          }
+          eventSource.onopen = () => {
+            retryCount = 0;
+            const sub = this.subscriptions.get(subId);
+            if (sub) {
+              sub.retryCount = 0;
+            }
+            this.setConnectionState("connected");
+          };
+          eventSource.onmessage = (event) => {
+            try {
+              const message = JSON.parse(event.data);
+              observer.next?.(message);
+            } catch (error) {
+              observer.error?.(error);
+            }
+          };
+          eventSource.addEventListener("error", (_event) => {
+            if (eventSource.readyState === this.config.EventSource.CLOSED) {
+              if (this.config.retry.enabled && retryCount < this.config.retry.maxAttempts) {
+                this.setConnectionState("reconnecting");
+                retryCount++;
+                const sub = this.subscriptions.get(subId);
+                if (sub) {
+                  sub.retryCount = retryCount;
+                }
+                const delay = this.getRetryDelay(retryCount);
+                setTimeout(() => {
+                  if (this.subscriptions.has(subId)) {
+                    this.subscriptions.delete(subId);
+                    connect();
+                  }
+                }, delay);
+              } else {
+                observer.error?.(new Error("SSE connection failed"));
+                this.subscriptions.delete(subId);
+                if (this.subscriptions.size === 0) {
+                  this.setConnectionState("disconnected");
+                }
+              }
+            }
+          });
+          eventSource.addEventListener("complete", () => {
+            observer.complete?.();
+            eventSource.close();
+            this.subscriptions.delete(subId);
+            if (this.subscriptions.size === 0) {
+              this.setConnectionState("disconnected");
+            }
+          });
+          eventSource.addEventListener("lens-error", (event) => {
+            try {
+              const errorData = JSON.parse(event.data);
+              observer.error?.(new Error(errorData.message || "SSE error"));
+            } catch {
+              observer.error?.(new Error("SSE error"));
+            }
+          });
+        };
+        connect();
+        return {
+          unsubscribe: () => {
+            const sub = this.subscriptions.get(subId);
+            if (sub) {
+              sub.eventSource.close();
+              this.subscriptions.delete(subId);
+              if (this.subscriptions.size === 0) {
+                this.setConnectionState("disconnected");
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+  close() {
+    for (const [_id, sub] of this.subscriptions) {
+      sub.eventSource.close();
+    }
+    this.subscriptions.clear();
+    this.setConnectionState("disconnected");
+  }
+}
+class SubscriptionRegistry2 {
+  subscriptions = new Map;
+  entityIndex = new Map;
+  add(sub) {
+    const tracked = {
+      ...sub,
+      state: "pending",
+      lastDataHash: sub.lastData ? hashEntityState(sub.lastData) : null,
+      createdAt: Date.now(),
+      lastUpdateAt: null
+    };
+    this.subscriptions.set(sub.id, tracked);
+    const entityKey = `${sub.entity}:${sub.entityId}`;
+    let ids = this.entityIndex.get(entityKey);
+    if (!ids) {
+      ids = new Set;
+      this.entityIndex.set(entityKey, ids);
+    }
+    ids.add(sub.id);
+  }
+  get(id) {
+    return this.subscriptions.get(id);
+  }
+  has(id) {
+    return this.subscriptions.has(id);
+  }
+  remove(id) {
+    const sub = this.subscriptions.get(id);
+    if (!sub)
+      return;
+    this.subscriptions.delete(id);
+    const entityKey = `${sub.entity}:${sub.entityId}`;
+    const ids = this.entityIndex.get(entityKey);
+    if (ids) {
+      ids.delete(id);
+      if (ids.size === 0) {
+        this.entityIndex.delete(entityKey);
+      }
+    }
+  }
+  getByEntity(entity3, entityId) {
+    const entityKey = `${entity3}:${entityId}`;
+    const ids = this.entityIndex.get(entityKey);
+    if (!ids)
+      return [];
+    const result = [];
+    for (const id of ids) {
+      const sub = this.subscriptions.get(id);
+      if (sub) {
+        result.push(sub);
+      }
+    }
+    return result;
+  }
+  updateVersion(id, version, data) {
+    const sub = this.subscriptions.get(id);
+    if (!sub)
+      return;
+    sub.version = version;
+    sub.lastUpdateAt = Date.now();
+    if (data !== undefined) {
+      sub.lastData = data;
+      sub.lastDataHash = hashEntityState(data);
+    }
+    if (sub.state === "pending" || sub.state === "reconnecting") {
+      sub.state = "active";
+    }
+  }
+  updateData(id, data) {
+    const sub = this.subscriptions.get(id);
+    if (!sub)
+      return;
+    sub.lastData = data;
+    sub.lastDataHash = hashEntityState(data);
+  }
+  getLastData(id) {
+    return this.subscriptions.get(id)?.lastData ?? null;
+  }
+  getVersion(id) {
+    return this.subscriptions.get(id)?.version ?? null;
+  }
+  markActive(id) {
+    const sub = this.subscriptions.get(id);
+    if (sub) {
+      sub.state = "active";
+    }
+  }
+  markError(id) {
+    const sub = this.subscriptions.get(id);
+    if (sub) {
+      sub.state = "error";
+    }
+  }
+  markAllReconnecting() {
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "active") {
+        sub.state = "reconnecting";
+      }
+    }
+  }
+  getByState(state) {
+    const result = [];
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === state) {
+        result.push(sub);
+      }
+    }
+    return result;
+  }
+  getAllForReconnect() {
+    const result = [];
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "reconnecting" || sub.state === "active") {
+        const reconnectSub = {
+          id: sub.id,
+          entity: sub.entity,
+          entityId: sub.entityId,
+          fields: sub.fields,
+          version: sub.version,
+          input: sub.input
+        };
+        if (sub.lastDataHash) {
+          reconnectSub.dataHash = sub.lastDataHash;
+        }
+        result.push(reconnectSub);
+      }
+    }
+    return result;
+  }
+  processReconnectResult(id, version, data) {
+    const sub = this.subscriptions.get(id);
+    if (!sub)
+      return;
+    sub.version = version;
+    sub.state = "active";
+    sub.lastUpdateAt = Date.now();
+    if (data !== undefined) {
+      sub.lastData = data;
+      sub.lastDataHash = hashEntityState(data);
+    }
+  }
+  getObserver(id) {
+    return this.subscriptions.get(id)?.observer;
+  }
+  updateObserver(id, observer) {
+    const sub = this.subscriptions.get(id);
+    if (sub) {
+      sub.observer = observer;
+    }
+  }
+  notifyNext(id, data) {
+    const sub = this.subscriptions.get(id);
+    sub?.observer.next?.({ data, version: sub.version });
+  }
+  notifyError(id, error) {
+    this.subscriptions.get(id)?.observer.error?.(error);
+  }
+  notifyAllReconnectingError(error) {
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "reconnecting") {
+        sub.observer.error?.(error);
+      }
+    }
+  }
+  get size() {
+    return this.subscriptions.size;
+  }
+  getIds() {
+    return Array.from(this.subscriptions.keys());
+  }
+  values() {
+    return this.subscriptions.values();
+  }
+  getStats() {
+    const byState = {
+      pending: 0,
+      active: 0,
+      reconnecting: 0,
+      error: 0
+    };
+    const byEntity = {};
+    for (const sub of this.subscriptions.values()) {
+      byState[sub.state]++;
+      const entityKey = `${sub.entity}:${sub.entityId}`;
+      byEntity[entityKey] = (byEntity[entityKey] ?? 0) + 1;
+    }
+    return {
+      total: this.subscriptions.size,
+      byState,
+      byEntity
+    };
+  }
+  clear() {
+    for (const sub of this.subscriptions.values()) {
+      sub.observer.complete?.();
+    }
+    this.subscriptions.clear();
+    this.entityIndex.clear();
+  }
+  clearErrors() {
+    const toRemove = [];
+    for (const [id, sub] of this.subscriptions) {
+      if (sub.state === "error") {
+        toRemove.push(id);
+      }
+    }
+    for (const id of toRemove) {
+      this.remove(id);
+    }
+  }
+}
 
 // src/create.ts
 import { createEffect, createSignal, on, onCleanup } from "solid-js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-solid",
-	"version": "2.3.8",
+	"version": "2.3.9",
 	"description": "SolidJS bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -31,8 +31,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.7.3",
-		"@sylphx/lens-core": "^2.12.1"
+		"@sylphx/lens-client": "^2.7.4",
+		"@sylphx/lens-core": "^2.12.2"
 	},
 	"peerDependencies": {
 		"solid-js": ">=1.8.0"