@affectively/dash 5.4.1 → 5.4.5

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

@@ -1,418 +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 _lastModified timestamps
- *
- * Security:
- * - Table/column names are validated against allowed patterns
- * - All user data uses parameterized queries
- */
-import { dash } from '../engine/sqlite.js';
-// Valid identifier pattern (prevents SQL injection)
-const VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-/**
- * Validate and escape a SQL identifier (table or column name)
- * Throws if the identifier is invalid
- */
-function escapeIdentifier(name) {
-    if (!VALID_IDENTIFIER.test(name)) {
-        throw new Error(`Invalid SQL identifier: ${name}`);
-    }
-    // Double-quote the identifier for safety
-    return `"${name}"`;
-}
-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
-     * Uses validated identifiers to prevent SQL injection
-     */
-    setupTableTriggers(tableName) {
-        // Validate table name to prevent SQL injection
-        const safeTableName = escapeIdentifier(tableName);
-        const triggerSuffix = tableName.replace(/[^a-zA-Z0-9_]/g, '_');
-        // Clean up existing triggers first
-        try {
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${triggerSuffix}_insert`);
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${triggerSuffix}_update`);
-            dash.execute(`DROP TRIGGER IF EXISTS dash_sync_${triggerSuffix}_delete`);
-        }
-        catch {
-            // Ignore errors from dropping non-existent triggers
-        }
-        // Create INSERT trigger with parameterized table name in data
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${triggerSuffix}_insert
-      AFTER INSERT ON ${safeTableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES (
-          '${tableName.replace(/'/g, "''")}',
-          NEW.id,
-          'create',
-          json_object(
-            'id', NEW.id,
-            '_lastModified', strftime('%s', 'now') * 1000,
-            '_data', json(NEW)
-          )
-        );
-      END
-    `);
-        // Create UPDATE trigger with timestamp for LWW
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${triggerSuffix}_update
-      AFTER UPDATE ON ${safeTableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES (
-          '${tableName.replace(/'/g, "''")}',
-          NEW.id,
-          'update',
-          json_object(
-            'id', NEW.id,
-            '_lastModified', strftime('%s', 'now') * 1000,
-            '_data', json(NEW)
-          )
-        );
-      END
-    `);
-        // Create DELETE trigger
-        dash.execute(`
-      CREATE TRIGGER IF NOT EXISTS dash_sync_${triggerSuffix}_delete
-      AFTER DELETE ON ${safeTableName}
-      BEGIN
-        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
-        VALUES (
-          '${tableName.replace(/'/g, "''")}',
-          OLD.id,
-          'delete',
-          json_object('id', OLD.id, '_lastModified', strftime('%s', 'now') * 1000)
-        );
-      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 with Last-Write-Wins (LWW) conflict resolution
-     * Server changes only win if their _lastModified is newer than local
-     */
-    async applyServerChanges(tableName, changes) {
-        const safeTableName = escapeIdentifier(tableName);
-        for (const change of changes) {
-            try {
-                const serverTimestamp = change._lastModified || 0;
-                const rowId = change.id;
-                // Check if this is a delete (marked by a flag or null data)
-                if (change.deleted || change._deleted) {
-                    // For deletes, check if local row exists and is older
-                    const local = dash.execute(`SELECT _lastModified FROM ${safeTableName} WHERE id = ?`, [rowId]);
-                    if (local.length === 0 || (local[0]._lastModified || 0) < serverTimestamp) {
-                        dash.execute(`DELETE FROM ${safeTableName} WHERE id = ?`, [rowId]);
-                        console.log(`[D1SyncProvider] LWW: Applied server delete for ${tableName}:${rowId}`);
-                    }
-                    else {
-                        console.log(`[D1SyncProvider] LWW: Skipped server delete (local is newer) for ${tableName}:${rowId}`);
-                    }
-                    continue;
-                }
-                // Check local record timestamp for LWW
-                const local = dash.execute(`SELECT _lastModified FROM ${safeTableName} WHERE id = ?`, [rowId]);
-                const localTimestamp = local.length > 0 ? (local[0]._lastModified || 0) : 0;
-                // Only apply if server is newer (or record doesn't exist locally)
-                if (localTimestamp >= serverTimestamp && local.length > 0) {
-                    console.log(`[D1SyncProvider] LWW: Skipped server change (local is newer) for ${tableName}:${rowId}`);
-                    continue;
-                }
-                // Get column names from the change object, excluding internal fields
-                const data = change._data || change;
-                const columns = Object.keys(data).filter(k => !k.startsWith('_'));
-                // Add _lastModified column for tracking
-                if (!columns.includes('_lastModified')) {
-                    columns.push('_lastModified');
-                }
-                const escapedColumns = columns.map(c => escapeIdentifier(c));
-                const placeholders = columns.map(() => '?').join(', ');
-                const values = columns.map(k => {
-                    if (k === '_lastModified')
-                        return serverTimestamp;
-                    const v = data[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 ${safeTableName} (${escapedColumns.join(', ')}) VALUES (${placeholders})`;
-                dash.execute(sql, values);
-                console.log(`[D1SyncProvider] LWW: Applied server change for ${tableName}:${rowId}`);
-            }
-            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;
-    }
-}