@framers/sql-storage-adapter 0.7.2 → 0.7.4

package/dist/cjs/adapters/electron/preload.js

@@ -0,0 +1,233 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var preload_exports = {};
+__export(preload_exports, {
+  sqlStorageApi: () => sqlStorageApi
+});
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+var import_channels = require("./ipc/channels.js");
+function generateMessageId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function createRequest(payload) {
+  return {
+    messageId: generateMessageId(),
+    payload,
+    timestamp: Date.now()
+  };
+}
+async function invokeIpc(channel, payload) {
+  const request = createRequest(payload);
+  const response = await import_electron.ipcRenderer.invoke(channel, request);
+  if (!response.success) {
+    const error = new Error(response.error?.message ?? "Unknown IPC error");
+    error.name = response.error?.code ?? "IpcError";
+    throw error;
+  }
+  return response.data;
+}
+const sqlStorageApi = {
+  // ============================================================================
+  // Database Operations
+  // ============================================================================
+  /**
+   * Open the database connection.
+   */
+  async open(options) {
+    const payload = { options };
+    await invokeIpc(import_channels.DB_CHANNELS.OPEN, payload);
+  },
+  /**
+   * Close the database connection.
+   */
+  async close() {
+    await invokeIpc(import_channels.DB_CHANNELS.CLOSE, void 0);
+  },
+  /**
+   * Check if the database is open.
+   */
+  async isOpen() {
+    return invokeIpc(import_channels.DB_CHANNELS.IS_OPEN, void 0);
+  },
+  /**
+   * Get adapter capabilities.
+   */
+  async getCapabilities() {
+    return invokeIpc(import_channels.DB_CHANNELS.CAPABILITIES, void 0);
+  },
+  /**
+   * Execute a mutation statement (INSERT, UPDATE, DELETE).
+   */
+  async run(statement, parameters) {
+    const payload = { statement, parameters };
+    return invokeIpc(import_channels.DB_CHANNELS.RUN, payload);
+  },
+  /**
+   * Get a single row.
+   */
+  async get(statement, parameters) {
+    const payload = { statement, parameters };
+    return invokeIpc(import_channels.DB_CHANNELS.GET, payload);
+  },
+  /**
+   * Get all matching rows.
+   */
+  async all(statement, parameters) {
+    const payload = { statement, parameters };
+    return invokeIpc(import_channels.DB_CHANNELS.ALL, payload);
+  },
+  /**
+   * Execute a SQL script.
+   */
+  async exec(script) {
+    const payload = { script };
+    await invokeIpc(import_channels.DB_CHANNELS.EXEC, payload);
+  },
+  /**
+   * Execute batch operations.
+   */
+  async batch(operations) {
+    const payload = { operations };
+    return invokeIpc(import_channels.DB_CHANNELS.BATCH, payload);
+  },
+  // ============================================================================
+  // Transaction Operations
+  // ============================================================================
+  /**
+   * Begin a transaction.
+   */
+  async beginTransaction() {
+    return invokeIpc(import_channels.TRANSACTION_CHANNELS.BEGIN, void 0);
+  },
+  /**
+   * Commit a transaction.
+   */
+  async commitTransaction(transactionId) {
+    await invokeIpc(import_channels.TRANSACTION_CHANNELS.COMMIT, { transactionId });
+  },
+  /**
+   * Rollback a transaction.
+   */
+  async rollbackTransaction(transactionId) {
+    await invokeIpc(import_channels.TRANSACTION_CHANNELS.ROLLBACK, { transactionId });
+  },
+  /**
+   * Execute an operation within a transaction.
+   */
+  async executeInTransaction(transactionId, statement, parameters) {
+    const payload = {
+      transactionId,
+      operation: { statement, parameters }
+    };
+    return invokeIpc(import_channels.TRANSACTION_CHANNELS.EXECUTE, payload);
+  },
+  /**
+   * Execute a callback within a transaction (convenience method).
+   * Automatically handles begin/commit/rollback.
+   */
+  async transaction(fn) {
+    const ctx = await this.beginTransaction();
+    const trx = {
+      run: async (statement, parameters) => {
+        const result = await this.executeInTransaction(ctx.transactionId, statement, parameters);
+        return result;
+      },
+      get: async (statement, parameters) => {
+        const result = await this.executeInTransaction(ctx.transactionId, statement, parameters);
+        return Array.isArray(result) ? result[0] ?? null : null;
+      },
+      all: async (statement, parameters) => {
+        const result = await this.executeInTransaction(ctx.transactionId, statement, parameters);
+        return Array.isArray(result) ? result : [];
+      }
+    };
+    try {
+      const result = await fn(trx);
+      await this.commitTransaction(ctx.transactionId);
+      return result;
+    } catch (error) {
+      await this.rollbackTransaction(ctx.transactionId).catch(() => {
+      });
+      throw error;
+    }
+  },
+  // ============================================================================
+  // Sync Operations
+  // ============================================================================
+  /**
+   * Get sync status.
+   */
+  async getSyncStatus() {
+    return invokeIpc(import_channels.SYNC_CHANNELS.STATUS, void 0);
+  },
+  /**
+   * Trigger manual sync.
+   */
+  async triggerSync() {
+    await invokeIpc(import_channels.SYNC_CHANNELS.TRIGGER, void 0);
+  },
+  // ============================================================================
+  // Event Subscriptions
+  // ============================================================================
+  /**
+   * Subscribe to database change events.
+   */
+  onDatabaseChange(callback) {
+    const handler = (_, event) => {
+      callback(event);
+    };
+    import_electron.ipcRenderer.on(import_channels.BROADCAST_CHANNELS.DB_CHANGE, handler);
+    return () => import_electron.ipcRenderer.removeListener(import_channels.BROADCAST_CHANNELS.DB_CHANGE, handler);
+  },
+  /**
+   * Subscribe to sync progress events.
+   */
+  onSyncProgress(callback) {
+    const handler = (_, progress) => {
+      callback(progress);
+    };
+    import_electron.ipcRenderer.on(import_channels.SYNC_CHANNELS.PROGRESS, handler);
+    return () => import_electron.ipcRenderer.removeListener(import_channels.SYNC_CHANNELS.PROGRESS, handler);
+  },
+  /**
+   * Subscribe to sync complete events.
+   */
+  onSyncComplete(callback) {
+    const handler = () => callback();
+    import_electron.ipcRenderer.on(import_channels.SYNC_CHANNELS.COMPLETE, handler);
+    return () => import_electron.ipcRenderer.removeListener(import_channels.SYNC_CHANNELS.COMPLETE, handler);
+  },
+  /**
+   * Subscribe to sync error events.
+   */
+  onSyncError(callback) {
+    const handler = (_, error) => {
+      callback(new Error(error.message));
+    };
+    import_electron.ipcRenderer.on(import_channels.SYNC_CHANNELS.ERROR, handler);
+    return () => import_electron.ipcRenderer.removeListener(import_channels.SYNC_CHANNELS.ERROR, handler);
+  }
+};
+if (import_electron.contextBridge) {
+  import_electron.contextBridge.exposeInMainWorld("sqlStorage", sqlStorageApi);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sqlStorageApi
+});

