@abloatai/ablo 0.25.0 → 0.27.0

package/dist/sync/OfflineTransactionStore.js

@@ -1,263 +0,0 @@
-/*
- * OfflineTransactionStore
- * - IndexedDB-backed queue for GraphQL mutations and REST ops
- * - AES-GCM encryption at rest (per-browser key)
- * - Priority-aware ordering with simple topological sort
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { openIDBWithTimeout } from '../core/openIDBWithTimeout.js';
-import { AbloConnectionError } from '../errors.js';
-export var Priority;
-(function (Priority) {
-    Priority[Priority["CRITICAL"] = 0] = "CRITICAL";
-    Priority[Priority["HIGH"] = 1] = "HIGH";
-    Priority[Priority["NORMAL"] = 2] = "NORMAL";
-    Priority[Priority["LOW"] = 3] = "LOW";
-})(Priority || (Priority = {}));
-// Minimal IndexedDB helpers. Delegates to openIDBWithTimeout so the open
-// request can't silently hang when another tab holds an older version
-// (`onblocked`) or when storage is in a bad state (no event fires at all).
-function openDB(name, version, upgrade) {
-    return openIDBWithTimeout(name, version, {
-        onUpgrade: (request) => upgrade(request.result),
-    });
-}
-function txStore(db, mode) {
-    const tx = db.transaction('transactions', mode);
-    const store = tx.objectStore('transactions');
-    return { tx, store };
-}
-function b64(bytes) {
-    // Buffer.from accepts ArrayBufferLike but the @types/node overloads
-    // don't all line up — wrap in Uint8Array (which Buffer DOES accept
-    // unambiguously) so the type system stays happy without a cast.
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(new Uint8Array(bytes)).toString('base64');
-    }
-    let binary = '';
-    const arr = new Uint8Array(bytes);
-    for (let i = 0; i < arr.byteLength; i++)
-        binary += String.fromCharCode(arr[i]);
-    return btoa(binary);
-}
-function b64dec(text) {
-    if (typeof Buffer !== 'undefined') {
-        const buffer = Buffer.from(text, 'base64');
-        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-    }
-    const binary = atob(text);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++)
-        bytes[i] = binary.charCodeAt(i);
-    return bytes.buffer;
-}
-async function getOrCreateKey() {
-    try {
-        const storageKey = 'ablo:offline:key';
-        let raw = localStorage.getItem(storageKey);
-        if (!raw) {
-            const seed = crypto.getRandomValues(new Uint8Array(32));
-            raw = b64(seed.buffer);
-            localStorage.setItem(storageKey, raw);
-        }
-        const keyData = b64dec(raw);
-        return await crypto.subtle.importKey('raw', keyData, 'AES-GCM', false, ['encrypt', 'decrypt']);
-    }
-    catch {
-        return null; // no crypto in environment
-    }
-}
-async function encryptJSON(key, data) {
-    const plaintext = new TextEncoder().encode(JSON.stringify(data));
-    if (!key || !crypto?.subtle) {
-        return { iv: '', ciphertext: b64(plaintext.buffer) };
-    }
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, plaintext);
-    return { iv: b64(iv.buffer), ciphertext: b64(ct) };
-}
-async function decryptJSON(key, record) {
-    if (!key || !record.iv) {
-        const buf = b64dec(record.ciphertext);
-        const text = new TextDecoder().decode(buf);
-        return JSON.parse(text);
-    }
-    const iv = new Uint8Array(b64dec(record.iv));
-    const ct = b64dec(record.ciphertext);
-    const pt = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, ct);
-    return JSON.parse(new TextDecoder().decode(pt));
-}
-export class OfflineTransactionStore {
-    db = null;
-    key = null;
-    async init() {
-        if (typeof indexedDB === 'undefined')
-            return;
-        this.key = await getOrCreateKey();
-        this.db = await openDB('ablo-sync', 1, (db) => {
-            if (!db.objectStoreNames.contains('transactions')) {
-                const store = db.createObjectStore('transactions', { keyPath: 'id' });
-                store.createIndex('priority_createdAt', ['priority', 'createdAt']);
-                store.createIndex('createdAt', 'createdAt');
-            }
-        });
-    }
-    async enqueue(tx) {
-        if (!this.db)
-            await this.init();
-        if (!this.db)
-            throw new AbloConnectionError('IndexedDB unavailable', {
-                code: 'idb_unavailable',
-            });
-        const full = { ...tx, createdAt: Date.now() };
-        const { iv, ciphertext } = await encryptJSON(this.key, full);
-        const rec = {
-            id: full.id,
-            priority: full.priority,
-            createdAt: full.createdAt,
-            dependsOn: full.dependsOn,
-            iv,
-            ciphertext,
-        };
-        const { tx: itx, store } = txStore(this.db, 'readwrite');
-        return new Promise((resolve, reject) => {
-            const req = store.put(rec);
-            req.onsuccess = () => {
-                resolve(full.id);
-            };
-            req.onerror = () => {
-                reject(req.error);
-            };
-        });
-    }
-    async listAll() {
-        if (!this.db)
-            await this.init();
-        if (!this.db)
-            return [];
-        const out = [];
-        const { store } = txStore(this.db, 'readonly');
-        const req = store.getAll();
-        return new Promise((resolve, reject) => {
-            req.onsuccess = async () => {
-                try {
-                    for (const rec of req.result) {
-                        out.push(await decryptJSON(this.key, rec));
-                    }
-                    resolve(out);
-                }
-                catch (e) {
-                    reject(e);
-                }
-            };
-            req.onerror = () => reject(req.error);
-        });
-    }
-    async getOptimizedSyncOrder() {
-        // Collect all, sort by priority asc, then topologically by dependsOn
-        const items = await this.listAll();
-        items.sort((a, b) => {
-            if (a.priority !== b.priority)
-                return a.priority - b.priority;
-            return a.createdAt - b.createdAt;
-        });
-        // Topological sort
-        const byId = new Map();
-        const indeg = new Map();
-        const graph = new Map();
-        for (const it of items) {
-            byId.set(it.id, it);
-            indeg.set(it.id, 0);
-            graph.set(it.id, []);
-        }
-        for (const it of items) {
-            for (const dep of it.dependsOn || []) {
-                if (!byId.has(dep))
-                    continue; // ignore external
-                indeg.set(it.id, (indeg.get(it.id) || 0) + 1);
-                graph.get(dep).push(it.id);
-            }
-        }
-        const queue = [];
-        for (const [id, deg] of indeg)
-            if (deg === 0)
-                queue.push(id);
-        // Sort queue by priority so nodes at the same dependency level
-        // come out in priority order (lower number = higher priority)
-        const sortQueue = () => queue.sort((a, b) => {
-            const pa = byId.get(a)?.priority ?? 0;
-            const pb = byId.get(b)?.priority ?? 0;
-            if (pa !== pb)
-                return pa - pb;
-            return (byId.get(a)?.createdAt ?? 0) - (byId.get(b)?.createdAt ?? 0);
-        });
-        sortQueue();
-        const order = [];
-        while (queue.length) {
-            const id = queue.shift();
-            const node = byId.get(id);
-            if (node)
-                order.push(node);
-            for (const nxt of graph.get(id) || []) {
-                const d = (indeg.get(nxt) || 0) - 1;
-                indeg.set(nxt, d);
-                if (d === 0)
-                    queue.push(nxt);
-            }
-            if (queue.length > 1)
-                sortQueue();
-        }
-        // Fallback: if cycles exist, append remaining by createdAt
-        if (order.length < items.length) {
-            const seen = new Set(order.map((x) => x.id));
-            for (const it of items)
-                if (!seen.has(it.id))
-                    order.push(it);
-        }
-        return order;
-    }
-    async remove(id) {
-        if (!this.db)
-            await this.init();
-        if (!this.db)
-            return;
-        const { store } = txStore(this.db, 'readwrite');
-        await new Promise((resolve, reject) => {
-            const req = store.delete(id);
-            req.onsuccess = () => resolve();
-            req.onerror = () => reject(req.error);
-        });
-    }
-    async clear() {
-        if (!this.db)
-            await this.init();
-        if (!this.db)
-            return;
-        const { store } = txStore(this.db, 'readwrite');
-        await new Promise((resolve, reject) => {
-            const req = store.clear();
-            req.onsuccess = () => resolve();
-            req.onerror = () => reject(req.error);
-        });
-    }
-    // Flush with caller-provided network function
-    async flush(processor) {
-        const ordered = await this.getOptimizedSyncOrder();
-        let processed = 0;
-        let failed = 0;
-        for (const tx of ordered) {
-            try {
-                await processor(tx);
-                await this.remove(tx.id);
-                processed++;
-            }
-            catch (_err) {
-                // Stop on first failure to preserve order
-                failed++;
-                break;
-            }
-        }
-        return { processed, failed };
-    }
-}
-export const offlineTxStore = new OfflineTransactionStore();

package/dist/transactions/OptimisticEchoTracker.d.ts

@@ -1,82 +0,0 @@
-/**
- * OptimisticEchoTracker — receive-layer reconciliation primitive.
- *
- * Tracks the set of transaction ids the client has applied locally
- * but the server has not yet confirmed. When a sync delta arrives
- * carrying a `transactionId` the tracker recognizes, the pool
- * mutation is suppressed (the optimistic write already reflects it).
- * Drained when the matching delta echo lands or when the originating
- * transaction is rolled back.
- *
- * Architectural framing: see
- * `apps/sync-server/docs/OPTIMISTIC_RECONCILIATION.md`. This is the
- * "discriminator at the apply layer" the doc names — without it the
- * authoritative-layer apply path blindly re-applies confirmations on
- * top of whatever optimistic state has since diverged, producing the
- * chart-delete flicker.
- *
- * Bounded by `maxSize` to defend against runaway growth from a
- * pathological "transactions never confirmed and never rolled back"
- * loop. When the bound is hit, the OLDEST id is evicted (FIFO via
- * insertion-ordered Map). Eviction means a future echo of that
- * transaction will be applied as a foreign mutation — no correctness
- * risk for the originating tab (the pool already reflects the local
- * write); the worst case is a single redundant pool re-set.
- */
-export interface OptimisticEchoTrackerOptions {
-    /**
-     * Hard upper bound on tracked ids. FIFO eviction beyond this. The
-     * default of 10_000 covers a 200-tab user mid-bulk-edit (each tab
-     * tracking dozens of unconfirmed transactions) with two orders of
-     * magnitude of headroom.
-     */
-    maxSize?: number;
-}
-export interface OptimisticEchoMetrics {
-    /** Total ids currently tracked. */
-    size: number;
-    /** Cumulative ids ever added since construction. */
-    totalAdded: number;
-    /** Cumulative successful echo matches (delta arrived → drained). */
-    hits: number;
-    /** Cumulative explicit rollback drains (transaction never made it). */
-    rollbacks: number;
-    /** Cumulative ids evicted due to maxSize pressure. */
-    evictions: number;
-}
-export declare class OptimisticEchoTracker {
-    private readonly ids;
-    private readonly maxSize;
-    private _totalAdded;
-    private _hits;
-    private _rollbacks;
-    private _evictions;
-    constructor(options?: OptimisticEchoTrackerOptions);
-    /**
-     * Mark a transaction as locally-applied. The next sync delta with a
-     * matching `transactionId` will be recognized as the server's
-     * confirmation of this same write. Idempotent — repeated calls with
-     * the same id are no-ops.
-     */
-    markPending(transactionId: string): void;
-    /**
-     * If the id is currently tracked, drain it and return true (signal
-     * to the caller: this is an echo, skip the pool mutation).
-     * Otherwise return false (foreign mutation, apply normally).
-     *
-     * Combined check+drain into one method to make the receive-path
-     * idiom hard to misuse: a separate `has` then `drain` would race
-     * if multiple deltas with the same id arrived in the same batch.
-     */
-    consumeEcho(transactionId: string | null | undefined): boolean;
-    /**
-     * Drain on rollback. The transaction was cancelled before a server
-     * confirmation arrived — no echo will ever come, so the pending
-     * entry would otherwise leak. Counts as a separate metric category
-     * so a spike of `rollbacks` (vs `hits`) signals network or
-     * server-side health issues.
-     */
-    drainOnRollback(transactionId: string): void;
-    getMetrics(): Readonly<OptimisticEchoMetrics>;
-    clear(): void;
-}

