hyperstack-typescript 0.2.5 → 0.3.0

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var pako = require('pako');
+
 const DEFAULT_MAX_ENTRIES_PER_VIEW = 10000;
 const DEFAULT_CONFIG = {
     reconnectIntervals: [1000, 2000, 4000, 8000, 16000],
@@ -15,16 +17,40 @@ 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;
+}
 function isSnapshotFrame(frame) {
     return frame.op === 'snapshot';
 }
 function parseFrame(data) {
     if (typeof data === 'string') {
-        return JSON.parse(data);
+        return parseAndDecompress(data);
     }
     const decoder = new TextDecoder('utf-8');
     const jsonString = decoder.decode(data);
-    return JSON.parse(jsonString);
+    return parseAndDecompress(jsonString);
 }
 async function parseFrameFromBlob(blob) {
     const arrayBuffer = await blob.arrayBuffer();
@@ -121,6 +147,7 @@ class ConnectionManager {
                         this.notifyFrameHandlers(frame);
                     }
                     catch (error) {
+                        console.error('[hyperstack] Error parsing frame:', error);
                         this.updateState('error', 'Failed to parse frame from server');
                     }
                 };
@@ -253,57 +280,6 @@ class ConnectionManager {
     }
 }
 
-class ViewData {
-    constructor() {
-        this.entities = new Map();
-        this.accessOrder = [];
-    }
-    get(key) {
-        return this.entities.get(key);
-    }
-    set(key, value) {
-        if (!this.entities.has(key)) {
-            this.accessOrder.push(key);
-        }
-        else {
-            this.touch(key);
-        }
-        this.entities.set(key, value);
-    }
-    delete(key) {
-        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() {
-        return this.entities.values();
-    }
-    keys() {
-        return this.entities.keys();
-    }
-    get size() {
-        return this.entities.size;
-    }
-    touch(key) {
-        const idx = this.accessOrder.indexOf(key);
-        if (idx !== -1) {
-            this.accessOrder.splice(idx, 1);
-            this.accessOrder.push(key);
-        }
-    }
-    evictOldest() {
-        const oldest = this.accessOrder.shift();
-        if (oldest !== undefined) {
-            this.entities.delete(oldest);
-        }
-        return oldest;
-    }
-}
 function isObject(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
 }
@@ -333,189 +309,234 @@ function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
     }
     return result;
 }
