@laboverwire/stitch 0.4.1 → 0.5.0

package/dist/sync-engine.js

@@ -1,643 +0,0 @@
-import { OwnershipError } from "./types.js";
-const FAST_RECONNECT_LIMIT = 5;
-const SLOW_RECONNECT_INTERVAL = 15_000;
-function applyTicketAuth(connectOpts, ticket) {
-    if (!ticket)
-        return;
-    connectOpts.authenticationMethod = 'JWT';
-    connectOpts.authenticationData = new TextEncoder().encode(ticket);
-}
-class SyncEngineImpl {
-    client = null;
-    clientId;
-    config;
-    prefix;
-    responsePrefix;
-    SubscribeOptions = null;
-    PublishOptions = null;
-    ConnectOptions = null;
-    desiredScopes = new Set();
-    subscribedScopes = new Set();
-    appliedVersion = new Map();
-    buffered = new Map();
-    awaitingState = new Set();
-    pendingRequests = new Map();
-    topLevelSubscribed = false;
-    onMutation = null;
-    onConnectionStatus = null;
-    onSessionInvalid = null;
-    getTicket = null;
-    active = false;
-    reconnectTimer = null;
-    reconnectAttempt = 0;
-    reconnecting = false;
-    slowReconnecting = false;
-    serverUrl = null;
-    constructor(clientId, config) {
-        if (/[+#/]/.test(clientId)) {
-            throw new Error('clientId must not contain MQTT special characters (+, #, /)');
-        }
-        this.clientId = clientId;
-        this.config = config;
-        this.prefix = config.syncTopicPrefix ?? '$DB';
-        this.responsePrefix = config.responseTopicPrefix ?? '$SYS/responses';
-    }
-    async connect(serverUrl, wasmModule, getTicket) {
-        this.onConnectionStatus?.('connecting');
-        this.active = true;
-        this.serverUrl = serverUrl;
-        if (getTicket) {
-            this.getTicket = getTicket;
-        }
-        if (!this.client) {
-            const mod = wasmModule;
-            const { default: initMqttWasm, MqttClient, ConnectOptions, SubscribeOptions, PublishOptions, } = mod;
-            await initMqttWasm();
-            this.client = new MqttClient(this.clientId);
-            this.SubscribeOptions = SubscribeOptions;
-            this.PublishOptions = PublishOptions;
-            this.ConnectOptions = ConnectOptions;
-            this.client.onConnect(() => {
-                if (!this.active)
-                    return;
-                this.clearReconnectTimer();
-                this.reconnectAttempt = 0;
-                this.slowReconnecting = false;
-                this.topLevelSubscribed = false;
-                Promise.all([this.subscribeToResponseTopic(), this.subscribeToTopLevel()])
-                    .then(() => {
-                    if (this.active)
-                        this.onConnectionStatus?.('connected');
-                    for (const scopeId of this.desiredScopes) {
-                        this.subscribeToScope(scopeId)
-                            .then(() => this.subscribedScopes.add(scopeId))
-                            .catch((err) => console.error(`[SyncEngine] Re-subscribe ${scopeId} failed:`, err));
-                    }
-                })
-                    .catch((err) => {
-                    console.error('[SyncEngine] Post-connect subscribe failed:', err);
-                    this.onConnectionStatus?.('error');
-                    this.scheduleReconnect();
-                });
-            });
-            this.client.onDisconnect(() => {
-                if (!this.active)
-                    return;
-                if (this.reconnecting)
-                    return;
-                this.onConnectionStatus?.('disconnected');
-                this.cleanupOnDisconnect();
-                if (this.client?.isBrowserOnline()) {
-                    this.scheduleReconnect();
-                }
-            });
-            this.client.onError((error) => {
-                if (!this.active)
-                    return;
-                if (/closed by peer|connection reset/i.test(error))
-                    return;
-                if (/not.?authorized|bad.?user|bad.?password|authentication|0x8[567]/i.test(error)) {
-                    this.cancelReconnect();
-                    this.onSessionInvalid?.();
-                    return;
-                }
-                console.error('[SyncEngine] MQTT error:', error);
-                this.onConnectionStatus?.('error');
-            });
-            this.client.onConnectivityChange((online) => {
-                if (!this.active)
-                    return;
-                if (!online) {
-                    this.cancelReconnect();
-                    this.onConnectionStatus?.('offline');
-                    this.cleanupOnDisconnect();
-                }
-                else {
-                    this.scheduleReconnect(0);
-                }
-            });
-        }
-        try {
-            const connectOpts = new this.ConnectOptions();
-            connectOpts.cleanStart = true;
-            connectOpts.keepAlive = 60;
-            if (this.getTicket) {
-                applyTicketAuth(connectOpts, await this.getTicket());
-            }
-            await this.client.connectWithOptions(serverUrl, connectOpts);
-        }
-        catch (err) {
-            this.onConnectionStatus?.('disconnected');
-            if (this.client?.isBrowserOnline()) {
-                this.scheduleReconnect();
-            }
-            throw err;
-        }
-    }
-    async reconnect(serverUrl, getTicket) {
-        if (!this.client || !this.ConnectOptions) {
-            throw new Error('Cannot reconnect before initial connect');
-        }
-        this.clearReconnectTimer();
-        this.reconnecting = true;
-        this.active = true;
-        this.serverUrl = serverUrl;
-        if (!this.slowReconnecting) {
-            this.onConnectionStatus?.('connecting');
-        }
-        if (getTicket) {
-            this.getTicket = getTicket;
-        }
-        try {
-            this.client.disconnect();
-        }
-        catch {
-            // WASM client may throw if already disconnected
-        }
-        let failed = false;
-        try {
-            const connectOpts = new this.ConnectOptions();
-            connectOpts.cleanStart = true;
-            connectOpts.keepAlive = 60;
-            if (this.getTicket) {
-                const ticket = await Promise.race([
-                    this.getTicket(),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('getTicket timeout')), 10_000)),
-                ]);
-                applyTicketAuth(connectOpts, ticket);
-            }
-            await this.client.connectWithOptions(serverUrl, connectOpts);
-        }
-        catch (err) {
-            if (err instanceof Error && err.name === 'SessionExpiredError') {
-                this.cancelReconnect();
-                this.onSessionInvalid?.();
-                return;
-            }
-            failed = true;
-            throw err;
-        }
-        finally {
-            this.reconnecting = false;
-            if (failed && this.active && this.client?.isBrowserOnline()) {
-                this.scheduleReconnect();
-            }
-        }
-    }
-    cleanupOnDisconnect() {
-        this.subscribedScopes.clear();
-        this.appliedVersion.clear();
-        this.buffered.clear();
-        this.awaitingState.clear();
-        this.topLevelSubscribed = false;
-        for (const [, { reject }] of this.pendingRequests) {
-            reject(new Error('Disconnected'));
-        }
-        this.pendingRequests.clear();
-    }
-    scheduleReconnect(delayOverride) {
-        if (this.reconnectTimer || this.reconnecting || !this.active || !this.serverUrl)
-            return;
-        if (!this.slowReconnecting && this.reconnectAttempt >= FAST_RECONNECT_LIMIT) {
-            this.slowReconnecting = true;
-            this.onConnectionStatus?.('disconnected');
-        }
-        const baseDelay = this.slowReconnecting
-            ? SLOW_RECONNECT_INTERVAL
-            : (delayOverride ?? Math.min(1000 * 2 ** this.reconnectAttempt, 30000));
-        const jitter = Math.random() * (baseDelay / 4);
-        const delay = Math.round(baseDelay + jitter);
-        this.reconnectTimer = setTimeout(async () => {
-            this.reconnectTimer = null;
-            if (!this.active || !this.serverUrl)
-                return;
-            this.reconnectAttempt++;
-            try {
-                await this.reconnect(this.serverUrl, this.getTicket ?? undefined);
-            }
-            catch {
-                if (this.active && this.client?.isBrowserOnline()) {
-                    this.scheduleReconnect();
-                }
-            }
-        }, delay);
-    }
-    clearReconnectTimer() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-    }
-    cancelReconnect() {
-        this.clearReconnectTimer();
-        this.reconnectAttempt = 0;
-        this.slowReconnecting = false;
-    }
-    disconnect() {
-        this.active = false;
-        this.reconnecting = false;
-        this.cancelReconnect();
-        this.cleanupOnDisconnect();
-        try {
-            this.client?.disconnect();
-        }
-        catch {
-            // mqtt5-wasm may throw on disconnect
-        }
-    }
-    setMutationHandler(handler) {
-        this.onMutation = handler;
-    }
-    setConnectionStatusHandler(handler) {
-        this.onConnectionStatus = handler;
-    }
-    setSessionInvalidHandler(handler) {
-        this.onSessionInvalid = handler;
-    }
-    async subscribeToResponseTopic() {
-        if (!this.client || !this.SubscribeOptions)
-            return;
-        const responseTopic = `${this.responsePrefix}/${this.clientId}/#`;
-        const subOpts = new this.SubscribeOptions();
-        subOpts.qos = 1;
-        await this.client.subscribeWithOptions(responseTopic, (topic, payload) => {
-            this.handleResponseMessage(topic, payload);
-        }, subOpts);
-    }
-    async subscribeToTopLevel() {
-        if (!this.client || !this.SubscribeOptions || this.topLevelSubscribed)
-            return;
-        const { rootEntity } = this.config.scope;
-        const subOpts = new this.SubscribeOptions();
-        subOpts.qos = 1;
-        await this.client.subscribeWithOptions(`${this.prefix}/${rootEntity}/+/events/#`, (topic, payload, properties) => {
-            this.handleRootEntityEvent(topic, payload, properties);
-        }, subOpts);
-        if (this.config.topLevelEntities) {
-            for (const topLevel of this.config.topLevelEntities) {
-                const tSubOpts = new this.SubscribeOptions();
-                tSubOpts.qos = 1;
-                await this.client.subscribeWithOptions(topLevel.subscriptionPattern, (topic, payload, properties) => {
-                    this.handleTopLevelEntityEvent(topLevel.entity, topic, payload, properties);
-                }, tSubOpts);
-            }
-        }
-        this.topLevelSubscribed = true;
-    }
-    handleRootEntityEvent(topic, payload, properties) {
-        const parsed = this.parseScopedTopic(topic);
-        if (!parsed || parsed.entity !== this.config.scope.rootEntity)
-            return;
-        if (this.subscribedScopes.has(parsed.scopeId))
-            return;
-        let event;
-        try {
-            const parsedPayload = JSON.parse(new TextDecoder().decode(payload));
-            if (!SyncEngineImpl.isValidChangeEvent(parsedPayload))
-                return;
-            event = parsedPayload;
-        }
-        catch {
-            return;
-        }
-        if (this.isOwnMutation(properties, event.sender))
-            return;
-        const opMap = {
-            created: 'Create',
-            updated: 'Update',
-            deleted: 'Delete',
-        };
-        event.operation = opMap[parsed.eventType] ?? event.operation;
-        const mutation = SyncEngineImpl.mapChangeEvent(this.config.scope.rootEntity, event);
-        this.applyMutation('__global__', mutation);
-    }
-    handleTopLevelEntityEvent(entityName, topic, payload, properties) {
-        const match = topic.match(new RegExp(`^\\${this.prefix}/${entityName}/events/(.+)$`));
-        if (!match)
-            return;
-        let event;
-        try {
-            const parsedPayload = JSON.parse(new TextDecoder().decode(payload));
-            if (!SyncEngineImpl.isValidChangeEvent(parsedPayload))
-                return;
-            event = parsedPayload;
-        }
-        catch {
-            return;
-        }
-        if (this.isOwnMutation(properties, event.sender))
-            return;
-        const mutation = SyncEngineImpl.mapChangeEvent(entityName, event);
-        this.applyMutation('__global__', mutation);
-    }
-    handleResponseMessage(topic, payload) {
-        const match = topic.match(new RegExp(`^\\${this.responsePrefix}/[^/]+/(.+)$`));
-        if (!match)
-            return;
-        const requestId = match[1];
-        const pending = this.pendingRequests.get(requestId);
-        if (pending) {
-            this.pendingRequests.delete(requestId);
-            try {
-                const response = JSON.parse(new TextDecoder().decode(payload));
-                pending.resolve(response);
-            }
-            catch {
-                pending.reject(new Error('Invalid response format'));
-            }
-        }
-    }
-    async subscribeToScope(scopeId) {
-        if (!this.client || !this.SubscribeOptions)
-            return;
-        const { rootEntity } = this.config.scope;
-        const subOpts = new this.SubscribeOptions();
-        subOpts.qos = 1;
-        await this.client.subscribeWithOptions(`${this.prefix}/${rootEntity}/${scopeId}/#`, (topic, payload, properties) => {
-            this.handleWatchMessage(topic, payload, properties);
-        }, subOpts);
-    }
-    async unsubscribeFromScope(scopeId) {
-        if (!this.client)
-            return;
-        const { rootEntity } = this.config.scope;
-        await this.client.unsubscribe(`${this.prefix}/${rootEntity}/${scopeId}/#`);
-    }
-    static isValidChangeEvent(value) {
-        if (typeof value !== 'object' || value === null)
-            return false;
-        const e = value;
-        return (typeof e.id === 'string' &&
-            e.id.length > 0 &&
-            typeof e.operation === 'string' &&
-            ['Create', 'Update', 'Delete'].includes(e.operation) &&
-            (e.data === undefined || e.data === null || typeof e.data === 'object'));
-    }
-    static mapChangeEvent(entity, event) {
-        const opMap = {
-            Create: 'insert',
-            Update: 'update',
-            Delete: 'delete',
-        };
-        return {
-            op: opMap[event.operation] ?? 'update',
-            entity,
-            id: event.id,
-            data: event.data ?? null,
-            operationId: event.operation_id ?? null,
-        };
-    }
-    parseScopedTopic(topic) {
-        const { rootEntity } = this.config.scope;
-        const rootOwn = topic.match(new RegExp(`^\\${this.prefix}/${rootEntity}/([^/]+)/events/(created|updated|deleted)$`));
-        if (rootOwn) {
-            return { scopeId: rootOwn[1], entity: rootEntity, eventType: rootOwn[2] };
-        }
-        const childEntity = topic.match(new RegExp(`^\\${this.prefix}/${rootEntity}/([^/]+)/(\\w+)/events/(created|updated|deleted)$`));
-        if (childEntity) {
-            return { scopeId: childEntity[1], entity: childEntity[2], eventType: childEntity[3] };
-        }
-        return null;
-    }
-    static extractOriginClientId(properties) {
-        if (!properties)
-            return null;
-        const userProps = properties.getUserProperties();
-        for (let i = 0; i < userProps.length; i++) {
-            const [key, value] = userProps[i];
-            if (key === 'x-origin-client-id')
-                return value;
-        }
-        return null;
-    }
-    isOwnMutation(properties, eventSender) {
-        if (eventSender === this.clientId)
-            return true;
-        const origin = SyncEngineImpl.extractOriginClientId(properties);
-        return origin === this.clientId;
-    }
-    handleWatchMessage(topic, payload, properties) {
-        const parsed = this.parseScopedTopic(topic);
-        if (!parsed)
-            return;
-        const { scopeId, entity, eventType } = parsed;
-        let event;
-        try {
-            const parsedPayload = JSON.parse(new TextDecoder().decode(payload));
-            if (!SyncEngineImpl.isValidChangeEvent(parsedPayload))
-                return;
-            event = parsedPayload;
-        }
-        catch {
-            return;
-        }
-        const opMap = {
-            created: 'Create',
-            updated: 'Update',
-            deleted: 'Delete',
-        };
-        event.operation = opMap[eventType] ?? event.operation;
-        if (this.isOwnMutation(properties, event.sender))
-            return;
-        const mutation = SyncEngineImpl.mapChangeEvent(entity, event);
-        if (this.awaitingState.has(scopeId)) {
-            this.buffered.get(scopeId)?.push(mutation);
-            return;
-        }
-        this.applyMutation(scopeId, mutation);
-    }
-    applyMutation(scopeId, mutation) {
-        this.onMutation?.(scopeId, mutation);
-    }
-    async openScope(scopeId) {
-        if (!this.client)
-            throw new Error('Not connected');
-        const { rootEntity, childEntities, scopeField } = this.config.scope;
-        this.desiredScopes.add(scopeId);
-        this.awaitingState.add(scopeId);
-        this.buffered.set(scopeId, []);
-        this.subscribedScopes.add(scopeId);
-        try {
-            await this.subscribeToScope(scopeId);
-            const fetchPromises = childEntities.map((entity) => this.fetchList(entity, scopeId));
-            const [rootRecord, ...childResults] = await Promise.all([
-                this.fetchOne(rootEntity, scopeId),
-                ...fetchPromises,
-            ]);
-            const root = rootRecord ?? {};
-            const children = {};
-            for (let i = 0; i < childEntities.length; i++) {
-                children[childEntities[i]] = childResults[i] ?? [];
-            }
-            const versionField = this.config.versionField ?? 'version';
-            const version = root[versionField] || 0;
-            this.appliedVersion.set(scopeId, version);
-            const buffer = this.buffered.get(scopeId) || [];
-            const bufferedMutations = [];
-            for (const mutation of buffer) {
-                const belongsToScope = mutation.entity === rootEntity
-                    ? mutation.id === scopeId
-                    : mutation.data?.[scopeField] === scopeId;
-                if (belongsToScope) {
-                    bufferedMutations.push(mutation);
-                }
-            }
-            this.buffered.delete(scopeId);
-            this.awaitingState.delete(scopeId);
-            return { root, children, version, bufferedMutations };
-        }
-        catch (err) {
-            this.buffered.delete(scopeId);
-            this.awaitingState.delete(scopeId);
-            this.subscribedScopes.delete(scopeId);
-            throw err;
-        }
-    }
-    async closeScope(scopeId) {
-        this.desiredScopes.delete(scopeId);
-        this.subscribedScopes.delete(scopeId);
-        this.buffered.delete(scopeId);
-        this.awaitingState.delete(scopeId);
-        this.appliedVersion.delete(scopeId);
-        await this.unsubscribeFromScope(scopeId);
-    }
-    checkResponseAndAuth(response) {
-        if (response.status === 'error') {
-            const msg = response.message || 'Operation failed';
-            if (response.code === 401) {
-                this.onSessionInvalid?.();
-                throw new Error(msg);
-            }
-            if (response.code === 403) {
-                throw new OwnershipError(msg);
-            }
-            throw new Error(msg);
-        }
-    }
-    extractResponseId(response) {
-        const data = response.data;
-        if (typeof data !== 'object' || data === null) {
-            throw new Error('Response missing data payload');
-        }
-        const id = data.id;
-        if (typeof id !== 'string' || id.length === 0) {
-            throw new Error('Response missing valid id');
-        }
-        return id;
-    }
-    async createEntity(entity, scopeId, data) {
-        const { scopeField, childEntities } = this.config.scope;
-        const isChild = childEntities.includes(entity);
-        const payload = isChild && scopeId ? { ...data, [scopeField]: scopeId } : data;
-        const response = await this.request(`${this.prefix}/${entity}/create`, payload);
-        this.checkResponseAndAuth(response);
-        const id = this.extractResponseId(response);
-        if (isChild && scopeId) {
-            await this.bumpScopeVersion(scopeId);
-        }
-        return id;
-    }
-    async updateEntity(entity, scopeId, id, data) {
-        const response = await this.request(`${this.prefix}/${entity}/${id}/update`, data);
-        this.checkResponseAndAuth(response);
-        const { childEntities } = this.config.scope;
-        if (childEntities.includes(entity) && scopeId) {
-            await this.bumpScopeVersion(scopeId);
-        }
-    }
-    async deleteEntity(entity, scopeId, id) {
-        const response = await this.request(`${this.prefix}/${entity}/${id}/delete`, {});
-        this.checkResponseAndAuth(response);
-        const { childEntities } = this.config.scope;
-        if (childEntities.includes(entity) && scopeId) {
-            await this.bumpScopeVersion(scopeId);
-        }
-    }
-    async bumpScopeVersion(scopeId) {
-        const { rootEntity } = this.config.scope;
-        const versionField = this.config.versionField ?? 'version';
-        const updatedAtField = this.config.updatedAtField ?? 'updatedAt';
-        const now = Date.now();
-        const response = await this.request(`${this.prefix}/${rootEntity}/${scopeId}/update`, {
-            [versionField]: now,
-            [updatedAtField]: now,
-        });
-        this.checkResponseAndAuth(response);
-        this.appliedVersion.set(scopeId, now);
-    }
-    async fetchOne(entity, id) {
-        try {
-            const response = await this.request(`${this.prefix}/${entity}/${id}`, {});
-            this.checkResponseAndAuth(response);
-            return response.data;
-        }
-        catch {
-            return null;
-        }
-    }
-    async fetchList(entity, scopeId, sort) {
-        try {
-            const payload = {};
-            if (scopeId) {
-                const { scopeField } = this.config.scope;
-                payload.filters = [{ field: scopeField, op: 'eq', value: scopeId }];
-            }
-            if (sort && sort.length > 0) {
-                payload.sort = sort;
-            }
-            const response = await this.request(`${this.prefix}/${entity}/list`, payload);
-            this.checkResponseAndAuth(response);
-            return response.data || [];
-        }
-        catch {
-            return null;
-        }
-    }
-    async request(topic, payload) {
-        if (!this.client || !this.PublishOptions)
-            throw new Error('Not connected');
-        const requestId = crypto.randomUUID();
-        const responseTopic = `${this.responsePrefix}/${this.clientId}/${requestId}`;
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pendingRequests.delete(requestId);
-                reject(new Error('Request timeout'));
-            }, 10000);
-            this.pendingRequests.set(requestId, {
-                resolve: (value) => {
-                    clearTimeout(timeout);
-                    resolve(value);
-                },
-                reject: (error) => {
-                    clearTimeout(timeout);
-                    reject(error);
-                },
-            });
-            const encoder = new TextEncoder();
-            const pubOpts = new this.PublishOptions();
-            pubOpts.qos = 1;
-            pubOpts.retain = false;
-            pubOpts.responseTopic = responseTopic;
-            pubOpts.correlationData = encoder.encode(requestId);
-            const body = JSON.stringify(payload);
-            this.client.publishWithOptions(topic, encoder.encode(body), pubOpts).catch((err) => {
-                this.pendingRequests.delete(requestId);
-                clearTimeout(timeout);
-                reject(err);
-            });
-        });
-    }
-    get isReconnecting() {
-        return this.reconnecting || this.reconnectTimer !== null;
-    }
-    isSubscribedTo(scopeId) {
-        return this.subscribedScopes.has(scopeId);
-    }
-    getAppliedVersion(scopeId) {
-        return this.appliedVersion.get(scopeId) || 0;
-    }
-}
-export function createSyncEngine(clientId, config) {
-    return new SyncEngineImpl(clientId, config);
-}
-//# sourceMappingURL=sync-engine.js.map