@framers/sql-storage-adapter 0.7.2 → 0.7.3

package/dist/cjs/adapters/electron/ipc/channels.js

@@ -0,0 +1,127 @@
+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 channels_exports = {};
+__export(channels_exports, {
+  BACKUP_CHANNELS: () => BACKUP_CHANNELS,
+  BROADCAST_CHANNELS: () => BROADCAST_CHANNELS,
+  DB_CHANNELS: () => DB_CHANNELS,
+  IPC_CHANNELS: () => IPC_CHANNELS,
+  MIGRATION_CHANNELS: () => MIGRATION_CHANNELS,
+  RECOVERY_CHANNELS: () => RECOVERY_CHANNELS,
+  SYNC_CHANNELS: () => SYNC_CHANNELS,
+  TRANSACTION_CHANNELS: () => TRANSACTION_CHANNELS
+});
+module.exports = __toCommonJS(channels_exports);
+const DB_CHANNELS = {
+  /** Execute a mutation (INSERT/UPDATE/DELETE) */
+  RUN: "sql-storage:db:run",
+  /** Get a single row */
+  GET: "sql-storage:db:get",
+  /** Get all matching rows */
+  ALL: "sql-storage:db:all",
+  /** Execute a SQL script */
+  EXEC: "sql-storage:db:exec",
+  /** Execute batch operations */
+  BATCH: "sql-storage:db:batch",
+  /** Open database connection */
+  OPEN: "sql-storage:db:open",
+  /** Close database connection */
+  CLOSE: "sql-storage:db:close",
+  /** Check if database is open */
+  IS_OPEN: "sql-storage:db:is-open",
+  /** Get adapter capabilities */
+  CAPABILITIES: "sql-storage:db:capabilities"
+};
+const TRANSACTION_CHANNELS = {
+  /** Begin a transaction */
+  BEGIN: "sql-storage:transaction:begin",
+  /** Commit current transaction */
+  COMMIT: "sql-storage:transaction:commit",
+  /** Rollback current transaction */
+  ROLLBACK: "sql-storage:transaction:rollback",
+  /** Execute operation within transaction context */
+  EXECUTE: "sql-storage:transaction:execute"
+};
+const SYNC_CHANNELS = {
+  /** Get sync status */
+  STATUS: "sql-storage:sync:status",
+  /** Trigger manual sync */
+  TRIGGER: "sql-storage:sync:trigger",
+  /** Sync progress updates (main -> renderer) */
+  PROGRESS: "sql-storage:sync:progress",
+  /** Sync completed (main -> renderer) */
+  COMPLETE: "sql-storage:sync:complete",
+  /** Sync error (main -> renderer) */
+  ERROR: "sql-storage:sync:error"
+};
+const BACKUP_CHANNELS = {
+  /** Trigger cloud backup */
+  TRIGGER: "sql-storage:backup:trigger",
+  /** Backup progress (main -> renderer) */
+  PROGRESS: "sql-storage:backup:progress",
+  /** Backup completed (main -> renderer) */
+  COMPLETE: "sql-storage:backup:complete",
+  /** Restore from backup */
+  RESTORE: "sql-storage:backup:restore",
+  /** List available backups */
+  LIST: "sql-storage:backup:list"
+};
+const RECOVERY_CHANNELS = {
+  /** Run integrity check */
+  CHECK_INTEGRITY: "sql-storage:recovery:check-integrity",
+  /** Trigger WAL checkpoint */
+  WAL_CHECKPOINT: "sql-storage:recovery:wal-checkpoint",
+  /** Repair database */
+  REPAIR: "sql-storage:recovery:repair"
+};
+const MIGRATION_CHANNELS = {
+  /** Run pending migrations */
+  RUN: "sql-storage:migration:run",
+  /** Get migration status */
+  STATUS: "sql-storage:migration:status",
+  /** Rollback last migration */
+  ROLLBACK: "sql-storage:migration:rollback"
+};
+const BROADCAST_CHANNELS = {
+  /** Database change notification */
+  DB_CHANGE: "sql-storage:broadcast:db-change",
+  /** Connection state change */
+  CONNECTION_STATE: "sql-storage:broadcast:connection-state",
+  /** Error notification */
+  ERROR: "sql-storage:broadcast:error"
+};
+const IPC_CHANNELS = {
+  db: DB_CHANNELS,
+  transaction: TRANSACTION_CHANNELS,
+  sync: SYNC_CHANNELS,
+  backup: BACKUP_CHANNELS,
+  recovery: RECOVERY_CHANNELS,
+  migration: MIGRATION_CHANNELS,
+  broadcast: BROADCAST_CHANNELS
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKUP_CHANNELS,
+  BROADCAST_CHANNELS,
+  DB_CHANNELS,
+  IPC_CHANNELS,
+  MIGRATION_CHANNELS,
+  RECOVERY_CHANNELS,
+  SYNC_CHANNELS,
+  TRANSACTION_CHANNELS
+});