-class EntityStore {
-    constructor(config = {}) {
-        this.views = new Map();
-        this.updateCallbacks = new Set();
-        this.richUpdateCallbacks = new Set();
+class FrameProcessor {
+    constructor(storage, config = {}) {
+        this.storage = storage;
         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 (isSnapshotFrame(frame)) {
             this.handleSnapshotFrame(frame);
-            return;
         }
-        this.handleEntityFrame(frame);
+        else {
+            this.handleEntityFrame(frame);
+        }
     }
     handleSnapshotFrame(frame) {
         const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData();
-            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, {
+            const previousValue = this.storage.get(viewPath, entity.key);
+            this.storage.set(viewPath, entity.key, entity.data);
+            this.storage.notifyUpdate(viewPath, entity.key, {
                 type: 'upsert',
                 key: entity.key,
                 data: entity.data,
             });
-            this.notifyRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+            this.emitRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
         }
-        this.enforceMaxEntries(viewData);
+        this.enforceMaxEntries(viewPath);
     }
     handleEntityFrame(frame) {
         const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData();
-            this.views.set(viewPath, viewData);
-        }
-        const previousValue = viewData.get(frame.key);
+        const previousValue = this.storage.get(viewPath, frame.key);
         switch (frame.op) {
             case 'create':
             case 'upsert':
-                viewData.set(frame.key, frame.data);
-                this.enforceMaxEntries(viewData);
-                this.notifyUpdate(viewPath, frame.key, {
+                this.storage.set(viewPath, frame.key, frame.data);
+                this.enforceMaxEntries(viewPath);
+                this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'upsert',
                     key: frame.key,
                     data: frame.data,
                 });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
+                this.emitRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
                 break;
             case 'patch': {
-                const existing = viewData.get(frame.key);
+                const existing = this.storage.get(viewPath, 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, {
+                this.storage.set(viewPath, frame.key, merged);
+                this.enforceMaxEntries(viewPath);
+                this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'patch',
                     key: frame.key,
                     data: frame.data,
                 });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                this.emitRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
                 break;
             }
             case 'delete':
-                viewData.delete(frame.key);
-                this.notifyUpdate(viewPath, frame.key, {
+                this.storage.delete(viewPath, frame.key);
+                this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'delete',
                     key: frame.key,
                 });
-                if (previousValue !== undefined) {
-                    this.notifyRichDelete(viewPath, frame.key, previousValue);
+                if (previousValue !== null) {
+                    const richUpdate = { type: 'deleted', key: frame.key, lastKnown: previousValue };
+                    this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                 }
                 break;
         }
     }
-    getAll(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return [];
-        return Array.from(viewData.values());
+    emitRichUpdate(viewPath, key, before, after, _op, patch) {
+        const richUpdate = before === null
+            ? { type: 'created', key, data: after }
+            : { type: 'updated', key, before, after, patch };
+        this.storage.notifyRichUpdate(viewPath, key, richUpdate);
+    }
+    enforceMaxEntries(viewPath) {
+        if (this.maxEntriesPerView === null)
+            return;
+        if (!this.storage.evictOldest)
+            return;
+        while (this.storage.size(viewPath) > this.maxEntriesPerView) {
+            this.storage.evictOldest(viewPath);
+        }
+    }
+}
+
+class ViewData {
+    constructor() {
+        this.entities = new Map();
+        this.accessOrder = [];
+    }
+    get(key) {
+        return this.entities.get(key);
+    }
+    set(key, value) {
+        if (!this.entities.has(key)) {
+            this.accessOrder.push(key);
+        }
+        else {
+            this.touch(key);
+        }
+        this.entities.set(key, value);
+    }
+    delete(key) {
+        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() {
+        return this.entities.values();
+    }
+    keys() {
+        return this.entities.keys();
+    }
+    get size() {
+        return this.entities.size;
+    }
+    touch(key) {
+        const idx = this.accessOrder.indexOf(key);
+        if (idx !== -1) {
+            this.accessOrder.splice(idx, 1);
+            this.accessOrder.push(key);
+        }
+    }
+    evictOldest() {
+        const oldest = this.accessOrder.shift();
+        if (oldest !== undefined) {
+            this.entities.delete(oldest);
+        }
+        return oldest;
+    }
+    clear() {
+        this.entities.clear();
+        this.accessOrder = [];
+    }
+}
+class MemoryAdapter {
+    constructor(_config = {}) {
+        this.views = new Map();
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
     }
     get(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
+        const view = this.views.get(viewPath);
+        if (!view)
             return null;
-        const value = viewData.get(key);
+        const value = view.get(key);
         return value !== undefined ? value : null;
     }
+    getAll(viewPath) {
+        const view = this.views.get(viewPath);
+        if (!view)
+            return [];
+        return Array.from(view.values());
+    }
     getAllSync(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
+        const view = this.views.get(viewPath);
+        if (!view)
             return undefined;
-        return Array.from(viewData.values());
+        return Array.from(view.values());
     }
     getSync(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
+        const view = this.views.get(viewPath);
+        if (!view)
             return undefined;
-        const value = viewData.get(key);
+        const value = view.get(key);
         return value !== undefined ? value : null;
     }
+    has(viewPath, key) {
+        return this.views.get(viewPath)?.has(key) ?? false;
+    }
     keys(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
+        const view = this.views.get(viewPath);
+        if (!view)
             return [];
-        return Array.from(viewData.keys());
+        return Array.from(view.keys());
     }
     size(viewPath) {
-        const viewData = this.views.get(viewPath);
-        return viewData?.size ?? 0;
+        return this.views.get(viewPath)?.size ?? 0;
     }
-    clear() {
-        this.views.clear();
+    set(viewPath, key, data) {
+        let view = this.views.get(viewPath);
+        if (!view) {
+            view = new ViewData();
+            this.views.set(viewPath, view);
+        }
+        view.set(key, data);
+    }
+    delete(viewPath, key) {
+        this.views.get(viewPath)?.delete(key);
     }
-    clearView(viewPath) {
-        this.views.delete(viewPath);
+    clear(viewPath) {
+        if (viewPath) {
+            this.views.get(viewPath)?.clear();
+            this.views.delete(viewPath);
+        }
+        else {
+            this.views.clear();
+        }
+    }
+    evictOldest(viewPath) {
+        return this.views.get(viewPath)?.evictOldest();
     }
     onUpdate(callback) {
         this.updateCallbacks.add(callback);
-        return () => {
-            this.updateCallbacks.delete(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);
-        };
+        return () => this.richUpdateCallbacks.delete(callback);
     }
     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 };
+    notifyRichUpdate(viewPath, key, update) {
         for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, richUpdate);
+            callback(viewPath, key, update);
         }
     }
 }
@@ -571,12 +592,12 @@ class SubscriptionRegistry {
 }
 
 const MAX_QUEUE_SIZE = 1000;
-function createUpdateStream(store, subscriptionRegistry, subscription, keyFilter) {
+function createUpdateStream(storage, subscriptionRegistry, subscription, keyFilter) {
     return {
         [Symbol.asyncIterator]() {
             const queue = [];
             let waitingResolve = null;
-            let unsubscribeStore = null;
+            let unsubscribeStorage = null;
             let unsubscribeRegistry = null;
             let done = false;
             const handler = (viewPath, key, update) => {
@@ -601,12 +622,12 @@ function createUpdateStream(store, subscriptionRegistry, subscription, keyFilter
                 }
             };
             const start = () => {
-                unsubscribeStore = store.onUpdate(handler);
+                unsubscribeStorage = storage.onUpdate(handler);
                 unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
             };
             const cleanup = () => {
                 done = true;
-                unsubscribeStore?.();
+                unsubscribeStorage?.();
                 unsubscribeRegistry?.();
             };
             start();
@@ -635,12 +656,12 @@ function createUpdateStream(store, subscriptionRegistry, subscription, keyFilter
         },
     };
 }
-function createRichUpdateStream(store, subscriptionRegistry, subscription, keyFilter) {
+function createRichUpdateStream(storage, subscriptionRegistry, subscription, keyFilter) {
     return {
         [Symbol.asyncIterator]() {
             const queue = [];
             let waitingResolve = null;
-            let unsubscribeStore = null;
+            let unsubscribeStorage = null;
             let unsubscribeRegistry = null;
             let done = false;
             const handler = (viewPath, key, update) => {
@@ -665,12 +686,12 @@ function createRichUpdateStream(store, subscriptionRegistry, subscription, keyFi
                 }
             };
             const start = () => {
-                unsubscribeStore = store.onRichUpdate(handler);
+                unsubscribeStorage = storage.onRichUpdate(handler);
                 unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
             };
             const cleanup = () => {
                 done = true;
-                unsubscribeStore?.();
+                unsubscribeStorage?.();
                 unsubscribeRegistry?.();
             };
             start();
@@ -700,48 +721,48 @@ function createRichUpdateStream(store, subscriptionRegistry, subscription, keyFi
     };
 }
 
-function createTypedStateView(viewDef, store, subscriptionRegistry) {
+function createTypedStateView(viewDef, storage, subscriptionRegistry) {
     return {
         watch(key) {
-            return createUpdateStream(store, subscriptionRegistry, { view: viewDef.view, key }, key);
+            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key }, key);
         },
         watchRich(key) {
-            return createRichUpdateStream(store, subscriptionRegistry, { view: viewDef.view, key }, key);
+            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key }, key);
         },
         async get(key) {
-            return store.get(viewDef.view, key);
+            return storage.get(viewDef.view, key);
         },
         getSync(key) {
-            return store.getSync(viewDef.view, key);
+            return storage.getSync(viewDef.view, key);
         },
     };
 }
-function createTypedListView(viewDef, store, subscriptionRegistry) {
+function createTypedListView(viewDef, storage, subscriptionRegistry) {
     return {
         watch() {
-            return createUpdateStream(store, subscriptionRegistry, { view: viewDef.view });
+            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view });
         },
         watchRich() {
-            return createRichUpdateStream(store, subscriptionRegistry, { view: viewDef.view });
+            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view });
         },
         async get() {
-            return store.getAll(viewDef.view);
+            return storage.getAll(viewDef.view);
         },
         getSync() {
-            return store.getAllSync(viewDef.view);
+            return storage.getAllSync(viewDef.view);
         },
     };
 }
-function createTypedViews(stack, store, subscriptionRegistry) {
+function createTypedViews(stack, storage, subscriptionRegistry) {
     const views = {};
     for (const [viewName, viewGroup] of Object.entries(stack.views)) {
         const group = viewGroup;
         const typedGroup = {};
         if (group.state) {
-            typedGroup.state = createTypedStateView(group.state, store, subscriptionRegistry);
+            typedGroup.state = createTypedStateView(group.state, storage, subscriptionRegistry);
         }
         if (group.list) {
-            typedGroup.list = createTypedListView(group.list, store, subscriptionRegistry);
+            typedGroup.list = createTypedListView(group.list, storage, subscriptionRegistry);
         }
         views[viewName] = typedGroup;
     }
@@ -751,7 +772,10 @@ function createTypedViews(stack, store, subscriptionRegistry) {
 class HyperStack {
     constructor(url, options) {
         this.stack = options.stack;
-        this.store = new EntityStore();
+        this.storage = options.storage ?? new MemoryAdapter();
+        this.processor = new FrameProcessor(this.storage, {
+            maxEntriesPerView: options.maxEntriesPerView,
+        });
         this.connection = new ConnectionManager({
             websocketUrl: url,
             reconnectIntervals: options.reconnectIntervals,
@@ -759,9 +783,9 @@ class HyperStack {
         });
         this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
         this.connection.onFrame((frame) => {
-            this.store.handleFrame(frame);
+            this.processor.handleFrame(frame);
         });
-        this._views = createTypedViews(this.stack, this.store, this.subscriptionRegistry);
+        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
     }
     static async connect(url, options) {
         if (!url) {
@@ -785,6 +809,9 @@ class HyperStack {
     get stackName() {
         return this.stack.name;
     }
+    get store() {
+        return this.storage;
+    }
     onConnectionStateChange(callback) {
         return this.connection.onStateChange(callback);
     }
@@ -802,10 +829,10 @@ class HyperStack {
         return this.connection.isConnected();
     }
     clearStore() {
-        this.store.clear();
+        this.storage.clear();
     }
     getStore() {
-        return this.store;
+        return this.storage;
     }
     getConnection() {
         return this.connection;
@@ -817,9 +844,11 @@ class HyperStack {
 
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
-exports.EntityStore = EntityStore;
+exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
+exports.FrameProcessor = FrameProcessor;
 exports.HyperStack = HyperStack;
 exports.HyperStackError = HyperStackError;
+exports.MemoryAdapter = MemoryAdapter;
 exports.SubscriptionRegistry = SubscriptionRegistry;
 exports.createRichUpdateStream = createRichUpdateStream;
 exports.createTypedListView = createTypedListView;