package/dist/transactions/OptimisticEchoTracker.js

@@ -1,104 +0,0 @@
-/**
- * OptimisticEchoTracker — receive-layer reconciliation primitive.
- *
- * Tracks the set of transaction ids the client has applied locally
- * but the server has not yet confirmed. When a sync delta arrives
- * carrying a `transactionId` the tracker recognizes, the pool
- * mutation is suppressed (the optimistic write already reflects it).
- * Drained when the matching delta echo lands or when the originating
- * transaction is rolled back.
- *
- * Architectural framing: see
- * `apps/sync-server/docs/OPTIMISTIC_RECONCILIATION.md`. This is the
- * "discriminator at the apply layer" the doc names — without it the
- * authoritative-layer apply path blindly re-applies confirmations on
- * top of whatever optimistic state has since diverged, producing the
- * chart-delete flicker.
- *
- * Bounded by `maxSize` to defend against runaway growth from a
- * pathological "transactions never confirmed and never rolled back"
- * loop. When the bound is hit, the OLDEST id is evicted (FIFO via
- * insertion-ordered Map). Eviction means a future echo of that
- * transaction will be applied as a foreign mutation — no correctness
- * risk for the originating tab (the pool already reflects the local
- * write); the worst case is a single redundant pool re-set.
- */
-const DEFAULT_MAX_SIZE = 10_000;
-export class OptimisticEchoTracker {
-    // Map (not Set) for O(1) FIFO eviction via insertion order.
-    // Value is unused; Map.keys() iterates in insertion order so
-    // `keys().next()` yields the oldest id.
-    ids = new Map();
-    maxSize;
-    // Metrics — internal counters; exposed via `getMetrics()`. Kept
-    // numeric (not BigInt) since cumulative-since-page-load fits well
-    // under Number.MAX_SAFE_INTEGER for any realistic session.
-    _totalAdded = 0;
-    _hits = 0;
-    _rollbacks = 0;
-    _evictions = 0;
-    constructor(options = {}) {
-        this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
-    }
-    /**
-     * Mark a transaction as locally-applied. The next sync delta with a
-     * matching `transactionId` will be recognized as the server's
-     * confirmation of this same write. Idempotent — repeated calls with
-     * the same id are no-ops.
-     */
-    markPending(transactionId) {
-        if (this.ids.has(transactionId))
-            return;
-        if (this.ids.size >= this.maxSize) {
-            const oldest = this.ids.keys().next().value;
-            if (oldest !== undefined) {
-                this.ids.delete(oldest);
-                this._evictions += 1;
-            }
-        }
-        this.ids.set(transactionId, true);
-        this._totalAdded += 1;
-    }
-    /**
-     * If the id is currently tracked, drain it and return true (signal
-     * to the caller: this is an echo, skip the pool mutation).
-     * Otherwise return false (foreign mutation, apply normally).
-     *
-     * Combined check+drain into one method to make the receive-path
-     * idiom hard to misuse: a separate `has` then `drain` would race
-     * if multiple deltas with the same id arrived in the same batch.
-     */
-    consumeEcho(transactionId) {
-        if (!transactionId)
-            return false;
-        if (!this.ids.has(transactionId))
-            return false;
-        this.ids.delete(transactionId);
-        this._hits += 1;
-        return true;
-    }
-    /**
-     * Drain on rollback. The transaction was cancelled before a server
-     * confirmation arrived — no echo will ever come, so the pending
-     * entry would otherwise leak. Counts as a separate metric category
-     * so a spike of `rollbacks` (vs `hits`) signals network or
-     * server-side health issues.
-     */
-    drainOnRollback(transactionId) {
-        if (this.ids.delete(transactionId)) {
-            this._rollbacks += 1;
-        }
-    }
-    getMetrics() {
-        return {
-            size: this.ids.size,
-            totalAdded: this._totalAdded,
-            hits: this._hits,
-            rollbacks: this._rollbacks,
-            evictions: this._evictions,
-        };
-    }
-    clear() {
-        this.ids.clear();
-    }
-}

