@affectively/dash 5.2.1 → 5.3.1

package/dist/src/sync/d1-provider.js

@@ -1,345 +0,0 @@
-/**
- * D1 Sync Provider
- *
- * Provides HTTP-based sync between local Dash SQLite (WASM) and Cloudflare D1.
- *
- * Unlike the HybridProvider which syncs Yjs CRDT documents over WebSocket,
- * this provider syncs regular SQL tables via HTTP REST API.
- *
- * Architecture:
- * - Local changes are tracked in a sync_queue table
- * - Sync runs periodically or on-demand
- * - Conflicts are resolved using last-write-wins with timestamps
- */
-import { dash } from '../engine/sqlite.js';
-export class D1SyncProvider {
-    config;
-    syncTimer = null;
-    isSyncing = false;
-    lastSyncTime = 0;
-    initialized = false;
-    constructor(config) {
-        this.config = {
-            syncInterval: 30000,
-            ...config,
-        };
-    }
-    /**
-     * Initialize the sync provider - must be called before syncing
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        await dash.ready();
-        // Create sync metadata and queue tables
-        dash.execute(`
-      CREATE TABLE IF NOT EXISTS dash_sync_meta (
-        key TEXT PRIMARY KEY,
-        value TEXT
-      )
-    `);
-        dash.execute(`
-      CREATE TABLE IF NOT EXISTS dash_sync_queue (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        table_name TEXT NOT NULL,
-        row_id TEXT NOT NULL,
-        operation TEXT NOT NULL CHECK(operation IN ('create', 'update', 'delete')),
-        data TEXT,
-        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        synced INTEGER DEFAULT 0
-      )
-    `);
-        // Create index for efficient querying
-        dash.execute(`
-      CREATE INDEX IF NOT EXISTS idx_sync_queue_synced
-      ON dash_sync_queue(synced, created_at)
-    `);
-        // Load last sync time
-        const meta = dash.execute("SELECT value FROM dash_sync_meta WHERE key = 'lastSyncTime'");
-        if (meta.length > 0) {
-            this.lastSyncTime = parseInt(meta[0].value, 10) || 0;
-        }
-        this.initialized = true;
-        // Set up triggers for each table
-        for (const table of this.config.tables) {
-            this.setupTableTriggers(table);
-        }
-        // Start auto-sync if configured
-        if (this.config.syncInterval && this.config.syncInterval > 0) {
-            this.startAutoSync();
-        }
-        console.log('[D1SyncProvider] Initialized for tables:', this.config.tables);
-    }
-    /**
-     * Set up SQLite triggers to track changes for a table
-     */
-    setupTableTriggers(tableName) {
-        // Clean up existing triggers first
-        try {
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${tableName}_insert`);
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${tableName}_update`);
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${tableName}_delete`);
-        }
-        catch {
-            // Ignore errors from dropping non-existent triggers
-        }
-        // Create INSERT trigger
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${tableName}_insert
-      AFTER INSERT ON ${tableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES ('${tableName}', NEW.id, 'create', json(NEW));
-      END
-    `);
-        // Create UPDATE trigger
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${tableName}_update
-      AFTER UPDATE ON ${tableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES ('${tableName}', NEW.id, 'update', json(NEW));
-      END
-    `);
-        // Create DELETE trigger
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${tableName}_delete
-      AFTER DELETE ON ${tableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES ('${tableName}', OLD.id, 'delete', NULL);
-      END
-    `);
-    }
-    /**
-     * Start automatic sync at the configured interval
-     */
-    startAutoSync() {
-        if (this.syncTimer)
-            return;
-        this.syncTimer = setInterval(() => {
-            this.sync().catch((err) => {
-                console.error('[D1SyncProvider] Auto-sync failed:', err);
-                this.config.onSyncError?.(err);
-            });
-        }, this.config.syncInterval);
-        console.log('[D1SyncProvider] Auto-sync started, interval:', this.config.syncInterval, 'ms');
-    }
-    /**
-     * Stop automatic sync
-     */
-    stopAutoSync() {
-        if (this.syncTimer) {
-            clearInterval(this.syncTimer);
-            this.syncTimer = null;
-            console.log('[D1SyncProvider] Auto-sync stopped');
-        }
-    }
-    /**
-     * Perform a sync operation
-     */
-    async sync() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        if (this.isSyncing) {
-            console.log('[D1SyncProvider] Sync already in progress, skipping');
-            return { pushed: 0, pulled: 0, errors: ['Sync already in progress'], timestamp: Date.now() };
-        }
-        this.isSyncing = true;
-        const result = { pushed: 0, pulled: 0, errors: [], timestamp: Date.now() };
-        try {
-            const token = await this.config.getAuthToken();
-            if (!token) {
-                throw new Error('No auth token available');
-            }
-            // Get pending changes from queue
-            const pending = dash.execute(`
-        SELECT * FROM dash_sync_queue
-        WHERE synced = 0
-        ORDER BY created_at ASC
-        LIMIT 100
-      `);
-            // Group changes by table
-            const changes = {};
-            for (const entry of pending) {
-                if (!changes[entry.table_name]) {
-                    changes[entry.table_name] = { creates: [], updates: [], deletes: [] };
-                }
-                const tableChanges = changes[entry.table_name];
-                const data = entry.data ? JSON.parse(entry.data) : null;
-                switch (entry.operation) {
-                    case 'create':
-                        if (data)
-                            tableChanges.creates.push(data);
-                        break;
-                    case 'update':
-                        if (data)
-                            tableChanges.updates.push({ id: entry.row_id, data });
-                        break;
-                    case 'delete':
-                        tableChanges.deletes.push(entry.row_id);
-                        break;
-                }
-            }
-            // Sync each table
-            for (const tableName of this.config.tables) {
-                const tableChanges = changes[tableName] || { creates: [], updates: [], deletes: [] };
-                try {
-                    const response = await fetch(`${this.config.baseUrl}/sync`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${token}`,
-                        },
-                        body: JSON.stringify({
-                            table: tableName,
-                            creates: tableChanges.creates,
-                            updates: tableChanges.updates,
-                            deletes: tableChanges.deletes,
-                            lastSyncTime: this.lastSyncTime,
-                        }),
-                    });
-                    if (!response.ok) {
-                        const errorText = await response.text();
-                        result.errors.push(`${tableName}: ${response.status} ${errorText}`);
-                        continue;
-                    }
-                    const syncResponse = await response.json();
-                    result.pushed += tableChanges.creates.length + tableChanges.updates.length + tableChanges.deletes.length;
-                    result.pulled += syncResponse.serverChanges?.length || 0;
-                    // Apply server changes locally
-                    if (syncResponse.serverChanges && syncResponse.serverChanges.length > 0) {
-                        await this.applyServerChanges(tableName, syncResponse.serverChanges);
-                    }
-                    // Update sync time
-                    if (syncResponse.syncTime > this.lastSyncTime) {
-                        this.lastSyncTime = syncResponse.syncTime;
-                        dash.execute("INSERT OR REPLACE INTO dash_sync_meta (key, value) VALUES ('lastSyncTime', ?)", [String(this.lastSyncTime)]);
-                    }
-                }
-                catch (err) {
-                    result.errors.push(`${tableName}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            // Mark synced entries
-            if (pending.length > 0) {
-                const ids = pending.map(e => e.id).join(',');
-                dash.execute(`UPDATE dash_sync_queue SET synced = 1 WHERE id IN (${ids})`);
-            }
-            // Clean up old synced entries (keep last 1000)
-            dash.execute(`
-        DELETE FROM dash_sync_queue
-        WHERE synced = 1
-        AND id NOT IN (
-          SELECT id FROM dash_sync_queue
-          WHERE synced = 1
-          ORDER BY id DESC
-          LIMIT 1000
-        )
-      `);
-            console.log('[D1SyncProvider] Sync complete:', result);
-            this.config.onSyncComplete?.(result);
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            result.errors.push(error.message);
-            console.error('[D1SyncProvider] Sync failed:', error);
-            this.config.onSyncError?.(error);
-        }
-        finally {
-            this.isSyncing = false;
-        }
-        return result;
-    }
-    /**
-     * Apply changes received from the server
-     */
-    async applyServerChanges(tableName, changes) {
-        for (const change of changes) {
-            try {
-                // Check if this is a delete (marked by a flag or null data)
-                if (change.deleted || change._deleted) {
-                    dash.execute(`DELETE FROM ${tableName} WHERE id = ?`, [change.id]);
-                    continue;
-                }
-                // Get column names from the change object
-                const columns = Object.keys(change).filter(k => !k.startsWith('_'));
-                const placeholders = columns.map(() => '?').join(', ');
-                const values = columns.map(k => {
-                    const v = change[k];
-                    // Serialize objects/arrays to JSON
-                    if (v !== null && typeof v === 'object') {
-                        return JSON.stringify(v);
-                    }
-                    return v;
-                });
-                // Use INSERT OR REPLACE to handle both new and updated records
-                const sql = `INSERT OR REPLACE INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
-                dash.execute(sql, values);
-            }
-            catch (err) {
-                console.error(`[D1SyncProvider] Failed to apply change to ${tableName}:`, err, change);
-            }
-        }
-    }
-    /**
-     * Queue a change manually (for cases where triggers can't be used)
-     */
-    queueChange(tableName, rowId, operation, data) {
-        if (!this.initialized) {
-            console.warn('[D1SyncProvider] Not initialized, change will not be queued');
-            return;
-        }
-        dash.execute(`INSERT INTO dash_sync_queue (table_name, row_id, operation, data) VALUES (?, ?, ?, ?)`, [tableName, rowId, operation, data ? JSON.stringify(data) : null]);
-    }
-    /**
-     * Get the current sync status
-     */
-    getStatus() {
-        let pendingChanges = 0;
-        if (this.initialized) {
-            const result = dash.execute('SELECT COUNT(*) as count FROM dash_sync_queue WHERE synced = 0');
-            pendingChanges = result[0]?.count || 0;
-        }
-        return {
-            initialized: this.initialized,
-            syncing: this.isSyncing,
-            lastSyncTime: this.lastSyncTime,
-            pendingChanges,
-        };
-    }
-    /**
-     * Force a full sync by resetting last sync time
-     */
-    async forceFullSync() {
-        this.lastSyncTime = 0;
-        dash.execute("INSERT OR REPLACE INTO dash_sync_meta (key, value) VALUES ('lastSyncTime', '0')");
-        return this.sync();
-    }
-    /**
-     * Destroy the provider and clean up
-     */
-    destroy() {
-        this.stopAutoSync();
-        this.initialized = false;
-        console.log('[D1SyncProvider] Destroyed');
-    }
-}
-// Export singleton factory for convenience
-let defaultProvider = null;
-export function getD1SyncProvider(config) {
-    if (!defaultProvider && config) {
-        defaultProvider = new D1SyncProvider(config);
-    }
-    if (!defaultProvider) {
-        throw new Error('D1SyncProvider not configured. Call getD1SyncProvider(config) first.');
-    }
-    return defaultProvider;
-}
-export function resetD1SyncProvider() {
-    if (defaultProvider) {
-        defaultProvider.destroy();
-        defaultProvider = null;
-    }
-}

package/dist/src/sync/hybrid-provider.d.ts

@@ -1,172 +0,0 @@
-import * as Y from 'yjs';
-import { Observable } from 'lib0/observable';
-import * as awarenessProtocol from 'y-protocols/awareness';
-import { type AeonConfig } from './aeon/config.js';
-import { DashDeltaAdapter } from './aeon/delta-adapter.js';
-import { DashPresenceAdapter } from './aeon/presence-adapter.js';
-import { DashOfflineAdapter } from './aeon/offline-adapter.js';
-export declare class HybridProvider extends Observable<string> {
-    private doc;
-    private ws;
-    private wt;
-    private connected;
-    private url;
-    private roomName;
-    awareness: awarenessProtocol.Awareness;
-    private writer;
-    private highFrequencyMode;
-    private aeonConfig;
-    private deltaAdapter;
-    private presenceAdapter;
-    private offlineAdapter;
-    constructor(url: string, roomName: string, doc: Y.Doc, { awareness, aeonConfig, }?: {
-        awareness?: awarenessProtocol.Awareness;
-        aeonConfig?: AeonConfig;
-    });
-    private connect;
-    private connectWebSocket;
-    private getAuthToken;
-    enterHighFrequencyMode(): Promise<void>;
-    private sendSyncStep1;
-    private readLoop;
-    private handleMessage;
-    private send;
-    private onDocUpdate;
-    private onAwarenessUpdate;
-    destroy(): void;
-    /**
-     * Get the delta adapter for compression stats
-     */
-    getDeltaAdapter(): DashDeltaAdapter | null;
-    /**
-     * Get the presence adapter for rich presence features
-     */
-    getPresenceAdapter(): DashPresenceAdapter | null;
-    /**
-     * Get the offline adapter for queue management
-     */
-    getOfflineAdapter(): DashOfflineAdapter | null;
-    /**
-     * Get Aeon configuration
-     */
-    getAeonConfig(): AeonConfig;
-    /**
-     * Process offline queue when back online
-     */
-    processOfflineQueue(): Promise<{
-        synced: number;
-        failed: number;
-    }>;
-    /**
-     * Get comprehensive connection status
-     */
-    getConnectionStatus(): ConnectionStatus;
-    /**
-     * Get all awareness states from connected peers
-     */
-    getAwarenessStates(): AwarenessState[];
-    /**
-     * Get the local client ID
-     */
-    getLocalClientId(): number;
-    /**
-     * Get connected peer count (excluding local)
-     */
-    getPeerCount(): number;
-    /**
-     * Get document state information
-     */
-    getDocumentState(): DocumentState;
-    /**
-     * Get a snapshot of the Yjs document for inspection
-     */
-    getDocumentSnapshot(): DocumentSnapshot;
-    /**
-     * Set local awareness state for introspection (admin view)
-     */
-    setLocalAwareness(state: Record<string, unknown>): void;
-    /**
-     * Get full provider status for debugging
-     */
-    getProviderStatus(): ProviderStatus;
-    /**
-     * Get Aeon-specific status
-     */
-    getAeonStatus(): AeonStatus;
-}
-export interface ConnectionStatus {
-    connected: boolean;
-    roomName: string;
-    url: string;
-    websocket: {
-        state: 'connecting' | 'open' | 'closing' | 'closed';
-        connected: boolean;
-    };
-    webTransport: {
-        connected: boolean;
-        highFrequencyMode: boolean;
-    };
-    transport: 'WebSocket' | 'WebTransport';
-}
-export interface AwarenessState {
-    clientId: number;
-    state: Record<string, unknown>;
-    isLocal: boolean;
-}
-export interface SharedTypeInfo {
-    name: string;
-    type: 'YMap' | 'YArray' | 'YText' | 'YXmlFragment' | 'unknown';
-    size: number;
-}
-export interface DocumentState {
-    clientId: number;
-    guid: string;
-    stateVectorSize: number;
-    updateSize: number;
-    sharedTypes: SharedTypeInfo[];
-    transactionCount: number;
-    gcEnabled: boolean;
-}
-export interface DocumentSnapshot {
-    timestamp: string;
-    roomName: string;
-    content: Record<string, unknown>;
-}
-export interface ProviderStatus {
-    connection: ConnectionStatus;
-    awareness: {
-        localClientId: number;
-        peerCount: number;
-        states: AwarenessState[];
-    };
-    document: DocumentState;
-    aeon: AeonStatus;
-}
-export interface AeonStatus {
-    enabled: {
-        deltaSync: boolean;
-        richPresence: boolean;
-        offlineQueue: boolean;
-    };
-    delta: {
-        totalOperations: number;
-        totalFull: number;
-        totalDelta: number;
-        totalOriginalSize: number;
-        totalDeltaSize: number;
-        averageReductionPercent: number;
-    } | null;
-    offline: {
-        pending: number;
-        syncing: number;
-        failed: number;
-        synced: number;
-        totalOperations: number;
-    } | null;
-    presence: {
-        total: number;
-        online: number;
-        away: number;
-        offline: number;
-    } | null;
-}