hyperstack-typescript 0.2.0

package/dist/index.esm.js

@@ -0,0 +1,691 @@
+const DEFAULT_CONFIG = {
+    reconnectIntervals: [1000, 2000, 4000, 8000, 16000],
+    maxReconnectAttempts: 5,
+};
+class HyperStackError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'HyperStackError';
+    }
+}
+
+function parseFrame(data) {
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    const decoder = new TextDecoder('utf-8');
+    const jsonString = decoder.decode(data);
+    return JSON.parse(jsonString);
+}
+async function parseFrameFromBlob(blob) {
+    const arrayBuffer = await blob.arrayBuffer();
+    return parseFrame(arrayBuffer);
+}
+function isValidFrame(frame) {
+    if (typeof frame !== 'object' || frame === null) {
+        return false;
+    }
+    const f = frame;
+    return (typeof f['entity'] === 'string' &&
+        typeof f['key'] === 'string' &&
+        typeof f['op'] === 'string' &&
+        ['create', 'upsert', 'patch', 'delete'].includes(f['op']) &&
+        typeof f['mode'] === 'string' &&
+        ['state', 'append', 'list'].includes(f['mode']));
+}
+
+class ConnectionManager {
+    constructor(config) {
+        this.ws = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.pingInterval = null;
+        this.currentState = 'disconnected';
+        this.subscriptionQueue = [];
+        this.activeSubscriptions = new Set();
+        this.frameHandlers = new Set();
+        this.stateHandlers = new Set();
+        if (!config.websocketUrl) {
+            throw new HyperStackError('websocketUrl is required', 'INVALID_CONFIG');
+        }
+        this.websocketUrl = config.websocketUrl;
+        this.reconnectIntervals = config.reconnectIntervals ?? DEFAULT_CONFIG.reconnectIntervals;
+        this.maxReconnectAttempts = config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts;
+        if (config.initialSubscriptions) {
+            this.subscriptionQueue.push(...config.initialSubscriptions);
+        }
+    }
+    getState() {
+        return this.currentState;
+    }
+    onFrame(handler) {
+        this.frameHandlers.add(handler);
+        return () => {
+            this.frameHandlers.delete(handler);
+        };
+    }
+    onStateChange(handler) {
+        this.stateHandlers.add(handler);
+        return () => {
+            this.stateHandlers.delete(handler);
+        };
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.ws?.readyState === WebSocket.OPEN ||
+                this.ws?.readyState === WebSocket.CONNECTING ||
+                this.currentState === 'connecting') {
+                resolve();
+                return;
+            }
+            this.updateState('connecting');
+            try {
+                this.ws = new WebSocket(this.websocketUrl);
+                this.ws.onopen = () => {
+                    this.reconnectAttempts = 0;
+                    this.updateState('connected');
+                    this.startPingInterval();
+                    this.flushSubscriptionQueue();
+                    this.resubscribeActive();
+                    resolve();
+                };
+                this.ws.onmessage = async (event) => {
+                    try {
+                        let frame;
+                        if (event.data instanceof ArrayBuffer) {
+                            frame = parseFrame(event.data);
+                        }
+                        else if (event.data instanceof Blob) {
+                            frame = await parseFrameFromBlob(event.data);
+                        }
+                        else if (typeof event.data === 'string') {
+                            frame = parseFrame(event.data);
+                        }
+                        else {
+                            throw new HyperStackError(`Unsupported message type: ${typeof event.data}`, 'PARSE_ERROR');
+                        }
+                        this.notifyFrameHandlers(frame);
+                    }
+                    catch (error) {
+                        this.updateState('error', 'Failed to parse frame from server');
+                    }
+                };
+                this.ws.onerror = () => {
+                    const error = new HyperStackError('WebSocket connection error', 'CONNECTION_ERROR');
+                    this.updateState('error', error.message);
+                    if (this.currentState === 'connecting') {
+                        reject(error);
+                    }
+                };
+                this.ws.onclose = () => {
+                    this.stopPingInterval();
+                    this.ws = null;
+                    if (this.currentState !== 'disconnected') {
+                        this.handleReconnect();
+                    }
+                };
+            }
+            catch (error) {
+                const hsError = new HyperStackError('Failed to create WebSocket connection', 'CONNECTION_ERROR', error);
+                this.updateState('error', hsError.message);
+                reject(hsError);
+            }
+        });
+    }
+    disconnect() {
+        this.clearReconnectTimeout();
+        this.stopPingInterval();
+        this.updateState('disconnected');
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    subscribe(subscription) {
+        const subKey = this.makeSubKey(subscription);
+        if (this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(subscription));
+            this.activeSubscriptions.add(subKey);
+        }
+        else {
+            this.subscriptionQueue.push(subscription);
+        }
+    }
+    unsubscribe(view, key) {
+        const subscription = { view, key };
+        const subKey = this.makeSubKey(subscription);
+        this.activeSubscriptions.delete(subKey);
+    }
+    isConnected() {
+        return this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN;
+    }
+    makeSubKey(subscription) {
+        return `${subscription.view}:${subscription.key ?? '*'}:${subscription.partition ?? ''}`;
+    }
+    flushSubscriptionQueue() {
+        while (this.subscriptionQueue.length > 0) {
+            const sub = this.subscriptionQueue.shift();
+            if (sub) {
+                this.subscribe(sub);
+            }
+        }
+    }
+    resubscribeActive() {
+        for (const subKey of this.activeSubscriptions) {
+            const [view, key, partition] = subKey.split(':');
+            const subscription = {
+                view: view ?? '',
+                key: key === '*' ? undefined : key,
+                partition: partition || undefined,
+            };
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify(subscription));
+            }
+        }
+    }
+    updateState(state, error) {
+        this.currentState = state;
+        for (const handler of this.stateHandlers) {
+            handler(state, error);
+        }
+    }
+    notifyFrameHandlers(frame) {
+        for (const handler of this.frameHandlers) {
+            handler(frame);
+        }
+    }
+    handleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.updateState('error', `Max reconnection attempts (${this.reconnectAttempts}) reached`);
+            return;
+        }
+        this.updateState('reconnecting');
+        const attemptIndex = Math.min(this.reconnectAttempts, this.reconnectIntervals.length - 1);
+        const delay = this.reconnectIntervals[attemptIndex] ?? 1000;
+        this.reconnectAttempts++;
+        this.reconnectTimeout = setTimeout(() => {
+            this.connect().catch(() => {
+                /* retry handled by onclose */
+            });
+        }, delay);
+    }
+    clearReconnectTimeout() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    startPingInterval() {
+        this.stopPingInterval();
+        this.pingInterval = setInterval(() => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'ping' }));
+            }
+        }, 15000);
+    }
+    stopPingInterval() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+}
+
+function isObject(item) {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+    if (!isObject(target) || !isObject(source)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (isObject(sourceValue) && isObject(targetValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+class EntityStore {
+    constructor() {
+        this.entities = new Map();
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
+    }
+    handleFrame(frame) {
+        const viewPath = frame.entity;
+        let viewMap = this.entities.get(viewPath);
+        if (!viewMap) {
+            viewMap = new Map();
+            this.entities.set(viewPath, viewMap);
+        }
+        const previousValue = viewMap.get(frame.key);
+        switch (frame.op) {
+            case 'create':
+            case 'upsert':
+                viewMap.set(frame.key, frame.data);
+                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 = viewMap.get(frame.key);
+                const merged = existing ? deepMerge(existing, frame.data) : frame.data;
+                viewMap.set(frame.key, merged);
+                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':
+                viewMap.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 viewMap = this.entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.values());
+    }
+    get(viewPath, key) {
+        const viewMap = this.entities.get(viewPath);
+        if (!viewMap)
+            return null;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
+    }
+    getAllSync(viewPath) {
+        const viewMap = this.entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        return Array.from(viewMap.values());
+    }
+    getSync(viewPath, key) {
+        const viewMap = this.entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
+    }
+    keys(viewPath) {
+        const viewMap = this.entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.keys());
+    }
+    size(viewPath) {
+        const viewMap = this.entities.get(viewPath);
+        return viewMap?.size ?? 0;
+    }
+    clear() {
+        this.entities.clear();
+    }
+    clearView(viewPath) {
+        this.entities.delete(viewPath);
+    }
+    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);
+        }
+    }
+}
+
+class SubscriptionRegistry {
+    constructor(connection) {
+        this.subscriptions = new Map();
+        this.connection = connection;
+    }
+    subscribe(subscription) {
+        const subKey = this.makeSubKey(subscription);
+        const existing = this.subscriptions.get(subKey);
+        if (existing) {
+            existing.refCount++;
+        }
+        else {
+            this.subscriptions.set(subKey, {
+                subscription,
+                refCount: 1,
+            });
+            this.connection.subscribe(subscription);
+        }
+        return () => this.unsubscribe(subscription);
+    }
+    unsubscribe(subscription) {
+        const subKey = this.makeSubKey(subscription);
+        const existing = this.subscriptions.get(subKey);
+        if (existing) {
+            existing.refCount--;
+            if (existing.refCount <= 0) {
+                this.subscriptions.delete(subKey);
+                this.connection.unsubscribe(subscription.view, subscription.key);
+            }
+        }
+    }
+    getRefCount(subscription) {
+        const subKey = this.makeSubKey(subscription);
+        return this.subscriptions.get(subKey)?.refCount ?? 0;
+    }
+    getActiveSubscriptions() {
+        return Array.from(this.subscriptions.values()).map((t) => t.subscription);
+    }
+    clear() {
+        for (const { subscription } of this.subscriptions.values()) {
+            this.connection.unsubscribe(subscription.view, subscription.key);
+        }
+        this.subscriptions.clear();
+    }
+    makeSubKey(subscription) {
+        const filters = subscription.filters ? JSON.stringify(subscription.filters) : '{}';
+        return `${subscription.view}:${subscription.key ?? '*'}:${subscription.partition ?? ''}:${filters}`;
+    }
+}
+
+function createUpdateStream(store, subscriptionRegistry, subscription, keyFilter) {
+    return {
+        [Symbol.asyncIterator]() {
+            const queue = [];
+            let waitingResolve = null;
+            let unsubscribeStore = null;
+            let unsubscribeRegistry = null;
+            let done = false;
+            const handler = (viewPath, key, update) => {
+                if (viewPath !== subscription.view)
+                    return;
+                if (keyFilter !== undefined && key !== keyFilter)
+                    return;
+                const typedUpdate = update;
+                if (waitingResolve) {
+                    const resolve = waitingResolve;
+                    waitingResolve = null;
+                    resolve({ value: typedUpdate, done: false });
+                }
+                else {
+                    queue.push({
+                        update: typedUpdate,
+                        resolve: () => { },
+                    });
+                }
+            };
+            const start = () => {
+                unsubscribeStore = store.onUpdate(handler);
+                unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
+            };
+            const cleanup = () => {
+                done = true;
+                unsubscribeStore?.();
+                unsubscribeRegistry?.();
+            };
+            start();
+            return {
+                async next() {
+                    if (done) {
+                        return { value: undefined, done: true };
+                    }
+                    const queued = queue.shift();
+                    if (queued) {
+                        return { value: queued.update, done: false };
+                    }
+                    return new Promise((resolve) => {
+                        waitingResolve = resolve;
+                    });
+                },
+                async return() {
+                    cleanup();
+                    return { value: undefined, done: true };
+                },
+                async throw(error) {
+                    cleanup();
+                    throw error;
+                },
+            };
+        },
+    };
+}
+function createRichUpdateStream(store, subscriptionRegistry, subscription, keyFilter) {
+    return {
+        [Symbol.asyncIterator]() {
+            const queue = [];
+            let waitingResolve = null;
+            let unsubscribeStore = null;
+            let unsubscribeRegistry = null;
+            let done = false;
+            const handler = (viewPath, key, update) => {
+                if (viewPath !== subscription.view)
+                    return;
+                if (keyFilter !== undefined && key !== keyFilter)
+                    return;
+                const typedUpdate = update;
+                if (waitingResolve) {
+                    const resolve = waitingResolve;
+                    waitingResolve = null;
+                    resolve({ value: typedUpdate, done: false });
+                }
+                else {
+                    queue.push({
+                        update: typedUpdate,
+                        resolve: () => { },
+                    });
+                }
+            };
+            const start = () => {
+                unsubscribeStore = store.onRichUpdate(handler);
+                unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
+            };
+            const cleanup = () => {
+                done = true;
+                unsubscribeStore?.();
+                unsubscribeRegistry?.();
+            };
+            start();
+            return {
+                async next() {
+                    if (done) {
+                        return { value: undefined, done: true };
+                    }
+                    const queued = queue.shift();
+                    if (queued) {
+                        return { value: queued.update, done: false };
+                    }
+                    return new Promise((resolve) => {
+                        waitingResolve = resolve;
+                    });
+                },
+                async return() {
+                    cleanup();
+                    return { value: undefined, done: true };
+                },
+                async throw(error) {
+                    cleanup();
+                    throw error;
+                },
+            };
+        },
+    };
+}
+
+function createTypedStateView(viewDef, store, subscriptionRegistry) {
+    return {
+        watch(key) {
+            return createUpdateStream(store, subscriptionRegistry, { view: viewDef.view, key }, key);
+        },
+        watchRich(key) {
+            return createRichUpdateStream(store, subscriptionRegistry, { view: viewDef.view, key }, key);
+        },
+        async get(key) {
+            return store.get(viewDef.view, key);
+        },
+        getSync(key) {
+            return store.getSync(viewDef.view, key);
+        },
+    };
+}
+function createTypedListView(viewDef, store, subscriptionRegistry) {
+    return {
+        watch() {
+            return createUpdateStream(store, subscriptionRegistry, { view: viewDef.view });
+        },
+        watchRich() {
+            return createRichUpdateStream(store, subscriptionRegistry, { view: viewDef.view });
+        },
+        async get() {
+            return store.getAll(viewDef.view);
+        },
+        getSync() {
+            return store.getAllSync(viewDef.view);
+        },
+    };
+}
+function createTypedViews(stack, store, 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);
+        }
+        if (group.list) {
+            typedGroup.list = createTypedListView(group.list, store, subscriptionRegistry);
+        }
+        views[viewName] = typedGroup;
+    }
+    return views;
+}
+
+class HyperStack {
+    constructor(url, options) {
+        this.stack = options.stack;
+        this.store = new EntityStore();
+        this.connection = new ConnectionManager({
+            websocketUrl: url,
+            reconnectIntervals: options.reconnectIntervals,
+            maxReconnectAttempts: options.maxReconnectAttempts,
+        });
+        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
+        this.connection.onFrame((frame) => {
+            this.store.handleFrame(frame);
+        });
+        this._views = createTypedViews(this.stack, this.store, this.subscriptionRegistry);
+    }
+    static async connect(url, options) {
+        if (!url) {
+            throw new HyperStackError('URL is required', 'INVALID_CONFIG');
+        }
+        if (!options.stack) {
+            throw new HyperStackError('Stack definition is required', 'INVALID_CONFIG');
+        }
+        const client = new HyperStack(url, options);
+        if (options.autoReconnect !== false) {
+            await client.connection.connect();
+        }
+        return client;
+    }
+    get views() {
+        return this._views;
+    }
+    get connectionState() {
+        return this.connection.getState();
+    }
+    get stackName() {
+        return this.stack.name;
+    }
+    onConnectionStateChange(callback) {
+        return this.connection.onStateChange(callback);
+    }
+    onFrame(callback) {
+        return this.connection.onFrame(callback);
+    }
+    async connect() {
+        await this.connection.connect();
+    }
+    disconnect() {
+        this.subscriptionRegistry.clear();
+        this.connection.disconnect();
+    }
+    isConnected() {
+        return this.connection.isConnected();
+    }
+    clearStore() {
+        this.store.clear();
+    }
+    getStore() {
+        return this.store;
+    }
+    getConnection() {
+        return this.connection;
+    }
+    getSubscriptionRegistry() {
+        return this.subscriptionRegistry;
+    }
+}
+
+export { ConnectionManager, DEFAULT_CONFIG, EntityStore, HyperStack, HyperStackError, SubscriptionRegistry, createRichUpdateStream, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, isValidFrame, parseFrame, parseFrameFromBlob };
+//# sourceMappingURL=index.esm.js.map