hyperstack-typescript 0.3.1 → 0.3.3

package/dist/index.js

@@ -17,40 +17,32 @@ class HyperStackError extends Error {
     }
 }
 
-function isCompressedFrame(obj) {
-    return (typeof obj === 'object' &&
-        obj !== null &&
-        obj.compressed === 'gzip' &&
-        typeof obj.data === 'string');
-}
-function decompressGzip(base64Data) {
-    const binaryString = atob(base64Data);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    const decompressed = pako.inflate(bytes);
-    return new TextDecoder().decode(decompressed);
-}
-function parseAndDecompress(jsonString) {
-    const parsed = JSON.parse(jsonString);
-    if (isCompressedFrame(parsed)) {
-        const decompressedJson = decompressGzip(parsed.data);
-        const frame = JSON.parse(decompressedJson);
-        return frame;
-    }
-    return parsed;
+const GZIP_MAGIC_0 = 0x1f;
+const GZIP_MAGIC_1 = 0x8b;
+function isGzipData(data) {
+    return data.length >= 2 && data[0] === GZIP_MAGIC_0 && data[1] === GZIP_MAGIC_1;
 }
 function isSnapshotFrame(frame) {
     return frame.op === 'snapshot';
 }
+function isSubscribedFrame(frame) {
+    return frame.op === 'subscribed';
+}
+function isEntityFrame(frame) {
+    return ['create', 'upsert', 'patch', 'delete'].includes(frame.op);
+}
 function parseFrame(data) {
     if (typeof data === 'string') {
-        return parseAndDecompress(data);
+        return JSON.parse(data);
+    }
+    const bytes = new Uint8Array(data);
+    if (isGzipData(bytes)) {
+        const decompressed = pako.inflate(bytes);
+        const jsonString = new TextDecoder().decode(decompressed);
+        return JSON.parse(jsonString);
     }
-    const decoder = new TextDecoder('utf-8');
-    const jsonString = decoder.decode(data);
-    return parseAndDecompress(jsonString);
+    const jsonString = new TextDecoder('utf-8').decode(data);
+    return JSON.parse(jsonString);
 }
 async function parseFrameFromBlob(blob) {
     const arrayBuffer = await blob.arrayBuffer();
@@ -125,8 +117,8 @@ class ConnectionManager {
                     this.reconnectAttempts = 0;
                     this.updateState('connected');
                     this.startPingInterval();
-                    this.flushSubscriptionQueue();
                     this.resubscribeActive();
+                    this.flushSubscriptionQueue();
                     resolve();
                 };
                 this.ws.onmessage = async (event) => {
@@ -147,7 +139,6 @@ class ConnectionManager {
                         this.notifyFrameHandlers(frame);
                     }
                     catch (error) {
-                        console.error('[hyperstack] Error parsing frame:', error);
                         this.updateState('error', 'Failed to parse frame from server');
                     }
                 };
@@ -185,12 +176,18 @@ class ConnectionManager {
     subscribe(subscription) {
         const subKey = this.makeSubKey(subscription);
         if (this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
+            if (this.activeSubscriptions.has(subKey)) {
+                return;
+            }
             const subMsg = { type: 'subscribe', ...subscription };
             this.ws.send(JSON.stringify(subMsg));
             this.activeSubscriptions.add(subKey);
         }
         else {
-            this.subscriptionQueue.push(subscription);
+            const alreadyQueued = this.subscriptionQueue.some((s) => this.makeSubKey(s) === subKey);
+            if (!alreadyQueued) {
+                this.subscriptionQueue.push(subscription);
+            }
         }
     }
     unsubscribe(view, key) {
@@ -280,11 +277,11 @@ class ConnectionManager {
     }
 }
 
-function isObject(item) {
+function isObject$1(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
 }
-function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
-    if (!isObject(target) || !isObject(source)) {
+function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
+    if (!isObject$1(target) || !isObject$1(source)) {
         return source;
     }
     const result = { ...target };
@@ -300,8 +297,8 @@ function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
                 result[key] = sourceValue;
             }
         }
-        else if (isObject(sourceValue) && isObject(targetValue)) {
-            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
+        else if (isObject$1(sourceValue) && isObject$1(targetValue)) {
+            result[key] = deepMergeWithAppend$1(targetValue, sourceValue, appendPaths, fieldPath);
         }
         else {
             result[key] = sourceValue;
@@ -311,20 +308,107 @@ function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
 }
 class FrameProcessor {
     constructor(storage, config = {}) {
+        this.pendingUpdates = [];
+        this.flushTimer = null;
+        this.isProcessing = false;
         this.storage = storage;
         this.maxEntriesPerView = config.maxEntriesPerView === undefined
             ? DEFAULT_MAX_ENTRIES_PER_VIEW
             : config.maxEntriesPerView;
+        this.flushIntervalMs = config.flushIntervalMs ?? 0;
     }
     handleFrame(frame) {
-        if (isSnapshotFrame(frame)) {
+        if (this.flushIntervalMs === 0) {
+            this.processFrame(frame);
+            return;
+        }
+        this.pendingUpdates.push({ frame });
+        this.scheduleFlush();
+    }
+    /**
+     * Immediately flush all pending updates.
+     * Useful for ensuring all updates are processed before reading state.
+     */
+    flush() {
+        if (this.flushTimer !== null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flushPendingUpdates();
+    }
+    /**
+     * Clean up any pending timers. Call when disposing the processor.
+     */
+    dispose() {
+        if (this.flushTimer !== null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.pendingUpdates = [];
+    }
+    scheduleFlush() {
+        if (this.flushTimer !== null) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flushPendingUpdates();
+        }, this.flushIntervalMs);
+    }
+    flushPendingUpdates() {
+        if (this.isProcessing || this.pendingUpdates.length === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        const batch = this.pendingUpdates;
+        this.pendingUpdates = [];
+        const viewsToEnforce = new Set();
+        for (const { frame } of batch) {
+            const viewPath = this.processFrameWithoutEnforce(frame);
+            if (viewPath) {
+                viewsToEnforce.add(viewPath);
+            }
+        }
+        viewsToEnforce.forEach((viewPath) => {
+            this.enforceMaxEntries(viewPath);
+        });
+        this.isProcessing = false;
+    }
+    processFrame(frame) {
+        if (isSubscribedFrame(frame)) {
+            this.handleSubscribedFrame(frame);
+        }
+        else if (isSnapshotFrame(frame)) {
             this.handleSnapshotFrame(frame);
         }
         else {
             this.handleEntityFrame(frame);
         }
     }
+    processFrameWithoutEnforce(frame) {
+        if (isSubscribedFrame(frame)) {
+            this.handleSubscribedFrame(frame);
+            return null;
+        }
+        else if (isSnapshotFrame(frame)) {
+            this.handleSnapshotFrameWithoutEnforce(frame);
+            return frame.entity;
+        }
+        else {
+            this.handleEntityFrameWithoutEnforce(frame);
+            return frame.entity;
+        }
+    }
+    handleSubscribedFrame(frame) {
+        if (this.storage.setViewConfig && frame.sort) {
+            this.storage.setViewConfig(frame.view, { sort: frame.sort });
+        }
+    }
     handleSnapshotFrame(frame) {
+        this.handleSnapshotFrameWithoutEnforce(frame);
+        this.enforceMaxEntries(frame.entity);
+    }
+    handleSnapshotFrameWithoutEnforce(frame) {
         const viewPath = frame.entity;
         for (const entity of frame.data) {
             const previousValue = this.storage.get(viewPath, entity.key);
@@ -336,16 +420,18 @@ class FrameProcessor {
             });
             this.emitRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
         }
-        this.enforceMaxEntries(viewPath);
     }
     handleEntityFrame(frame) {
+        this.handleEntityFrameWithoutEnforce(frame);
+        this.enforceMaxEntries(frame.entity);
+    }
+    handleEntityFrameWithoutEnforce(frame) {
         const viewPath = frame.entity;
         const previousValue = this.storage.get(viewPath, frame.key);
         switch (frame.op) {
             case 'create':
             case 'upsert':
                 this.storage.set(viewPath, frame.key, frame.data);
-                this.enforceMaxEntries(viewPath);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'upsert',
                     key: frame.key,
@@ -357,10 +443,9 @@ class FrameProcessor {
                 const existing = this.storage.get(viewPath, frame.key);
                 const appendPaths = frame.append ?? [];
                 const merged = existing
-                    ? deepMergeWithAppend(existing, frame.data, appendPaths)
+                    ? deepMergeWithAppend$1(existing, frame.data, appendPaths)
                     : frame.data;
                 this.storage.set(viewPath, frame.key, merged);
-                this.enforceMaxEntries(viewPath);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'patch',
                     key: frame.key,
@@ -399,7 +484,7 @@ class FrameProcessor {
     }
 }
 
-class ViewData {
+let ViewData$1 = class ViewData {
     constructor() {
         this.entities = new Map();
         this.accessOrder = [];
@@ -453,7 +538,7 @@ class ViewData {
         this.entities.clear();
         this.accessOrder = [];
     }
-}
+};
 class MemoryAdapter {
     constructor(_config = {}) {
         this.views = new Map();
@@ -501,7 +586,7 @@ class MemoryAdapter {
     set(viewPath, key, data) {
         let view = this.views.get(viewPath);
         if (!view) {
-            view = new ViewData();
+            view = new ViewData$1();
             this.views.set(viewPath, view);
         }
         view.set(key, data);
@@ -842,9 +927,430 @@ class HyperStack {
     }
 }
 
+function getNestedValue(obj, path) {
+    let current = obj;
+    for (const segment of path) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function compareSortValues(a, b) {
+    if (a === b)
+        return 0;
+    if (a === undefined || a === null)
+        return -1;
+    if (b === undefined || b === null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number') {
+        return a - b;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b);
+    }
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+        return (a ? 1 : 0) - (b ? 1 : 0);
+    }
+    return String(a).localeCompare(String(b));
+}
+class ViewData {
+    constructor(sortConfig) {
+        this.entities = new Map();
+        this.accessOrder = [];
+        this.sortedKeys = [];
+        this.sortConfig = sortConfig;
+    }
+    get(key) {
+        return this.entities.get(key);
+    }
+    set(key, value) {
+        const isNew = !this.entities.has(key);
+        this.entities.set(key, value);
+        if (this.sortConfig) {
+            this.updateSortedPosition(key, value, isNew);
+        }
+        else {
+            if (isNew) {
+                this.accessOrder.push(key);
+            }
+            else {
+                this.touch(key);
+            }
+        }
+    }
+    updateSortedPosition(key, value, isNew) {
+        if (!isNew) {
+            const existingIdx = this.sortedKeys.indexOf(key);
+            if (existingIdx !== -1) {
+                this.sortedKeys.splice(existingIdx, 1);
+            }
+        }
+        const sortValue = getNestedValue(value, this.sortConfig.field);
+        const isDesc = this.sortConfig.order === 'desc';
+        let insertIdx = this.binarySearchInsertPosition(sortValue, key, isDesc);
+        this.sortedKeys.splice(insertIdx, 0, key);
+    }
+    binarySearchInsertPosition(sortValue, key, isDesc) {
+        let low = 0;
+        let high = this.sortedKeys.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            const midKey = this.sortedKeys[mid];
+            const midEntity = this.entities.get(midKey);
+            const midValue = getNestedValue(midEntity, this.sortConfig.field);
+            let cmp = compareSortValues(sortValue, midValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = key.localeCompare(midKey);
+            }
+            if (cmp < 0) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+    delete(key) {
+        if (this.sortConfig) {
+            const idx = this.sortedKeys.indexOf(key);
+            if (idx !== -1) {
+                this.sortedKeys.splice(idx, 1);
+            }
+        }
+        else {
+            const idx = this.accessOrder.indexOf(key);
+            if (idx !== -1) {
+                this.accessOrder.splice(idx, 1);
+            }
+        }
+        return this.entities.delete(key);
+    }
+    has(key) {
+        return this.entities.has(key);
+    }
+    values() {
+        if (this.sortConfig) {
+            return this.sortedKeys.map(k => this.entities.get(k));
+        }
+        return Array.from(this.entities.values());
+    }
+    keys() {
+        if (this.sortConfig) {
+            return [...this.sortedKeys];
+        }
+        return Array.from(this.entities.keys());
+    }
+    get size() {
+        return this.entities.size;
+    }
+    touch(key) {
+        if (this.sortConfig)
+            return;
+        const idx = this.accessOrder.indexOf(key);
+        if (idx !== -1) {
+            this.accessOrder.splice(idx, 1);
+            this.accessOrder.push(key);
+        }
+    }
+    evictOldest() {
+        if (this.sortConfig) {
+            const oldest = this.sortedKeys.pop();
+            if (oldest !== undefined) {
+                this.entities.delete(oldest);
+            }
+            return oldest;
+        }
+        const oldest = this.accessOrder.shift();
+        if (oldest !== undefined) {
+            this.entities.delete(oldest);
+        }
+        return oldest;
+    }
+    setSortConfig(config) {
+        if (this.sortConfig)
+            return;
+        this.sortConfig = config;
+        this.rebuildSortedKeys();
+    }
+    rebuildSortedKeys() {
+        if (!this.sortConfig)
+            return;
+        const entries = Array.from(this.entities.entries());
+        const isDesc = this.sortConfig.order === 'desc';
+        entries.sort((a, b) => {
+            const aValue = getNestedValue(a[1], this.sortConfig.field);
+            const bValue = getNestedValue(b[1], this.sortConfig.field);
+            let cmp = compareSortValues(aValue, bValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = a[0].localeCompare(b[0]);
+            }
+            return cmp;
+        });
+        this.sortedKeys = entries.map(([k]) => k);
+        this.accessOrder = [];
+    }
+    getSortConfig() {
+        return this.sortConfig;
+    }
+}
+function isObject(item) {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+}
+function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
+    if (!isObject(target) || !isObject(source)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+        if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+            if (appendPaths.includes(fieldPath)) {
+                result[key] = [...targetValue, ...sourceValue];
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+        else if (isObject(sourceValue) && isObject(targetValue)) {
+            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+class EntityStore {
+    constructor(config = {}) {
+        this.views = new Map();
+        this.viewConfigs = new Map();
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
+        this.maxEntriesPerView = config.maxEntriesPerView === undefined
+            ? DEFAULT_MAX_ENTRIES_PER_VIEW
+            : config.maxEntriesPerView;
+    }
+    enforceMaxEntries(viewData) {
+        if (this.maxEntriesPerView === null)
+            return;
+        while (viewData.size > this.maxEntriesPerView) {
+            viewData.evictOldest();
+        }
+    }
+    handleFrame(frame) {
+        if (isSubscribedFrame(frame)) {
+            this.handleSubscribedFrame(frame);
+            return;
+        }
+        if (isSnapshotFrame(frame)) {
+            this.handleSnapshotFrame(frame);
+            return;
+        }
+        this.handleEntityFrame(frame);
+    }
+    handleSubscribedFrame(frame) {
+        const viewPath = frame.view;
+        const config = {};
+        if (frame.sort) {
+            config.sort = frame.sort;
+        }
+        this.viewConfigs.set(viewPath, config);
+        const existingView = this.views.get(viewPath);
+        if (existingView && frame.sort) {
+            existingView.setSortConfig(frame.sort);
+        }
+    }
+    handleSnapshotFrame(frame) {
+        const viewPath = frame.entity;
+        let viewData = this.views.get(viewPath);
+        const viewConfig = this.viewConfigs.get(viewPath);
+        if (!viewData) {
+            viewData = new ViewData(viewConfig?.sort);
+            this.views.set(viewPath, viewData);
+        }
+        for (const entity of frame.data) {
+            const previousValue = viewData.get(entity.key);
+            viewData.set(entity.key, entity.data);
+            this.notifyUpdate(viewPath, entity.key, {
+                type: 'upsert',
+                key: entity.key,
+                data: entity.data,
+            });
+            this.notifyRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+        }
+        this.enforceMaxEntries(viewData);
+    }
+    handleEntityFrame(frame) {
+        const viewPath = frame.entity;
+        let viewData = this.views.get(viewPath);
+        const viewConfig = this.viewConfigs.get(viewPath);
+        if (!viewData) {
+            viewData = new ViewData(viewConfig?.sort);
+            this.views.set(viewPath, viewData);
+        }
+        const previousValue = viewData.get(frame.key);
+        switch (frame.op) {
+            case 'create':
+            case 'upsert':
+                viewData.set(frame.key, frame.data);
+                this.enforceMaxEntries(viewData);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'upsert',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.notifyRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
+                break;
+            case 'patch': {
+                const existing = viewData.get(frame.key);
+                const appendPaths = frame.append ?? [];
+                const merged = existing
+                    ? deepMergeWithAppend(existing, frame.data, appendPaths)
+                    : frame.data;
+                viewData.set(frame.key, merged);
+                this.enforceMaxEntries(viewData);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'patch',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.notifyRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                break;
+            }
+            case 'delete':
+                viewData.delete(frame.key);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'delete',
+                    key: frame.key,
+                });
+                if (previousValue !== undefined) {
+                    this.notifyRichDelete(viewPath, frame.key, previousValue);
+                }
+                break;
+        }
+    }
+    getAll(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return [];
+        return viewData.values();
+    }
+    get(viewPath, key) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return null;
+        const value = viewData.get(key);
+        return value !== undefined ? value : null;
+    }
+    getAllSync(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return undefined;
+        return viewData.values();
+    }
+    getSync(viewPath, key) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return undefined;
+        const value = viewData.get(key);
+        return value !== undefined ? value : null;
+    }
+    keys(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return [];
+        return viewData.keys();
+    }
+    size(viewPath) {
+        const viewData = this.views.get(viewPath);
+        return viewData?.size ?? 0;
+    }
+    clear() {
+        this.views.clear();
+    }
+    clearView(viewPath) {
+        this.views.delete(viewPath);
+        this.viewConfigs.delete(viewPath);
+    }
+    getViewConfig(viewPath) {
+        return this.viewConfigs.get(viewPath);
+    }
+    setViewConfig(viewPath, config) {
+        this.viewConfigs.set(viewPath, config);
+        const existingView = this.views.get(viewPath);
+        if (existingView && config.sort) {
+            existingView.setSortConfig(config.sort);
+        }
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.add(callback);
+        return () => {
+            this.updateCallbacks.delete(callback);
+        };
+    }
+    onRichUpdate(callback) {
+        this.richUpdateCallbacks.add(callback);
+        return () => {
+            this.richUpdateCallbacks.delete(callback);
+        };
+    }
+    subscribe(viewPath, callback) {
+        const handler = (path, _key, update) => {
+            if (path === viewPath) {
+                callback(update);
+            }
+        };
+        this.updateCallbacks.add(handler);
+        return () => {
+            this.updateCallbacks.delete(handler);
+        };
+    }
+    subscribeToKey(viewPath, key, callback) {
+        const handler = (path, updateKey, update) => {
+            if (path === viewPath && updateKey === key) {
+                callback(update);
+            }
+        };
+        this.updateCallbacks.add(handler);
+        return () => {
+            this.updateCallbacks.delete(handler);
+        };
+    }
+    notifyUpdate(viewPath, key, update) {
+        for (const callback of this.updateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    notifyRichUpdate(viewPath, key, before, after, _op, patch) {
+        const richUpdate = before === undefined
+            ? { type: 'created', key, data: after }
+            : { type: 'updated', key, before, after, patch };
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, richUpdate);
+        }
+    }
+    notifyRichDelete(viewPath, key, lastKnown) {
+        const richUpdate = { type: 'deleted', key, lastKnown };
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, richUpdate);
+        }
+    }
+}
+
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
+exports.EntityStore = EntityStore;
 exports.FrameProcessor = FrameProcessor;
 exports.HyperStack = HyperStack;
 exports.HyperStackError = HyperStackError;
@@ -855,7 +1361,9 @@ exports.createTypedListView = createTypedListView;
 exports.createTypedStateView = createTypedStateView;
 exports.createTypedViews = createTypedViews;
 exports.createUpdateStream = createUpdateStream;
+exports.isEntityFrame = isEntityFrame;
 exports.isSnapshotFrame = isSnapshotFrame;
+exports.isSubscribedFrame = isSubscribedFrame;
 exports.isValidFrame = isValidFrame;
 exports.parseFrame = parseFrame;
 exports.parseFrameFromBlob = parseFrameFromBlob;