@rebasepro/client 0.7.0 → 0.9.0

package/src/websocket.ts

@@ -1,16 +1,16 @@
 import {
-    DeleteEntityProps,
-    Entity,
-    EntityCollection,
+    DeleteProps,
+    CollectionConfig,
     FetchCollectionProps,
-    FetchEntityProps,
-    SaveEntityProps,
+    FetchOneProps,
+    SaveProps,
     WebSocketMessage,
     WebSocketErrorPayload,
     CollectionUpdateMessage,
-    EntityUpdateMessage,
+    SingleUpdateMessage,
     TableMetadata,
-    BranchInfo
+    BranchInfo,
+    RebaseApiError
 } from "@rebasepro/types";
 import { rebaseReviver } from "./reviver";
 
@@ -44,19 +44,15 @@ export interface RebaseWebSocketConfig {
 }
 
 
-export class ApiError extends Error {
-    public code?: string;
-    public error?: string;
-
-    constructor(message: string, error?: string, code?: string) {
-        super(message);
-        this.name = "ApiError";
-        this.code = code;
-        this.error = error;
-    }
-}
-
-
+/**
+ * Low-level realtime WebSocket client.
+ *
+ * @internal Not a stable app-facing API. `createRebaseClient()` constructs and
+ * manages this internally (exposed as `client.ws`, typed by the minimal
+ * `RebaseWebSocket` contract in `@rebasepro/types`). It is re-exported from the
+ * package root only because the `@rebasepro/client-postgresql` driver
+ * instantiates it directly; its surface may change without a major bump.
+ */
 export class RebaseWebSocketClient {
     private websocketUrl: string;
     private ws: WebSocket | null = null;
@@ -86,23 +82,23 @@ export class RebaseWebSocketClient {
     private collectionSubscriptions = new Map<string, {
         backendSubscriptionId: string;
         callbacks: Map<string, {
-            onUpdate: (entities: Entity[]) => void;
+            onUpdate: (rows: Record<string, unknown>[]) => void;
             onError?: (error: Error) => void;
         }>;
         props: FetchCollectionProps;
-        latestData?: Entity[]; // Cache the latest data
+        latestData?: Record<string, unknown>[]; // Cache the latest flat rows
         lastUpdated?: number; // Timestamp for cache invalidation
         isInitialDataReceived?: boolean; // Track if we got initial data
     }>();
 
-    private entitySubscriptions = new Map<string, {
+    private singleSubscriptions = new Map<string, {
         backendSubscriptionId: string;
         callbacks: Map<string, {
-            onUpdate: (entity: Entity | null) => void;
+            onUpdate: (row: Record<string, unknown> | null) => void;
             onError?: (error: Error) => void;
         }>;
-        props: FetchEntityProps;
-        latestData?: Entity | null; // Cache the latest data
+        props: FetchOneProps;
+        latestData?: Record<string, unknown> | null; // Cache the latest flat row
         lastUpdated?: number; // Timestamp for cache invalidation
         isInitialDataReceived?: boolean; // Track if we got initial data
     }>();
@@ -294,7 +290,7 @@ export class RebaseWebSocketClient {
                         request.message._queuedReject = request.reject;
                         this.messageQueue.push(request.message);
                     } else {
-                        request.reject(new ApiError("Connection closed", "Connection closed"));
+                        request.reject(new RebaseApiError("Connection closed"));
                     }
                     this.pendingRequests.delete(reqId);
                 }
@@ -380,7 +376,7 @@ export class RebaseWebSocketClient {
     }
 
     /**
-     * Shared logic for re-subscribing a collection or entity subscription
+     * Shared logic for re-subscribing a collection or row subscription
      * after an auth error is resolved by refreshing credentials.
      */
     private resubscribeAfterAuthRefresh(
@@ -388,12 +384,12 @@ export class RebaseWebSocketClient {
         subscription: {
             backendSubscriptionId: string;
             callbacks: Map<string, { onUpdate: (...args: never[]) => void; onError?: (error: Error) => void }>;
-            props: FetchCollectionProps | FetchEntityProps;
+            props: FetchCollectionProps | FetchOneProps;
         },
         subscriptionKey: string,
-        idPrefix: "collection" | "entity",
+        idPrefix: "collection" | "row",
         backendKeyMap: Map<string, string>,
-        messageType: "subscribe_collection" | "subscribe_entity"
+        messageType: "subscribe_collection" | "subscribe_one"
     ): void {
         this.handleAuthFailure().then(refreshed => {
             if (refreshed) {
@@ -417,7 +413,7 @@ export class RebaseWebSocketClient {
                 });
             } else {
                 const { errorMessage, errorCode } = extractMessageError(message);
-                const error = new ApiError(errorMessage, errorMessage, errorCode);
+                const error = new RebaseApiError(errorMessage, { code: errorCode });
                 subscription.callbacks.forEach(callback => {
                     if (callback.onError) callback.onError(error);
                 });
@@ -447,7 +443,7 @@ export class RebaseWebSocketClient {
                             this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
                         } else {
                             const { errorMessage, errorCode } = extractMessageError(message);
-                            pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+                            pendingReq.reject(new RebaseApiError(errorMessage, { code: errorCode }));
                         }
                     }).catch(err => {
                         pendingReq.reject(err);
@@ -455,7 +451,7 @@ export class RebaseWebSocketClient {
                 } else {
                     this.pendingRequests.delete(requestId);
                     const { errorMessage, errorCode } = extractMessageError(message);
-                    pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+                    pendingReq.reject(new RebaseApiError(errorMessage, { code: errorCode }));
                 }
             } else {
                 this.pendingRequests.delete(requestId);
@@ -470,23 +466,24 @@ export class RebaseWebSocketClient {
             if (subscriptionKey) {
                 const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
                 if (collectionSub) {
-                    const incomingEntities = (message.entities || []) as Entity[];
+                    const wireEntities = (message.rows || []) as unknown as Record<string, unknown>[];
+                    const incomingRows = wireEntities;
 
-                    // Structural merge: preserve cached entity references for entities
+                    // Structural merge: preserve cached row references for rows
                     // whose values haven't changed. This prevents downstream React components
                     // from re-rendering (VirtualTableCell uses deepEqual on rowData —
                     // same reference = instant true, avoiding expensive deep comparison).
-                    const entities = this.mergeEntities(collectionSub.latestData, incomingEntities);
+                    const rows = this.mergeRows(collectionSub.latestData, incomingRows);
 
                     // Cache the latest data with optimizations
-                    collectionSub.latestData = entities;
+                    collectionSub.latestData = rows;
                     collectionSub.lastUpdated = Date.now();
                     collectionSub.isInitialDataReceived = true;
 
                     // Notify all callbacks for this subscription
                     collectionSub.callbacks.forEach(callback => {
                         try {
-                            callback.onUpdate(entities);
+                            callback.onUpdate(rows);
                         } catch (error) {
                             console.error("Error in collection subscription callback:", error);
                             if (callback.onError) {
@@ -499,30 +496,31 @@ export class RebaseWebSocketClient {
             }
         }
 
-        // Handle instant entity-level patches for collection subscriptions.
+        // Handle instant row-level patches for collection subscriptions.
         // These arrive before the full refetch and give immediate cross-tab feedback.
-        if (subscriptionId && type === "collection_entity_patch") {
+        if (subscriptionId && type === "collection_patch") {
             const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
             if (subscriptionKey) {
                 const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
                 if (collectionSub && collectionSub.isInitialDataReceived && collectionSub.latestData) {
-                    const patchEntity = message.entity ?? null;
-                    const patchEntityId = (message as unknown as { entityId: string }).entityId;
-                    let updated: Entity[];
+                    const patchWireEntity = message.row ?? null;
+                    const patchEntityId = (message as unknown as { id: string }).id;
+                    const patchRow = patchWireEntity ? (patchWireEntity as unknown as Record<string, unknown>) : null;
+                    let updated: Record<string, unknown>[];
 
-                    if (patchEntity === null || patchEntity === undefined) {
-                        // Entity was deleted — remove it from the cached list
+                    if (patchRow === null) {
+                        // Row was deleted — remove it from the cached list
                         updated = collectionSub.latestData.filter(e => String(e.id) !== String(patchEntityId));
                     } else {
-                        // Entity was created or updated — merge into the cached list
-                        const idx = collectionSub.latestData.findIndex(e => String(e.id) === String(patchEntity.id));
+                        // Row was created or updated — merge into the cached list
+                        const idx = collectionSub.latestData.findIndex(e => String(e.id) === String(patchRow.id));
                         if (idx >= 0) {
                             // Update in place (preserve array position)
                             updated = [...collectionSub.latestData];
-                            updated[idx] = patchEntity;
+                            updated[idx] = patchRow;
                         } else {
-                            // New entity — prepend (most recently created entities first)
-                            updated = [patchEntity, ...collectionSub.latestData];
+                            // New row — prepend (most recently created first)
+                            updated = [patchRow, ...collectionSub.latestData];
                         }
                     }
 
@@ -545,24 +543,25 @@ export class RebaseWebSocketClient {
             }
         }
 
-        // Handle subscription updates for entity subscriptions
-        if (subscriptionId && type === "entity_update") {
+        // Handle subscription updates for row subscriptions
+        if (subscriptionId && type === "single_update") {
             const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
             if (subscriptionKey) {
-                const entitySub = this.entitySubscriptions.get(subscriptionKey);
+                const entitySub = this.singleSubscriptions.get(subscriptionKey);
                 if (entitySub) {
-                    const entity = message.entity ?? null;
+                    const wireEntity = message.row ?? null;
+                    const row = wireEntity ? (wireEntity as unknown as Record<string, unknown>) : null;
                     // Cache the latest data with optimizations
-                    entitySub.latestData = entity;
+                    entitySub.latestData = row;
                     entitySub.lastUpdated = Date.now();
                     entitySub.isInitialDataReceived = true;
 
                     // Notify all callbacks for this subscription
                     entitySub.callbacks.forEach(callback => {
                         try {
-                            callback.onUpdate(entity);
+                            callback.onUpdate(row);
                         } catch (error) {
-                            console.error("Error in entity subscription callback:", error);
+                            console.error("Error in row subscription callback:", error);
                             if (callback.onError) {
                                 callback.onError(error instanceof Error ? error : new Error(String(error)));
                             }
@@ -592,7 +591,7 @@ export class RebaseWebSocketClient {
                     }
 
                     const { errorMessage, errorCode } = extractMessageError(message);
-                    const error = new ApiError(errorMessage, errorMessage, errorCode);
+                    const error = new RebaseApiError(errorMessage, { code: errorCode });
                     collectionSub.callbacks.forEach(callback => {
                         if (callback.onError) {
                             callback.onError(error);
@@ -604,22 +603,22 @@ export class RebaseWebSocketClient {
 
             const entityKey = this.backendToEntityKey.get(subscriptionId);
             if (entityKey) {
-                const entitySub = this.entitySubscriptions.get(entityKey);
+                const entitySub = this.singleSubscriptions.get(entityKey);
                 if (entitySub) {
                     if (this.isAuthError(message)) {
                         this.resubscribeAfterAuthRefresh(
                             message,
                             entitySub,
                             entityKey,
-                            "entity",
+                            "row",
                             this.backendToEntityKey,
-                            "subscribe_entity"
+                            "subscribe_one"
                         );
                         return;
                     }
 
                     const { errorMessage, errorCode } = extractMessageError(message);
-                    const error = new ApiError(errorMessage, errorMessage, errorCode);
+                    const error = new RebaseApiError(errorMessage, { code: errorCode });
                     entitySub.callbacks.forEach(callback => {
                         if (callback.onError) {
                             callback.onError(error);
@@ -639,7 +638,7 @@ export class RebaseWebSocketClient {
             if (message.type === "ERROR" || message.error) {
                 if (callback.onError) {
                     const { errorMessage, errorCode } = extractMessageError(message);
-                    callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
+                    callback.onError(new RebaseApiError(errorMessage, { code: errorCode }));
                 }
             } else {
                 callback.onUpdate(message);
@@ -747,7 +746,7 @@ export class RebaseWebSocketClient {
                 await this.ensureAuthenticated();
             } catch (error: unknown) {
                 const errorMessage = error instanceof Error ? error.message : "Authentication required";
-                reject(new ApiError(errorMessage, errorMessage));
+                reject(new RebaseApiError(errorMessage));
                 return;
             }
         }
@@ -757,7 +756,7 @@ export class RebaseWebSocketClient {
 
         const expectsResponse = ![
             "subscribe_collection",
-            "subscribe_entity",
+            "subscribe_one",
             "unsubscribe",
             "join_channel",
             "leave_channel",
@@ -771,7 +770,7 @@ export class RebaseWebSocketClient {
             const timeoutHandle = setTimeout(() => {
                 if (this.pendingRequests.has(requestId)) {
                     this.pendingRequests.delete(requestId);
-                    reject(new ApiError("Request timed out", "Request timed out"));
+                    reject(new RebaseApiError("Request timed out"));
                 }
             }, this.requestTimeoutMs);
 
@@ -797,38 +796,39 @@ export class RebaseWebSocketClient {
             if (expectsResponse) {
                 this.pendingRequests.delete(requestId);
             }
-            reject(new ApiError("Failed to send message", error instanceof Error ? error.message : "Unknown error"));
+            reject(new RebaseApiError("Failed to send message", { cause: error }));
         }
     }
 
     // Data source methods
-    async fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]> {
+    async fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Record<string, unknown>[]> {
         const response = await this.sendMessage({
             type: "FETCH_COLLECTION",
             payload: props
-        }) as { entities?: Entity<M>[] };
-        return response.entities || [];
+        }) as { rows?: Record<string, unknown>[] };
+        return (response.rows || []);
     }
 
-    async fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
+    async fetchOne<M extends Record<string, unknown>>(props: FetchOneProps<M>): Promise<Record<string, unknown> | undefined> {
         const response = await this.sendMessage({
-            type: "FETCH_ENTITY",
+            type: "FETCH_ONE",
             payload: props
-        }) as { entity?: Entity<M> };
-        return response.entity ?? undefined;
+        }) as { row?: Record<string, unknown> };
+        const wireEntity = response.row;
+        return wireEntity ?? undefined;
     }
 
-    async saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>> {
+    async save<M extends Record<string, unknown>>(props: SaveProps<M>): Promise<Record<string, unknown>> {
         const response = await this.sendMessage({
-            type: "SAVE_ENTITY",
+            type: "SAVE",
             payload: props
-        }) as { entity: Entity<M> };
-        return response.entity;
+        }) as { row: Record<string, unknown> };
+        return response.row;
     }
 
-    async deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void> {
+    async delete<M extends Record<string, unknown>>(props: DeleteProps<M>): Promise<void> {
         await this.sendMessage({
-            type: "DELETE_ENTITY",
+            type: "DELETE",
             payload: props
         });
     }
@@ -864,23 +864,23 @@ options }
         return response.database;
     }
 
-    async checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean> {
+    async checkUniqueField(path: string, name: string, value: unknown, id?: string, collection?: CollectionConfig): Promise<boolean> {
         const response = await this.sendMessage({
             type: "CHECK_UNIQUE_FIELD",
             payload: {
                 path,
                 name,
                 value,
-                entityId,
+                id,
                 collection
             }
         }) as { isUnique: boolean };
         return response.isUnique;
     }
 
-    async countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number> {
+    async count<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number> {
         const response = await this.sendMessage({
-            type: "COUNT_ENTITIES",
+            type: "COUNT",
             payload: props
         }) as { count: number };
         return response.count;
@@ -1017,52 +1017,50 @@ options }
     }
 
     /**
-     * Merge incoming entities with cached data, preserving cached references
-     * for entities whose values haven't changed. This avoids unnecessary
-     * React re-renders when the server refetches all entities but most
+     * Merge incoming rows with cached data, preserving cached references
+     * for rows whose values haven't changed. This avoids unnecessary
+     * React re-renders when the server refetches all rows but most
      * haven't actually changed.
      */
-    private mergeEntities(cached: Entity[] | undefined, incoming: Entity[]): Entity[] {
+    private mergeRows(cached: Record<string, unknown>[] | undefined, incoming: Record<string, unknown>[]): Record<string, unknown>[] {
         if (!cached || cached.length === 0) return incoming;
 
-        // Build a lookup from cached entities by ID for O(1) access
-        const cachedById = new Map<string | number, Entity>();
-        for (const entity of cached) {
-            cachedById.set(entity.id, entity);
+        // Build a lookup from cached rows by ID for O(1) access
+        const cachedById = new Map<string | number, Record<string, unknown>>();
+        for (const row of cached) {
+            cachedById.set(row.id as string | number, row);
         }
 
-        return incoming.map(incomingEntity => {
-            const cachedEntity = cachedById.get(incomingEntity.id);
-            if (!cachedEntity) return incomingEntity;
+        return incoming.map(incomingRow => {
+            const cachedRow = cachedById.get(incomingRow.id as string | number);
+            if (!cachedRow) return incomingRow;
 
-            if (cachedEntity.path === incomingEntity.path) {
-                const normCached = this.normalizeForComparison(cachedEntity.values) as Record<string, unknown>;
-                const normIncoming = this.normalizeForComparison(incomingEntity.values) as Record<string, unknown>;
+            // Compare flat rows directly (no more path/values nesting)
+            const normCached = this.normalizeForComparison(cachedRow) as Record<string, unknown>;
+            const normIncoming = this.normalizeForComparison(incomingRow) as Record<string, unknown>;
 
-                if (this.deepEqual(normCached, normIncoming)) {
-                    return cachedEntity;
-                } else {
-                    // Deep debug: Why did it fail? Let's check which exact property differs
-                    // so the user can see it in their browser console if flashing still occurs.
-                    const mismatches: Record<string, { cached: unknown, incoming: unknown }> = {};
-                    const allKeys = new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
-                    for (const key of allKeys) {
-                        if (!this.deepEqual(normCached[key], normIncoming[key])) {
-                            mismatches[key] = { cached: normCached[key],
+            if (this.deepEqual(normCached, normIncoming)) {
+                return cachedRow;
+            } else {
+                // Deep debug: Why did it fail?
+                const mismatches: Record<string, { cached: unknown, incoming: unknown }> = {};
+                const allKeys = new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
+                for (const key of allKeys) {
+                    if (!this.deepEqual(normCached[key], normIncoming[key])) {
+                        mismatches[key] = { cached: normCached[key],
 incoming: normIncoming[key] };
-                        }
                     }
-                    console.debug(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
                 }
+                console.debug(`[RebaseWS] Row ${incomingRow.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
             }
-            return incomingEntity;
+            return incomingRow;
         });
     }
 
     // Subscription methods
     listenCollection<M extends Record<string, unknown>>(
         props: FetchCollectionProps<M>,
-        onUpdate: (entities: Entity[]) => void,
+        onUpdate: (rows: Record<string, unknown>[]) => void,
         onError?: (error: Error) => void
     ): () => void {
         const subscriptionKey = this.createCollectionSubscriptionKey(props);
@@ -1074,7 +1072,7 @@ incoming: normIncoming[key] };
         if (existingSubscription) {
             // Reuse existing subscription - just add the new callback
             const callbackMap = existingSubscription.callbacks as Map<string, {
-                onUpdate: (entities: Entity[]) => void;
+                onUpdate: (rows: Record<string, unknown>[]) => void;
                 onError?: (error: Error) => void;
             }>;
             callbackMap.set(callbackId, { onUpdate,
@@ -1112,7 +1110,7 @@ onError });
         // Create new subscription
         const backendSubscriptionId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const callbackMap = new Map<string, {
-            onUpdate: (entities: Entity[]) => void;
+            onUpdate: (rows: Record<string, unknown>[]) => void;
             onError?: (error: Error) => void;
         }>();
         callbackMap.set(callbackId, { onUpdate,
@@ -1158,21 +1156,21 @@ onError });
         };
     }
 
-    listenEntity<M extends Record<string, unknown>>(
-        props: FetchEntityProps<M>,
-        onUpdate: (entity: Entity | null) => void,
+    listenOne<M extends Record<string, unknown>>(
+        props: FetchOneProps<M>,
+        onUpdate: (row: Record<string, unknown> | null) => void,
         onError?: (error: Error) => void
     ): () => void {
-        const subscriptionKey = this.createEntitySubscriptionKey(props);
+        const subscriptionKey = this.createSingleSubscriptionKey(props);
         const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 
         // Check if we already have a subscription for these exact parameters
-        const existingSubscription = this.entitySubscriptions.get(subscriptionKey);
+        const existingSubscription = this.singleSubscriptions.get(subscriptionKey);
 
         if (existingSubscription) {
             // Reuse existing subscription - just add the new callback
             const callbackMap = existingSubscription.callbacks as Map<string, {
-                onUpdate: (entity: Entity | null) => void;
+                onUpdate: (row: Record<string, unknown> | null) => void;
                 onError?: (error: Error) => void;
             }>;
             callbackMap.set(callbackId, { onUpdate,
@@ -1183,7 +1181,7 @@ onError });
                 try {
                     onUpdate(existingSubscription.latestData);
                 } catch (error) {
-                    console.error("Error in entity subscription callback:", error);
+                    console.error("Error in row subscription callback:", error);
                     if (onError) {
                         onError(error instanceof Error ? error : new Error(String(error)));
                     }
@@ -1195,7 +1193,7 @@ onError });
                 callbackMap.delete(callbackId);
                 if (callbackMap.size === 0) {
                     // No more callbacks, unsubscribe from backend
-                    this.entitySubscriptions.delete(subscriptionKey);
+                    this.singleSubscriptions.delete(subscriptionKey);
                     this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
                     if (this.isConnected && this.ws) {
                         this.sendMessage({
@@ -1210,13 +1208,13 @@ onError });
         // Create new subscription
         const backendSubscriptionId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const callbackMap = new Map<string, {
-            onUpdate: (entity: Entity | null) => void;
+            onUpdate: (row: Record<string, unknown> | null) => void;
             onError?: (error: Error) => void;
         }>();
         callbackMap.set(callbackId, { onUpdate,
 onError });
 
-        this.entitySubscriptions.set(subscriptionKey, {
+        this.singleSubscriptions.set(subscriptionKey, {
             backendSubscriptionId,
             callbacks: callbackMap,
             props
@@ -1227,7 +1225,7 @@ onError });
 
         // Send subscription request to backend
         this.sendMessage({
-            type: "subscribe_entity",
+            type: "subscribe_one",
             payload: {
                 ...props,
                 subscriptionId: backendSubscriptionId
@@ -1238,12 +1236,12 @@ onError });
 
         // Return unsubscribe function
         return () => {
-            const subscription = this.entitySubscriptions.get(subscriptionKey);
+            const subscription = this.singleSubscriptions.get(subscriptionKey);
             if (subscription) {
                 const callbacks = subscription.callbacks;
                 callbacks.delete(callbackId);
                 if (callbacks.size === 0) {
-                    this.entitySubscriptions.delete(subscriptionKey);
+                    this.singleSubscriptions.delete(subscriptionKey);
                     this.backendToEntityKey.delete(subscription.backendSubscriptionId);
                     if (this.isConnected && this.ws) {
                         this.sendMessage({
@@ -1262,7 +1260,7 @@ onError });
      * we need to re-register everything to resume receiving updates.
      */
     private resubscribeAll(): void {
-        console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
+        console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.singleSubscriptions.size} row(ies)`);
 
         // Re-subscribe collection subscriptions
         for (const [key, sub] of this.collectionSubscriptions.entries()) {
@@ -1286,8 +1284,8 @@ onError });
             });
         }
 
-        // Re-subscribe entity subscriptions
-        for (const [key, sub] of this.entitySubscriptions.entries()) {
+        // Re-subscribe row subscriptions
+        for (const [key, sub] of this.singleSubscriptions.entries()) {
             const oldBackendId = sub.backendSubscriptionId;
             const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
             sub.backendSubscriptionId = newBackendId;
@@ -1296,13 +1294,13 @@ onError });
             this.backendToEntityKey.set(newBackendId, key);
 
             this.sendMessage({
-                type: "subscribe_entity",
+                type: "subscribe_one",
                 payload: {
                     ...sub.props,
                     subscriptionId: newBackendId
                 }
             }).catch(error => {
-                console.error("[WS] Failed to re-subscribe entity:", key, error);
+                console.error("[WS] Failed to re-subscribe row:", key, error);
             });
         }
     }
@@ -1331,7 +1329,7 @@ onError });
         });
     }
 
-    private createEntitySubscriptionKey(props: FetchEntityProps): string {
-        return `${props.path}|${props.entityId}`;
+    private createSingleSubscriptionKey(props: FetchOneProps): string {
+        return `${props.path}|${props.id}`;
     }
 }