package/dist/transactions/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * Transaction types and exports (MVP)
- *
- * Simplified for MVP: only TransactionQueue exports
- * Individual transaction classes removed in favor of simple transaction objects
- */
-export { TransactionQueue } from './TransactionQueue.js';
-export type TransactionType = 'create' | 'update' | 'delete';
-export interface Transaction {
-    id: string;
-    type: TransactionType;
-    modelName: string;
-    modelId: string;
-    data?: any;
-    createdAt: number;
-}

package/dist/transactions/index.js

@@ -1,7 +0,0 @@
-/**
- * Transaction types and exports (MVP)
- *
- * Simplified for MVP: only TransactionQueue exports
- * Individual transaction classes removed in favor of simple transaction objects
- */
-export { TransactionQueue } from './TransactionQueue.js';

package/dist/transactions/mutation-error-handler.d.ts

@@ -1,5 +0,0 @@
-/**
- * Shared error handler for mutation execution.
- * Logs to SyncObservability (unless offline + network error), then re-throws.
- */
-export declare function handleMutationError(error: unknown, context: string, schemaName: string, modelId: string): never;

package/dist/transactions/mutation-error-handler.js

@@ -1,39 +0,0 @@
-import { getContext } from "../context.js";
-/**
- * Shared error handler for mutation execution.
- * Logs to SyncObservability (unless offline + network error), then re-throws.
- */
-export function handleMutationError(error, context, schemaName, modelId) {
-    const errorInfo = { schemaName, modelId, rawError: error };
-    if (error instanceof Error) {
-        errorInfo.message = error.message;
-        errorInfo.name = error.name;
-        errorInfo.stack =
-            typeof error.stack === 'string' ? error.stack.split('\n').slice(0, 5) : undefined;
-    }
-    else if (error && typeof error === 'object') {
-        errorInfo.message =
-            error.message ??
-                error.error ??
-                'Unknown error';
-        errorInfo.code = error.code;
-        errorInfo.extensions = error.extensions;
-    }
-    else {
-        errorInfo.message = String(error);
-    }
-    const isOffline = !getContext().onlineStatus.isOnline();
-    const msg = errorInfo.message;
-    const isNetworkError = msg?.includes('Failed to fetch') ||
-        msg?.includes('Network request failed') ||
-        msg?.includes('NetworkError');
-    if (!isOffline || !isNetworkError) {
-        getContext().observability.captureTransactionFailure({
-            context,
-            error: error instanceof Error ? error : String(errorInfo.message ?? error),
-            modelName: schemaName,
-            modelId,
-        });
-    }
-    throw error;
-}