package/dist/cjs/adapters/electron/recovery/corruptionDetector.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Database Corruption Detection and Auto-Repair.
+ *
+ * Provides integrity checking and automatic repair capabilities
+ * for SQLite databases. Detects corruption early and attempts
+ * recovery before data loss occurs.
+ *
+ * ## Detection Methods
+ * - SQLite integrity_check PRAGMA
+ * - Quick check (faster, less thorough)
+ * - Foreign key constraint validation
+ * - Index integrity verification
+ *
+ * ## Repair Strategies
+ * - VACUUM: Rebuilds entire database
+ * - REINDEX: Rebuilds all indexes
+ * - Export/Import: Last resort recovery
+ *
+ * @example
+ * ```typescript
+ * const detector = new CorruptionDetector(adapter, {
+ *   checkOnOpen: true,
+ *   autoRepair: true,
+ *   backupBeforeRepair: true,
+ * });
+ *
+ * const result = await detector.runFullCheck();
+ * if (!result.isHealthy) {
+ *   await detector.attemptRepair();
+ * }
+ * ```
+ */
+import type { StorageAdapter } from '../../../core/contracts/index.js';
+/**
+ * Integrity check level.
+ */
+export type IntegrityCheckLevel = 'quick' | 'full' | 'thorough';
+/**
+ * Corruption detection configuration.
+ */
+export interface CorruptionDetectorConfig {
+    /** Run check when database is opened (default: true) */
+    checkOnOpen?: boolean;
+    /** Attempt automatic repair on corruption (default: true) */
+    autoRepair?: boolean;
+    /** Create backup before repair (default: true) */
+    backupBeforeRepair?: boolean;
+    /** Maximum time for integrity check in ms (default: 60000) */
+    checkTimeout?: number;
+    /** Check level (default: 'quick') */
+    defaultCheckLevel?: IntegrityCheckLevel;
+    /** Enable verbose logging (default: false) */
+    verbose?: boolean;
+}
+/**
+ * Single corruption issue.
+ */
+export interface CorruptionIssue {
+    /** Issue type */
+    type: 'data' | 'index' | 'foreign_key' | 'structure' | 'unknown';
+    /** Affected table (if identifiable) */
+    table?: string;
+    /** Detailed message */
+    message: string;
+    /** Severity level */
+    severity: 'warning' | 'error' | 'critical';
+    /** Whether this issue is repairable */
+    repairable: boolean;
+}
+/**
+ * Result of an integrity check.
+ */
+export interface IntegrityCheckResult {
+    /** Whether the database is healthy */
+    isHealthy: boolean;
+    /** Check level performed */
+    level: IntegrityCheckLevel;
+    /** List of issues found */
+    issues: CorruptionIssue[];
+    /** Time taken in milliseconds */
+    durationMs: number;
+    /** Timestamp of check */
+    timestamp: number;
+    /** Pages checked (full check only) */
+    pagesChecked?: number;
+    /** Total database size in bytes */
+    databaseSize?: number;
+}
+/**
+ * Repair strategy.
+ */
+export type RepairStrategy = 'vacuum' | 'reindex' | 'export_import';
+/**
+ * Result of a repair attempt.
+ */
+export interface RepairResult {
+    /** Whether repair was successful */
+    success: boolean;
+    /** Strategy used */
+    strategy: RepairStrategy;
+    /** Issues fixed */
+    issuesFixed: number;
+    /** Issues remaining */
+    issuesRemaining: number;
+    /** Time taken in milliseconds */
+    durationMs: number;
+    /** Backup path (if created) */
+    backupPath?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Database Corruption Detector.
+ *
+ * Detects and repairs SQLite database corruption.
+ */
+export declare class CorruptionDetector {
+    private readonly adapter;
+    private readonly config;
+    private lastCheck;
+    private repairHistory;
+    constructor(adapter: StorageAdapter, config?: CorruptionDetectorConfig);
+    /**
+     * Run a quick integrity check.
+     * Faster but less thorough than full check.
+     */
+    runQuickCheck(): Promise<IntegrityCheckResult>;
+    /**
+     * Run a full integrity check.
+     * Checks all pages and structures.
+     */
+    runFullCheck(): Promise<IntegrityCheckResult>;
+    /**
+     * Run a thorough integrity check.
+     * Includes foreign key and index validation.
+     */
+    runThoroughCheck(): Promise<IntegrityCheckResult>;
+    /**
+     * Run an integrity check at the specified level.
+     */
+    private runCheck;
+    /**
+     * Parse integrity check results into structured issues.
+     */
+    private parseIntegrityResults;
+    /**
+     * Check foreign key constraints.
+     */
+    private checkForeignKeys;
+    /**
+     * Check index integrity.
+     */
+    private checkIndexes;
+    /**
+     * Attempt to repair the database.
+     */
+    attemptRepair(strategy?: RepairStrategy): Promise<RepairResult>;
+    /**
+     * Select the best repair strategy based on issues found.
+     */
+    private selectRepairStrategy;
+    /**
+     * Repair using VACUUM.
+     */
+    private repairWithVacuum;
+    /**
+     * Repair using REINDEX.
+     */
+    private repairWithReindex;
+    /**
+     * Repair using export/import.
+     * This is a last resort that exports all data and recreates the database.
+     */
+    private repairWithExportImport;
+    /**
+     * Create a backup of the database.
+     */
+    private createBackup;
+    /**
+     * Get the last integrity check result.
+     */
+    getLastCheck(): IntegrityCheckResult | null;
+    /**
+     * Get repair history.
+     */
+    getRepairHistory(): RepairResult[];
+    /**
+     * Check if the database appears healthy.
+     */
+    isHealthy(): boolean;
+    /**
+     * Get summary of database health.
+     */
+    getHealthSummary(): {
+        isHealthy: boolean;
+        lastCheckAt: number | null;
+        issueCount: number;
+        repairAttempts: number;
+        successfulRepairs: number;
+    };
+    /**
+     * Log a message if verbose mode is enabled.
+     */
+    private log;
+}
+/**
+ * Create a Corruption Detector.
+ *
+ * @param adapter - Storage adapter to monitor
+ * @param config - Detector configuration
+ * @returns CorruptionDetector instance
+ */
+export declare function createCorruptionDetector(adapter: StorageAdapter, config?: CorruptionDetectorConfig): CorruptionDetector;
+//# sourceMappingURL=corruptionDetector.d.ts.map