@abloatai/ablo 0.35.0 → 0.37.0

package/dist/stores/SyncActionStore.js

@@ -1,504 +0,0 @@
-/**
- * A local, IndexedDB-backed store for the sync actions (change deltas) the
- * server sends. See {@link SyncActionStore}.
- */
-// Uses native IndexedDB for maximum performance
-import { getContext } from '../context.js';
-import { syncActionSchema } from './syncAction.js';
-/**
- * The validation boundary for rows read back from the store. A row may have
- * been written by an earlier session, so this build cannot assume its shape.
- * Parsing in strip mode also drops the storage bookkeeping fields
- * (`storedAt`, `applied`, `appliedAt`) that are not part of a
- * {@link SyncAction}. A row that fails to parse is dropped and logged rather
- * than replayed as a malformed delta.
- */
-/** Parse one stored row into a SyncAction, or `null` (dropped + logged). */
-function toSyncAction(row) {
-    const parsed = syncActionSchema.safeParse(row);
-    if (!parsed.success) {
-        getContext().logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
-            issues: parsed.error.issues.map((i) => i.path.join('.')).join(', '),
-        });
-        return null;
-    }
-    return parsed.data;
-}
-/**
- * Stores the sync actions (the change deltas) the server sends, keyed by
- * their sync id, and tracks which ones have been applied. It keeps a
- * watermark of the last applied id, holds not-yet-applied actions as
- * pending, and can rewind a range of actions back to pending so they can be
- * replayed while resolving a conflict.
- */
-export class SyncActionStore {
-    db;
-    storeName = 'sync_action_table';
-    lastAppliedSyncId = 0;
-    pendingActions = new Map();
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Initialize store (create if needed)
-     */
-    async initialize() {
-        // Store is created during database migration
-        // Load last applied sync ID from metadata
-        const metadata = await this.getMetadata();
-        if (metadata) {
-            this.lastAppliedSyncId = metadata.lastSyncId || 0;
-        }
-    }
-    /**
-     * Store a sync action
-     */
-    async storeSyncAction(action) {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            const request = store.put({
-                ...action,
-                storedAt: Date.now(),
-                applied: false,
-            });
-            tx.oncomplete = () => {
-                // Add to pending if not yet applied
-                if (action.id > this.lastAppliedSyncId) {
-                    this.pendingActions.set(action.id, action);
-                }
-                resolve();
-            };
-            tx.onerror = () => { reject(tx.error); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Store multiple sync actions
-     */
-    async storeSyncActions(actions) {
-        if (actions.length === 0)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            let completed = 0;
-            const total = actions.length;
-            for (const action of actions) {
-                const request = store.put({
-                    ...action,
-                    storedAt: Date.now(),
-                    applied: false,
-                });
-                request.onsuccess = () => {
-                    completed++;
-                    if (completed === total) {
-                        // Add to pending
-                        for (const action of actions) {
-                            if (action.id > this.lastAppliedSyncId) {
-                                this.pendingActions.set(action.id, action);
-                            }
-                        }
-                    }
-                };
-                request.onerror = () => { reject(request.error); };
-            }
-            tx.oncomplete = () => { resolve(); };
-            tx.onerror = () => { reject(tx.error); };
-        });
-    }
-    /**
-     * Get sync action by ID
-     */
-    async getSyncAction(id) {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const request = store.get(id);
-            request.onsuccess = () => {
-                const data = request.result;
-                if (!data) {
-                    resolve(undefined);
-                    return;
-                }
-                resolve(toSyncAction(data) ?? undefined);
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get sync actions in range
-     */
-    async getSyncActionsInRange(startId, endId) {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const index = store.index('syncId');
-            const range = IDBKeyRange.bound(startId, endId);
-            const request = index.getAll(range);
-            request.onsuccess = () => {
-                const allData = request.result;
-                const actions = allData
-                    .map(toSyncAction)
-                    .filter((action) => action !== null);
-                resolve(actions);
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get pending sync actions (not yet applied)
-     */
-    async getPendingSyncActions() {
-        if (this.pendingActions.size === 0) {
-            return [];
-        }
-        // Return sorted by sync ID
-        const sorted = Array.from(this.pendingActions.values()).sort((a, b) => a.id - b.id);
-        return sorted;
-    }
-    /**
-     * Mark sync action as applied
-     */
-    async markAsApplied(syncId) {
-        // Plain (non-async) executor: a sync throw (e.g. transaction() on a
-        // closing DB) must reject this promise, not vanish into an ignored one.
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            const getRequest = store.get(syncId);
-            getRequest.onsuccess = () => {
-                const existing = getRequest.result;
-                if (existing) {
-                    existing.applied = true;
-                    existing.appliedAt = Date.now();
-                    const putRequest = store.put(existing);
-                    putRequest.onerror = () => { reject(putRequest.error); };
-                }
-            };
-            getRequest.onerror = () => { reject(getRequest.error); };
-            tx.oncomplete = async () => {
-                // Update tracking
-                if (syncId > this.lastAppliedSyncId) {
-                    this.lastAppliedSyncId = syncId;
-                }
-                // Remove from pending
-                this.pendingActions.delete(syncId);
-                // Update metadata
-                try {
-                    await this.updateLastSyncId(syncId);
-                    resolve();
-                }
-                catch (error) {
-                    reject(error);
-                }
-            };
-            tx.onerror = () => { reject(tx.error); };
-        });
-    }
-    /**
-     * Mark multiple actions as applied
-     */
-    async markManyAsApplied(syncIds) {
-        if (syncIds.length === 0)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            let processed = 0;
-            const total = syncIds.length;
-            for (const syncId of syncIds) {
-                const getRequest = store.get(syncId);
-                getRequest.onsuccess = () => {
-                    const existing = getRequest.result;
-                    if (existing) {
-                        existing.applied = true;
-                        existing.appliedAt = Date.now();
-                        const putRequest = store.put(existing);
-                        putRequest.onsuccess = () => {
-                            processed++;
-                            // Remove from pending
-                            this.pendingActions.delete(syncId);
-                            if (processed === total) {
-                                // All processed, update last applied ID
-                                const maxId = Math.max(...syncIds);
-                                if (maxId > this.lastAppliedSyncId) {
-                                    this.lastAppliedSyncId = maxId;
-                                }
-                            }
-                        };
-                        putRequest.onerror = () => { reject(putRequest.error); };
-                    }
-                    else {
-                        processed++;
-                        this.pendingActions.delete(syncId);
-                    }
-                };
-                getRequest.onerror = () => { reject(getRequest.error); };
-            }
-            tx.oncomplete = async () => {
-                // Update metadata with the highest sync ID
-                const maxId = Math.max(...syncIds);
-                if (maxId > this.lastAppliedSyncId) {
-                    try {
-                        await this.updateLastSyncId(maxId);
-                        resolve();
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                }
-                else {
-                    resolve();
-                }
-            };
-            tx.onerror = () => { reject(tx.error); };
-        });
-    }
-    /**
-     * Get last applied sync ID
-     */
-    getLastAppliedSyncId() {
-        return this.lastAppliedSyncId;
-    }
-    /**
-     * Check if we have a gap in sync IDs
-     */
-    async hasGap(fromId, toId) {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const index = store.index('syncId');
-            let currentId = fromId;
-            let hasGap = false;
-            const checkNext = () => {
-                if (currentId > toId) {
-                    resolve(hasGap);
-                    return;
-                }
-                const request = index.get(currentId);
-                request.onsuccess = () => {
-                    if (!request.result) {
-                        hasGap = true;
-                        resolve(true);
-                        return;
-                    }
-                    currentId++;
-                    checkNext();
-                };
-                request.onerror = () => { reject(request.error); };
-            };
-            checkNext();
-        });
-    }
-    /**
-     * Get missing sync IDs in range
-     */
-    async getMissingSyncIds(fromId, toId) {
-        return new Promise((resolve, reject) => {
-            const missing = [];
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const index = store.index('syncId');
-            let currentId = fromId;
-            const checkNext = () => {
-                if (currentId > toId) {
-                    resolve(missing);
-                    return;
-                }
-                const request = index.get(currentId);
-                request.onsuccess = () => {
-                    if (!request.result) {
-                        missing.push(currentId);
-                    }
-                    currentId++;
-                    checkNext();
-                };
-                request.onerror = () => { reject(request.error); };
-            };
-            checkNext();
-        });
-    }
-    /**
-     * Clean up old sync actions
-     */
-    async cleanup(keepDays = 7) {
-        return new Promise((resolve, reject) => {
-            const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            const request = store.openCursor();
-            let cleaned = 0;
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    if (cursor.value.applied && cursor.value.appliedAt < cutoff) {
-                        const deleteRequest = cursor.delete();
-                        deleteRequest.onsuccess = () => {
-                            cleaned++;
-                            cursor.continue();
-                        };
-                        deleteRequest.onerror = () => { reject(deleteRequest.error); };
-                    }
-                    else {
-                        cursor.continue();
-                    }
-                }
-                else {
-                    // Cursor finished
-                    resolve(cleaned);
-                }
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Clear all sync actions
-     */
-    async clear() {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readwrite');
-            const store = tx.objectStore(this.storeName);
-            const request = store.clear();
-            tx.oncomplete = () => {
-                this.pendingActions.clear();
-                this.lastAppliedSyncId = 0;
-                resolve();
-            };
-            tx.onerror = () => { reject(tx.error); };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Get statistics
-     */
-    async getStats() {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const request = store.getAll();
-            request.onsuccess = () => {
-                const allActions = request.result;
-                const applied = allActions.filter((a) => a.applied).length;
-                const pending = allActions.filter((a) => !a.applied).length;
-                const timestamps = allActions
-                    .map((a) => a.storedAt)
-                    .filter(Boolean)
-                    .sort();
-                resolve({
-                    total: allActions.length,
-                    applied,
-                    pending,
-                    lastAppliedId: this.lastAppliedSyncId,
-                    oldestAction: timestamps.length > 0 ? new Date(timestamps[0]) : null,
-                    newestAction: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]) : null,
-                });
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Update last sync ID in metadata
-     */
-    async updateLastSyncId(syncId) {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction(['__meta'], 'readwrite');
-            const store = tx.objectStore('__meta');
-            const getRequest = store.get('metadata');
-            getRequest.onsuccess = () => {
-                const metadata = getRequest.result || {};
-                metadata.lastSyncId = syncId;
-                metadata.updatedAt = new Date();
-                const putRequest = store.put(metadata, 'metadata');
-                putRequest.onerror = () => { reject(putRequest.error); };
-            };
-            getRequest.onerror = () => { reject(getRequest.error); };
-            tx.oncomplete = () => { resolve(); };
-            tx.onerror = () => { reject(tx.error); };
-        });
-    }
-    /**
-     * Get metadata. Shape mirrors what's written by the database manager
-     * — currently only `lastSyncId` is consumed here (in `initialize`),
-     * so the return type is narrowed to that read surface. Returns
-     * `undefined` when the row hasn't been written yet (fresh DB).
-     */
-    async getMetadata() {
-        return new Promise((resolve, reject) => {
-            const tx = this.db.transaction(['__meta'], 'readonly');
-            const store = tx.objectStore('__meta');
-            const request = store.get('metadata');
-            request.onsuccess = () => {
-                const raw = request.result;
-                if (raw && typeof raw === 'object' && 'lastSyncId' in raw) {
-                    resolve(raw);
-                }
-                else {
-                    resolve(undefined);
-                }
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-    /**
-     * Rewind to a specific sync ID (for conflict resolution)
-     */
-    async rewindTo(syncId) {
-        return new Promise((resolve, reject) => {
-            // Get all actions after this sync ID
-            const tx = this.db.transaction([this.storeName], 'readonly');
-            const store = tx.objectStore(this.storeName);
-            const index = store.index('syncId');
-            const range = IDBKeyRange.lowerBound(syncId, false);
-            const request = index.getAll(range);
-            request.onsuccess = async () => {
-                const actionsToRewind = request.result;
-                // Mark them as not applied
-                const writeTx = this.db.transaction([this.storeName], 'readwrite');
-                const writeStore = writeTx.objectStore(this.storeName);
-                let processed = 0;
-                const total = actionsToRewind.length;
-                if (total === 0) {
-                    this.lastAppliedSyncId = syncId - 1;
-                    try {
-                        await this.updateLastSyncId(this.lastAppliedSyncId);
-                        resolve([]);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                    return;
-                }
-                for (const action of actionsToRewind) {
-                    action.applied = false;
-                    delete action.appliedAt;
-                    const putRequest = writeStore.put(action);
-                    putRequest.onsuccess = () => {
-                        processed++;
-                        // Add back to pending
-                        this.pendingActions.set(action.id, action);
-                        if (processed === total) {
-                            // All processed
-                            this.lastAppliedSyncId = syncId - 1;
-                        }
-                    };
-                    putRequest.onerror = () => { reject(putRequest.error); };
-                }
-                writeTx.oncomplete = async () => {
-                    try {
-                        await this.updateLastSyncId(this.lastAppliedSyncId);
-                        const result = actionsToRewind
-                            .map(toSyncAction)
-                            .filter((action) => action !== null);
-                        resolve(result);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                };
-                writeTx.onerror = () => { reject(writeTx.error); };
-            };
-            request.onerror = () => { reject(request.error); };
-        });
-    }
-}

package/dist/stores/syncAction.d.ts

@@ -1,26 +0,0 @@
-/**
- * The persisted local action record consumed by `SyncActionStore`. It is a
- * client materialization artifact, not a transaction-layer wire shape: the
- * authoritative broadcast vocabulary is the settlement core's delta wire
- * schema, while this one adds the local `__class` discriminator IndexedDB uses.
- */
-import { z } from 'zod';
-export declare const syncActionSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    modelName: z.ZodString;
-    modelId: z.ZodString;
-    action: z.ZodEnum<{
-        I: "I";
-        U: "U";
-        D: "D";
-        A: "A";
-        V: "V";
-        C: "C";
-        G: "G";
-        S: "S";
-    }>;
-    data: z.ZodUnknown;
-    __class: z.ZodDefault<z.ZodLiteral<"SyncAction">>;
-}, z.core.$strip>;
-export type SyncAction = z.infer<typeof syncActionSchema>;
-export type SyncActionType = SyncAction['action'];

package/dist/stores/syncAction.js

@@ -1,16 +0,0 @@
-/**
- * The persisted local action record consumed by `SyncActionStore`. It is a
- * client materialization artifact, not a transaction-layer wire shape: the
- * authoritative broadcast vocabulary is the settlement core's delta wire
- * schema, while this one adds the local `__class` discriminator IndexedDB uses.
- */
-import { z } from 'zod';
-import { syncDeltaActionSchema } from '../transaction/wire/delta.js';
-export const syncActionSchema = z.object({
-    id: z.number(),
-    modelName: z.string(),
-    modelId: z.string(),
-    action: syncDeltaActionSchema,
-    data: z.unknown(),
-    __class: z.literal('SyncAction').default('SyncAction'),
-});

package/dist/surface.d.ts

@@ -1,36 +0,0 @@
-/**
- * A machine-checked manifest of this package's public API surface. It lists,
- * as string tuples, the method names on `ablo.<model>`, the keys accepted by
- * the list-style read options, and the keys of the client constructor
- * options. Each tuple is proven equal to the keys of its source interface at
- * compile time, so the lists cannot drift from the real types: add or remove
- * a name on either side without updating the matching tuple and this file
- * fails to compile, in both directions — no name the interface lacks, and no
- * interface key the tuple omits.
- *
- * Documentation tooling reads these tuples to describe the surface, which
- * guarantees a generated summary never names a method or option that does
- * not exist. The names are verified here; their prose descriptions are
- * written by hand, since prose cannot be type-checked.
- */
-/**
- * The names of every method available on `ablo.<model>`, matching the keys of
- * the {@link ModelOperations} interface. Documentation tooling reads this
- * tuple, so it is the one list of model-verb names a generated summary can
- * describe.
- */
-export declare const PUBLIC_MODEL_VERBS: readonly ["retrieve", "list", "local", "create", "update", "delete", "claim", "track", "join", "onChange"];
-/**
- * The option keys accepted by `local.list` and `onChange`, matching the
- * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named
- * `state`, not `scope`.
- */
-export declare const PUBLIC_LIST_OPTION_KEYS: readonly ["where", "filter", "orderBy", "limit", "offset", "state"];
-/**
- * The keys of the client constructor options, {@link AbloOptions}. Only
- * `schema` is required; every other key is optional.
- */
-export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "authEndpoint", "persistence", "durableWrites", "commitOutbox", "commitOutboxScope", "transport", "debug", "logLevel", "logger", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser", "collaborationEvents", "plugins", "wait"];
-export type ModelVerb = (typeof PUBLIC_MODEL_VERBS)[number];
-export type ListOptionKey = (typeof PUBLIC_LIST_OPTION_KEYS)[number];
-export type AbloOptionKey = (typeof PUBLIC_ABLO_OPTION_KEYS)[number];

package/dist/surface.js

@@ -1,75 +0,0 @@
-/**
- * A machine-checked manifest of this package's public API surface. It lists,
- * as string tuples, the method names on `ablo.<model>`, the keys accepted by
- * the list-style read options, and the keys of the client constructor
- * options. Each tuple is proven equal to the keys of its source interface at
- * compile time, so the lists cannot drift from the real types: add or remove
- * a name on either side without updating the matching tuple and this file
- * fails to compile, in both directions — no name the interface lacks, and no
- * interface key the tuple omits.
- *
- * Documentation tooling reads these tuples to describe the surface, which
- * guarantees a generated summary never names a method or option that does
- * not exist. The names are verified here; their prose descriptions are
- * written by hand, since prose cannot be type-checked.
- */
-// ── the per-`ablo.<model>` verb surface ────────────────────────────────────
-/**
- * The names of every method available on `ablo.<model>`, matching the keys of
- * the {@link ModelOperations} interface. Documentation tooling reads this
- * tuple, so it is the one list of model-verb names a generated summary can
- * describe.
- */
-export const PUBLIC_MODEL_VERBS = [
-    'retrieve',
-    'list',
-    'local',
-    'create',
-    'update',
-    'delete',
-    'claim',
-    'track',
-    'join',
-    'onChange',
-];
-// ── the read/list query option surface ─────────────────────────────────────
-/**
- * The option keys accepted by `local.list` and `onChange`, matching the
- * keys of {@link LocalReadOptions}. Note that the lifecycle filter is named
- * `state`, not `scope`.
- */
-export const PUBLIC_LIST_OPTION_KEYS = [
-    'where',
-    'filter',
-    'orderBy',
-    'limit',
-    'offset',
-    'state',
-];
-// ── the `Ablo({ … })` constructor option surface ───────────────────────────
-/**
- * The keys of the client constructor options, {@link AbloOptions}. Only
- * `schema` is required; every other key is optional.
- */
-export const PUBLIC_ABLO_OPTION_KEYS = [
-    'schema',
-    'apiKey',
-    'authEndpoint',
-    'persistence',
-    'durableWrites',
-    'commitOutbox',
-    'commitOutboxScope',
-    'transport',
-    'debug',
-    'logLevel',
-    'logger',
-    'authToken',
-    'baseURL',
-    'fetch',
-    'defaultHeaders',
-    'defaultQuery',
-    'dangerouslyAllowBrowser',
-    'collaborationEvents',
-    'plugins',
-    'wait',
-];