package/dist/utils/mobx-setup.d.ts

@@ -1,42 +0,0 @@
-/**
- * M1 Helper - Simplified MobX Setup
- *
- * Fixed version that doesn't conflict with existing getters/setters
- */
-import { type AnnotationMapEntry } from 'mobx';
-import { PropertyMetadata, ReferenceMetadata } from '../types/index.js';
-/**
- * The internal contract M1 relies on. Models invoke M1 from inside
- * their constructor, where these fields are guaranteed to exist on
- * `this`. Declared here as the bound on M1's generic so the body can
- * reference them without `as any` casts. Each field is optional so a
- * partial Model implementation (e.g., a test fixture) still satisfies
- * the bound.
- */
-interface M1Target {
-    _hasCustomObservability?: boolean;
-    _isConstructing?: boolean;
-    _extraMobxAnnotations?: Record<string, AnnotationMapEntry>;
-    setupObservability?(): void;
-    propertyChanged?(name: string, oldValue: unknown, newValue: unknown): void;
-}
-/**
- * M1 - Make properties observable with proper MobX setup
- *
- * Simplified version that respects existing getters/setters
- */
-export declare function M1<T extends M1Target>(target: T, propertyMetadata: Map<string, PropertyMetadata>, referenceMetadata?: Map<string, ReferenceMetadata>): void;
-/**
- * Helper to make a class observable
- * For classes that don't have custom observability
- */
-export declare function makeModelObservable(modelClass: any, propertyMetadata: Map<string, PropertyMetadata>, referenceMetadata?: Map<string, any>): any;
-/**
- * Utility to check if a property is observable
- */
-export declare function isObservableProperty(target: any, propName: string, propertyMetadata: Map<string, PropertyMetadata>): boolean;
-/**
- * Utility to get computed properties
- */
-export declare function getComputedProperties(propertyMetadata: Map<string, PropertyMetadata>): string[];
-export {};