package/dist/cjs/adapters/electron/ipc/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * IPC Module for Electron SQL Storage Adapter.
+ *
+ * Provides type-safe IPC communication between main and renderer processes.
+ *
+ * @packageDocumentation
+ */
+export * from './channels.js';
+export * from './types.js';
+export { IpcProtocolManager, protocolManager, initializeIpcProtocol, disposeIpcProtocol, } from './protocol.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/adapters/electron/ipc/index.js

@@ -0,0 +1,38 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ipc_exports = {};
+__export(ipc_exports, {
+  IpcProtocolManager: () => import_protocol.IpcProtocolManager,
+  disposeIpcProtocol: () => import_protocol.disposeIpcProtocol,
+  initializeIpcProtocol: () => import_protocol.initializeIpcProtocol,
+  protocolManager: () => import_protocol.protocolManager
+});
+module.exports = __toCommonJS(ipc_exports);
+__reExport(ipc_exports, require("./channels.js"), module.exports);
+__reExport(ipc_exports, require("./types.js"), module.exports);
+var import_protocol = require("./protocol.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IpcProtocolManager,
+  disposeIpcProtocol,
+  initializeIpcProtocol,
+  protocolManager,
+  ...require("./channels.js"),
+  ...require("./types.js")
+});

package/dist/cjs/adapters/electron/ipc/protocol.d.ts

@@ -0,0 +1,78 @@
+/**
+ * IPC Protocol Handlers for Electron SQL Storage Adapter.
+ *
+ * Registers IPC handlers in the main process to handle database
+ * operations from renderer processes. Ensures type-safe communication
+ * and proper error handling.
+ */
+import type { StorageAdapter } from '../../../core/contracts/index.js';
+/**
+ * IPC Protocol Manager.
+ *
+ * Manages IPC communication between main and renderer processes
+ * for database operations. Handles request routing, error handling,
+ * and change broadcasting.
+ */
+export declare class IpcProtocolManager {
+    private adapter;
+    private activeTransactions;
+    private handlersRegistered;
+    /**
+     * Initialize the protocol manager with a storage adapter.
+     */
+    initialize(adapter: StorageAdapter): void;
+    /**
+     * Register all IPC handlers.
+     */
+    private registerHandlers;
+    /**
+     * Unregister all IPC handlers.
+     */
+    dispose(): void;
+    private handleOpen;
+    private handleClose;
+    private handleIsOpen;
+    private handleCapabilities;
+    private handleRun;
+    private handleGet;
+    private handleAll;
+    private handleExec;
+    private handleBatch;
+    private handleTransactionBegin;
+    private handleTransactionCommit;
+    private handleTransactionRollback;
+    private handleTransactionExecute;
+    /**
+     * Wrap handler with error handling and response formatting.
+     */
+    private wrapHandler;
+    /**
+     * Format error for IPC response.
+     */
+    private formatError;
+    /**
+     * Broadcast database change to all windows except sender.
+     */
+    private broadcastDbChange;
+    /**
+     * Detect mutation type from SQL statement.
+     */
+    private detectMutationType;
+    /**
+     * Extract table names from SQL statement.
+     */
+    private extractTables;
+}
+/**
+ * Singleton protocol manager instance.
+ */
+export declare const protocolManager: IpcProtocolManager;
+/**
+ * Initialize IPC protocol with the given adapter.
+ */
+export declare function initializeIpcProtocol(adapter: StorageAdapter): void;
+/**
+ * Dispose IPC protocol handlers.
+ */
+export declare function disposeIpcProtocol(): void;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/cjs/adapters/electron/ipc/protocol.js

@@ -0,0 +1,341 @@
+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 protocol_exports = {};
+__export(protocol_exports, {
+  IpcProtocolManager: () => IpcProtocolManager,
+  disposeIpcProtocol: () => disposeIpcProtocol,
+  initializeIpcProtocol: () => initializeIpcProtocol,
+  protocolManager: () => protocolManager
+});
+module.exports = __toCommonJS(protocol_exports);
+var import_electron = require("electron");
+var import_channels = require("./channels.js");
+class IpcProtocolManager {
+  constructor() {
+    this.adapter = null;
+    this.activeTransactions = /* @__PURE__ */ new Map();
+    this.handlersRegistered = false;
+  }
+  /**
+   * Initialize the protocol manager with a storage adapter.
+   */
+  initialize(adapter) {
+    this.adapter = adapter;
+    this.registerHandlers();
+  }
+  /**
+   * Register all IPC handlers.
+   */
+  registerHandlers() {
+    if (this.handlersRegistered) {
+      console.warn("[IpcProtocol] Handlers already registered");
+      return;
+    }
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.OPEN, this.handleOpen.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.CLOSE, this.handleClose.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.IS_OPEN, this.handleIsOpen.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.CAPABILITIES, this.handleCapabilities.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.RUN, this.handleRun.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.GET, this.handleGet.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.ALL, this.handleAll.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.EXEC, this.handleExec.bind(this));
+    import_electron.ipcMain.handle(import_channels.DB_CHANNELS.BATCH, this.handleBatch.bind(this));
+    import_electron.ipcMain.handle(import_channels.TRANSACTION_CHANNELS.BEGIN, this.handleTransactionBegin.bind(this));
+    import_electron.ipcMain.handle(import_channels.TRANSACTION_CHANNELS.COMMIT, this.handleTransactionCommit.bind(this));
+    import_electron.ipcMain.handle(import_channels.TRANSACTION_CHANNELS.ROLLBACK, this.handleTransactionRollback.bind(this));
+    import_electron.ipcMain.handle(import_channels.TRANSACTION_CHANNELS.EXECUTE, this.handleTransactionExecute.bind(this));
+    this.handlersRegistered = true;
+  }
+  /**
+   * Unregister all IPC handlers.
+   */
+  dispose() {
+    if (!this.handlersRegistered)
+      return;
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.OPEN);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.CLOSE);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.IS_OPEN);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.CAPABILITIES);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.RUN);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.GET);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.ALL);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.EXEC);
+    import_electron.ipcMain.removeHandler(import_channels.DB_CHANNELS.BATCH);
+    import_electron.ipcMain.removeHandler(import_channels.TRANSACTION_CHANNELS.BEGIN);
+    import_electron.ipcMain.removeHandler(import_channels.TRANSACTION_CHANNELS.COMMIT);
+    import_electron.ipcMain.removeHandler(import_channels.TRANSACTION_CHANNELS.ROLLBACK);
+    import_electron.ipcMain.removeHandler(import_channels.TRANSACTION_CHANNELS.EXECUTE);
+    this.handlersRegistered = false;
+  }
+  // ============================================================================
+  // Database Operation Handlers
+  // ============================================================================
+  async handleOpen(_event, request) {
+    return this.wrapHandler(request, async () => {
+      await this.adapter.open(request.payload.options);
+    });
+  }
+  async handleClose(_event, request) {
+    return this.wrapHandler(request, async () => {
+      await this.adapter.close();
+    });
+  }
+  async handleIsOpen(_event, request) {
+    return this.wrapHandler(request, async () => {
+      if ("isOpen" in this.adapter && typeof this.adapter.isOpen === "function") {
+        return this.adapter.isOpen();
+      }
+      try {
+        await this.adapter.get("SELECT 1");
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+  async handleCapabilities(_event, request) {
+    return this.wrapHandler(request, async () => {
+      return Array.from(this.adapter.capabilities);
+    });
+  }
+  async handleRun(event, request) {
+    return this.wrapHandler(request, async () => {
+      const result = await this.adapter.run(request.payload.statement, request.payload.parameters);
+      this.broadcastDbChange(event, {
+        type: this.detectMutationType(request.payload.statement),
+        tables: this.extractTables(request.payload.statement),
+        changes: result.changes,
+        timestamp: Date.now(),
+        sourceWindowId: import_electron.BrowserWindow.fromWebContents(event.sender)?.id
+      });
+      return result;
+    });
+  }
+  async handleGet(_event, request) {
+    return this.wrapHandler(request, async () => {
+      return this.adapter.get(request.payload.statement, request.payload.parameters);
+    });
+  }
+  async handleAll(_event, request) {
+    return this.wrapHandler(request, async () => {
+      return this.adapter.all(request.payload.statement, request.payload.parameters);
+    });
+  }
+  async handleExec(event, request) {
+    return this.wrapHandler(request, async () => {
+      await this.adapter.exec(request.payload.script);
+      this.broadcastDbChange(event, {
+        type: "transaction",
+        tables: [],
+        changes: 0,
+        timestamp: Date.now(),
+        sourceWindowId: import_electron.BrowserWindow.fromWebContents(event.sender)?.id
+      });
+    });
+  }
+  async handleBatch(event, request) {
+    return this.wrapHandler(request, async () => {
+      if (!this.adapter.batch) {
+        throw new Error("Batch operations not supported by this adapter");
+      }
+      const result = await this.adapter.batch(request.payload.operations);
+      this.broadcastDbChange(event, {
+        type: "transaction",
+        tables: request.payload.operations.flatMap((op) => this.extractTables(op.statement)),
+        changes: result.successful,
+        timestamp: Date.now(),
+        sourceWindowId: import_electron.BrowserWindow.fromWebContents(event.sender)?.id
+      });
+      return result;
+    });
+  }
+  // ============================================================================
+  // Transaction Handlers
+  // ============================================================================
+  async handleTransactionBegin(event, request) {
+    return this.wrapHandler(request, async () => {
+      const transactionId = `trx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const windowId = import_electron.BrowserWindow.fromWebContents(event.sender)?.id ?? 0;
+      await this.adapter.exec("BEGIN IMMEDIATE");
+      const context = {
+        transactionId,
+        active: true,
+        startedAt: Date.now()
+      };
+      this.activeTransactions.set(transactionId, {
+        id: transactionId,
+        startedAt: context.startedAt,
+        windowId
+      });
+      return context;
+    });
+  }
+  async handleTransactionCommit(event, request) {
+    return this.wrapHandler(request, async () => {
+      const trx = this.activeTransactions.get(request.payload.transactionId);
+      if (!trx) {
+        throw new Error(`Transaction ${request.payload.transactionId} not found`);
+      }
+      await this.adapter.exec("COMMIT");
+      this.activeTransactions.delete(request.payload.transactionId);
+      this.broadcastDbChange(event, {
+        type: "transaction",
+        tables: [],
+        changes: 0,
+        timestamp: Date.now(),
+        sourceWindowId: import_electron.BrowserWindow.fromWebContents(event.sender)?.id
+      });
+    });
+  }
+  async handleTransactionRollback(_event, request) {
+    return this.wrapHandler(request, async () => {
+      const trx = this.activeTransactions.get(request.payload.transactionId);
+      if (!trx) {
+        throw new Error(`Transaction ${request.payload.transactionId} not found`);
+      }
+      await this.adapter.exec("ROLLBACK");
+      this.activeTransactions.delete(request.payload.transactionId);
+    });
+  }
+  async handleTransactionExecute(_event, request) {
+    return this.wrapHandler(request, async () => {
+      const trx = this.activeTransactions.get(request.payload.transactionId);
+      if (!trx) {
+        throw new Error(`Transaction ${request.payload.transactionId} not found`);
+      }
+      const { statement, parameters } = request.payload.operation;
+      const upperStatement = statement.trim().toUpperCase();
+      if (upperStatement.startsWith("SELECT")) {
+        return this.adapter.all(statement, parameters);
+      } else {
+        return this.adapter.run(statement, parameters);
+      }
+    });
+  }
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+  /**
+   * Wrap handler with error handling and response formatting.
+   */
+  async wrapHandler(request, handler) {
+    const startTime = Date.now();
+    if (!this.adapter) {
+      return {
+        messageId: request.messageId,
+        success: false,
+        error: this.formatError(new Error("Adapter not initialized")),
+        duration: Date.now() - startTime
+      };
+    }
+    try {
+      const data = await handler();
+      return {
+        messageId: request.messageId,
+        success: true,
+        data,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        messageId: request.messageId,
+        success: false,
+        error: this.formatError(error),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Format error for IPC response.
+   */
+  formatError(error) {
+    if (error instanceof Error) {
+      return {
+        code: error.name || "ERROR",
+        message: error.message,
+        stack: process.env.NODE_ENV === "development" ? error.stack : void 0,
+        cause: error.cause
+      };
+    }
+    return {
+      code: "UNKNOWN_ERROR",
+      message: String(error)
+    };
+  }
+  /**
+   * Broadcast database change to all windows except sender.
+   */
+  broadcastDbChange(event, change) {
+    const senderWindow = import_electron.BrowserWindow.fromWebContents(event.sender);
+    const allWindows = import_electron.BrowserWindow.getAllWindows();
+    for (const win of allWindows) {
+      if (win.id !== senderWindow?.id && !win.isDestroyed()) {
+        win.webContents.send(import_channels.BROADCAST_CHANNELS.DB_CHANGE, change);
+      }
+    }
+  }
+  /**
+   * Detect mutation type from SQL statement.
+   */
+  detectMutationType(statement) {
+    const upper = statement.trim().toUpperCase();
+    if (upper.startsWith("INSERT"))
+      return "insert";
+    if (upper.startsWith("UPDATE"))
+      return "update";
+    if (upper.startsWith("DELETE"))
+      return "delete";
+    return "transaction";
+  }
+  /**
+   * Extract table names from SQL statement.
+   */
+  extractTables(statement) {
+    const tables = [];
+    const patterns = [
+      /FROM\s+([^\s,;(]+)/gi,
+      /INSERT\s+INTO\s+([^\s(]+)/i,
+      /UPDATE\s+([^\s]+)/i,
+      /DELETE\s+FROM\s+([^\s]+)/i,
+      /JOIN\s+([^\s]+)/gi
+    ];
+    for (const pattern of patterns) {
+      const matches = statement.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1]) {
+          tables.push(match[1].toLowerCase().replace(/["`[\]]/g, ""));
+        }
+      }
+    }
+    return [...new Set(tables)];
+  }
+}
+const protocolManager = new IpcProtocolManager();
+function initializeIpcProtocol(adapter) {
+  protocolManager.initialize(adapter);
+}
+function disposeIpcProtocol() {
+  protocolManager.dispose();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IpcProtocolManager,
+  disposeIpcProtocol,
+  initializeIpcProtocol,
+  protocolManager
+});