@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/core/index.d.ts

@@ -1,12 +1,15 @@
-export { B as BackupManager, a as BackupScheduler } from '../index-hXiis3N-.js';
+export { B as BackupManager, a as BackupScheduler } from '../index-CLdNrcPz.js';
+export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-CFTQ9TSn.js';
 import { S as SQLiteDriver, a as SQLiteConnection } from '../types-BFSsG77t.js';
 export { D as DriverCapabilities, O as OpenOptions, R as RunResult, b as SQLiteStatement } from '../types-BFSsG77t.js';
-import { D as Database } from '../sirannon-B1oTfebD.js';
-export { H as HookDispose, a as HookEvent, b as HookEventContextMap, c as HookHandler, d as HookRegistry, M as MetricsCollector, S as Sirannon, e as SubscribeHookContext } from '../sirannon-B1oTfebD.js';
-import { D as DatabaseOptions, L as LifecycleConfig, P as Params, E as ExecuteResult } from '../types-DtDutWRU.js';
-export { A as AfterQueryHook, e as BackupScheduleOptions, h as BeforeConnectHook, f as BeforeQueryHook, B as BeforeSubscribeHook, c as CDCMetrics, k as ChangeEvent, l as ChangeOperation, m as ClientOptions, C as ConnectionHookContext, b as ConnectionMetrics, n as CorsOptions, j as DatabaseCloseHook, i as DatabaseOpenHook, H as HookConfig, M as MetricsConfig, O as OnRequestHook, Q as QueryHookContext, a as QueryMetrics, R as RequestContext, o as RequestDenial, S as ServerOptions, g as SirannonOptions, p as Subscription, d as SubscriptionBuilder, W as WSHandlerOptions } from '../types-DtDutWRU.js';
-import { M as Migration, a as MigrationResult, R as RollbackResult } from '../types-DRkJlqex.js';
-export { A as AppliedMigration, b as AppliedMigrationEntry, T as Transaction } from '../types-DRkJlqex.js';
+import { D as Database } from '../database-BVY1GqE7.js';
+export { H as HookDispose, a as HookEvent, b as HookEventContextMap, c as HookHandler, d as HookRegistry, M as MetricsCollector, S as SubscribeHookContext } from '../database-BVY1GqE7.js';
+export { B as BackupError, C as CDCError, a as ConnectionPoolError, D as DatabaseAlreadyExistsError, b as DatabaseNotFoundError, E as ExtensionError, H as HookDeniedError, M as MaxDatabasesError, c as MigrationError, Q as QueryError, R as ReadOnlyError, S as SirannonError, T as TransactionError } from '../errors-C00ed08Q.js';
+import { D as DatabaseOptions, L as LifecycleConfig, P as Params, E as ExecuteResult } from '../types-D-74JiXb.js';
+export { A as AfterQueryHook, m as BackupScheduleOptions, a as BeforeConnectHook, B as BeforeQueryHook, g as BeforeSubscribeHook, j as CDCMetrics, C as ChangeEvent, n as ChangeOperation, o as ClientOptions, p as ClusterReadEndpointInfo, q as ClusterStatusInfo, f as ConnectionHookContext, i as ConnectionMetrics, r as CorsOptions, c as DatabaseCloseHook, b as DatabaseOpenHook, H as HookConfig, M as MetricsConfig, O as OnRequestHook, Q as QueryHookContext, h as QueryMetrics, k as QueryOptions, R as ReadConcern, s as ReadConcernLevel, t as ReplicationStatusInfo, u as RequestContext, v as RequestDenial, w as ServerExecutionTarget, x as ServerExecutionTargetResolver, d as ServerOptions, S as SirannonOptions, y as Subscription, l as SubscriptionBuilder, T as Transaction, e as WSHandlerOptions, W as WriteConcern, z as WriteConcernLevel } from '../types-D-74JiXb.js';
+import { M as Migration, a as MigrationResult, R as RollbackResult } from '../types-BeozgNPr.js';
+export { A as AppliedMigration, b as AppliedMigrationEntry } from '../types-BeozgNPr.js';
+export { S as Sirannon } from '../sirannon-Cd-lK6T0.js';
 
 interface ConnectionPoolOptions {
     driver: SQLiteDriver;
@@ -31,106 +34,6 @@ declare class ConnectionPool {
 
 declare function defineDriver(config: SQLiteDriver): SQLiteDriver;
 
-/**
- * Base class for all sirannon-db errors. Extend this class to create
- * domain-specific errors that carry a machine-readable {@link code}.
- */
-declare class SirannonError extends Error {
-    readonly code: string;
-    constructor(message: string, code: string);
-}
-/**
- * Thrown when a database ID cannot be resolved in the registry.
- * This typically means the database was never opened or has already been closed.
- */
-declare class DatabaseNotFoundError extends SirannonError {
-    constructor(id: string);
-}
-/**
- * Thrown when attempting to register a database with an ID that is already
- * in use. Each database ID must be unique within the registry.
- */
-declare class DatabaseAlreadyExistsError extends SirannonError {
-    constructor(id: string);
-}
-/**
- * Thrown when a write operation is attempted on a database that was opened
- * in read-only mode.
- */
-declare class ReadOnlyError extends SirannonError {
-    constructor(id: string);
-}
-/**
- * Thrown when SQLite fails to execute a statement. The {@link sql} property
- * holds the original SQL string that caused the failure, which is useful for
- * debugging and logging.
- */
-declare class QueryError extends SirannonError {
-    readonly sql: string;
-    constructor(message: string, sql: string);
-}
-/**
- * Thrown when a transaction cannot be committed or is forcibly rolled back.
- * Check the message for the underlying cause.
- */
-declare class TransactionError extends SirannonError {
-    constructor(message: string);
-}
-/**
- * Thrown when a migration step fails. The {@link version} property identifies
- * which schema version triggered the error so the failure can be pinpointed
- * in the migration history.
- */
-declare class MigrationError extends SirannonError {
-    readonly version: number;
-    constructor(message: string, version: number, code?: string);
-}
-/**
- * Thrown when a before-hook explicitly rejects an operation. The optional
- * `reason` string is surfaced in the message so callers can distinguish
- * between different hook policies.
- */
-declare class HookDeniedError extends SirannonError {
-    constructor(hookName: string, reason?: string);
-}
-/**
- * Thrown when the change-data-capture pipeline encounters an unrecoverable
- * error, such as a failed event dispatch or a corrupt change record.
- */
-declare class CDCError extends SirannonError {
-    constructor(message: string);
-}
-/**
- * Thrown when a backup operation fails, whether that is an online backup via
- * the SQLite backup API or a file-level copy.
- */
-declare class BackupError extends SirannonError {
-    constructor(message: string);
-}
-/**
- * Thrown when the connection pool reaches its limit or is configured with
- * invalid parameters such as a minimum size greater than the maximum.
- */
-declare class ConnectionPoolError extends SirannonError {
-    constructor(message: string);
-}
-/**
- * Thrown when opening a new database would exceed the configured cap on
- * concurrently open databases. Close an existing database before opening
- * another one.
- */
-declare class MaxDatabasesError extends SirannonError {
-    constructor(max: number);
-}
-/**
- * Thrown when a native SQLite extension cannot be loaded. The `path` argument
- * is the filesystem path passed to `load_extension`, and the optional `cause`
- * string carries the error detail reported by SQLite.
- */
-declare class ExtensionError extends SirannonError {
-    constructor(path: string, cause?: string);
-}
-
 interface LifecycleCallbacks {
     open: (id: string, path: string, options?: DatabaseOptions) => Promise<Database>;
     close: (id: string) => Promise<void>;
@@ -180,4 +83,4 @@ declare function queryOne<T = Record<string, unknown>>(conn: SQLiteConnection, s
 declare function execute(conn: SQLiteConnection, sql: string, params?: Params): Promise<ExecuteResult>;
 declare function executeBatch(conn: SQLiteConnection, sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
 
-export { BackupError, CDCError, ConnectionPool, ConnectionPoolError, type ConnectionPoolOptions, Database, DatabaseAlreadyExistsError, DatabaseNotFoundError, DatabaseOptions, ExecuteResult, ExtensionError, HookDeniedError, type LifecycleCallbacks, LifecycleConfig, LifecycleManager, MaxDatabasesError, Migration, MigrationError, MigrationResult, MigrationRunner, Params, QueryError, ReadOnlyError, RollbackResult, SQLiteConnection, SQLiteDriver, SirannonError, type TenantResolverOptions, TransactionError, createTenantResolver, defineDriver, execute, executeBatch, query, queryOne, sanitizeTenantId, tenantPath };
+export { ConnectionPool, type ConnectionPoolOptions, Database, DatabaseOptions, ExecuteResult, type LifecycleCallbacks, LifecycleConfig, LifecycleManager, Migration, MigrationResult, MigrationRunner, Params, RollbackResult, SQLiteConnection, SQLiteDriver, type TenantResolverOptions, createTenantResolver, defineDriver, execute, executeBatch, query, queryOne, sanitizeTenantId, tenantPath };

package/dist/core/index.mjs

@@ -1,8 +1,12 @@
-import { SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling } from '../chunk-AX66KWBR.mjs';
+import { SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling } from '../chunk-UTO3ZAFS.mjs';
+export { ChangeTracker } from '../chunk-UTO3ZAFS.mjs';
 export { defineDriver } from '../chunk-74UN4DIE.mjs';
 import { BackupManager, BackupScheduler } from '../chunk-PXKAKK2V.mjs';
 export { BackupManager, BackupScheduler } from '../chunk-PXKAKK2V.mjs';
-import { ConnectionPoolError, QueryError, MigrationError, ReadOnlyError, ExtensionError, SirannonError, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError } from '../chunk-O7BHI3CF.mjs';
+import { Transaction, query, queryOne, execute, executeBatch } from '../chunk-3MCMONVP.mjs';
+export { Transaction, execute, executeBatch, query, queryOne } from '../chunk-3MCMONVP.mjs';
+import '../chunk-GS7T5YMI.mjs';
+import { ConnectionPoolError, MigrationError, ReadOnlyError, SirannonError, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError } from '../chunk-O7BHI3CF.mjs';
 export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError } from '../chunk-O7BHI3CF.mjs';
 
 // src/core/connection-pool.ts
@@ -96,6 +100,81 @@ var ConnectionPool = class _ConnectionPool {
   }
 };
 
+// src/core/cdc/ddl-handler.ts
+var DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
+var DROP_TABLE_RE = /^\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"?([A-Za-z_][A-Za-z0-9_]*)"?\s*;?\s*$/i;
+function isCdcRelevantDdl(sql) {
+  return DDL_PREFIX_RE.test(sql);
+}
+function extractDroppedTable(sql) {
+  const m = DROP_TABLE_RE.exec(sql);
+  return m?.[1] ?? null;
+}
+async function applyDdlSideEffects(tracker, writerConn, sql) {
+  if (tracker.watchedTables.size === 0) {
+    return;
+  }
+  await tracker.refreshAllTriggersUsingConnection(writerConn);
+  const dropped = extractDroppedTable(sql);
+  if (dropped !== null) {
+    await tracker.pruneDroppedTables(writerConn, [dropped]);
+  }
+}
+
+// src/core/cdc/cdc-aware-transaction.ts
+var CdcAwareTransaction = class extends Transaction {
+  constructor(txConn, tracker, state) {
+    super(txConn);
+    this.tracker = tracker;
+    this.state = state;
+    this.txConn = txConn;
+  }
+  txConn;
+  async execute(sql, params) {
+    const isDdl = isCdcRelevantDdl(sql);
+    const result = await super.execute(sql, params);
+    if (!isDdl) {
+      return result;
+    }
+    this.state.sawDdl = true;
+    const dropped = extractDroppedTable(sql);
+    if (dropped !== null) {
+      this.state.droppedTables.push(dropped);
+    }
+    if (this.tracker.watchedTables.size > 0) {
+      await this.tracker.refreshAllTriggersUsingConnection(this.txConn);
+    }
+    return result;
+  }
+};
+
+// src/core/extension-loader.ts
+async function loadExtension(driver, writer, extensionPath) {
+  if (!driver.capabilities.extensions) {
+    throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
+  }
+  if (!extensionPath || extensionPath.includes("\0")) {
+    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
+  }
+  for (let i = 0; i < extensionPath.length; i++) {
+    if (extensionPath.charCodeAt(i) <= 31) {
+      throw new ExtensionError(extensionPath, "Extension path contains control characters");
+    }
+  }
+  const segments = extensionPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
+  }
+  const { resolve } = await import('path');
+  const resolved = resolve(extensionPath);
+  try {
+    const escaped = resolved.replace(/'/g, "''");
+    await writer.exec(`SELECT load_extension('${escaped}')`);
+  } catch (err) {
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
+
 // src/core/hooks/registry.ts
 var HOOK_CONFIG_MAP = {
   onBeforeQuery: "beforeQuery",
@@ -178,118 +257,6 @@ var HookRegistry = class {
   }
 };
 
-// src/core/query-executor.ts
-var STATEMENT_CACHE_CAPACITY = 128;
-var statementCaches = /* @__PURE__ */ new WeakMap();
-async function getStatement(conn, sql) {
-  let cache = statementCaches.get(conn);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    statementCaches.set(conn, cache);
-  }
-  const cached = cache.get(sql);
-  if (cached) {
-    cache.delete(sql);
-    cache.set(sql, cached);
-    return cached;
-  }
-  const pending = conn.prepare(sql);
-  cache.set(sql, pending);
-  if (cache.size > STATEMENT_CACHE_CAPACITY) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) {
-      cache.delete(oldest);
-    }
-  }
-  try {
-    return await pending;
-  } catch (err) {
-    cache.delete(sql);
-    throw err;
-  }
-}
-function bindParams(params) {
-  if (params === void 0) return [];
-  if (Array.isArray(params)) return params;
-  return [params];
-}
-async function query(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    return await stmt.all(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function queryOne(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    return await stmt.get(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function execute(conn, sql, params) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    const result = await stmt.run(...bindParams(params));
-    return {
-      changes: result.changes,
-      lastInsertRowId: result.lastInsertRowId
-    };
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-async function executeBatch(conn, sql, paramsBatch) {
-  try {
-    const stmt = await getStatement(conn, sql);
-    const results = [];
-    for (const params of paramsBatch) {
-      const result = await stmt.run(...bindParams(params));
-      results.push({
-        changes: result.changes,
-        lastInsertRowId: result.lastInsertRowId
-      });
-    }
-    return results;
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-
-// src/core/transaction.ts
-var Transaction = class _Transaction {
-  constructor(conn) {
-    this.conn = conn;
-  }
-  _lastInsertRowId = 0;
-  async query(sql, params) {
-    return query(this.conn, sql, params);
-  }
-  async execute(sql, params) {
-    const result = await execute(this.conn, sql, params);
-    this._lastInsertRowId = result.lastInsertRowId;
-    return result;
-  }
-  async executeBatch(sql, paramsBatch) {
-    const results = await executeBatch(this.conn, sql, paramsBatch);
-    if (results.length > 0) {
-      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
-    }
-    return results;
-  }
-  get lastInsertRowId() {
-    return this._lastInsertRowId;
-  }
-  static async run(conn, fn) {
-    return conn.transaction(async (txConn) => {
-      const tx = new _Transaction(txConn);
-      return fn(tx);
-    });
-  }
-};
-
 // src/core/migrations/runner.ts
 var CREATE_TRACKING_TABLE = `
   CREATE TABLE IF NOT EXISTS _sirannon_migrations (
@@ -488,9 +455,9 @@ var Database = class _Database {
     });
     return new _Database(id, path, pool, driver, options, internals);
   }
-  async query(sql, params) {
+  async query(sql, params, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql, params);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const reader = this.pool.acquireReader();
@@ -505,9 +472,9 @@ var Database = class _Database {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  async queryOne(sql, params) {
+  async queryOne(sql, params, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql, params);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const reader = this.pool.acquireReader();
@@ -522,39 +489,37 @@ var Database = class _Database {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  async execute(sql, params) {
+  async execute(sql, params, options) {
     this.ensureOpen();
     if (this.readOnly) throw new ReadOnlyError(this.id);
-    this.fireBeforeQueryHooks(sql, params);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const writer = this.pool.acquireWriter();
-      if (this.metricsCollector) {
-        return await this.metricsCollector.trackQuery(() => execute(writer, sql, params), {
-          databaseId: this.id,
-          sql
-        });
-      }
-      return await execute(writer, sql, params);
+      const result = this.metricsCollector ? await this.metricsCollector.trackQuery(() => execute(writer, sql, params), {
+        databaseId: this.id,
+        sql
+      }) : await execute(writer, sql, params);
+      await this.maybeApplyDdlSideEffects(writer, sql);
+      return result;
     } finally {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  async executeBatch(sql, paramsBatch) {
+  async executeBatch(sql, paramsBatch, options) {
     this.ensureOpen();
     if (this.readOnly) throw new ReadOnlyError(this.id);
-    this.fireBeforeQueryHooks(sql);
+    this.fireBeforeQueryHooks(sql, void 0, options);
     const start = performance.now();
     try {
       const writer = this.pool.acquireWriter();
       const batchFn = () => writer.transaction(async (txConn) => executeBatch(txConn, sql, paramsBatch));
-      if (this.metricsCollector) {
-        return await this.metricsCollector.trackQuery(batchFn, {
-          databaseId: this.id,
-          sql
-        });
-      }
-      return await batchFn();
+      const results = this.metricsCollector ? await this.metricsCollector.trackQuery(batchFn, {
+        databaseId: this.id,
+        sql
+      }) : await batchFn();
+      await this.maybeApplyDdlSideEffects(writer, sql);
+      return results;
     } finally {
       this.fireAfterQueryHooks(sql, void 0, performance.now() - start);
     }
@@ -563,7 +528,25 @@ var Database = class _Database {
     this.ensureOpen();
     if (this.readOnly) throw new ReadOnlyError(this.id);
     const writer = this.pool.acquireWriter();
-    return Transaction.run(writer, fn);
+    const tracker = this.changeTracker;
+    if (!tracker) {
+      return Transaction.run(writer, fn);
+    }
+    const state = { sawDdl: false, droppedTables: [] };
+    const result = await writer.transaction(async (txConn) => {
+      const tx = new CdcAwareTransaction(txConn, tracker, state);
+      return fn(tx);
+    });
+    if (state.sawDdl && state.droppedTables.length > 0) {
+      await tracker.pruneDroppedTables(writer, state.droppedTables);
+    }
+    return result;
+  }
+  async maybeApplyDdlSideEffects(writer, sql) {
+    const tracker = this.changeTracker;
+    if (!tracker) return;
+    if (!isCdcRelevantDdl(sql)) return;
+    await applyDdlSideEffects(tracker, writer, sql);
   }
   async watch(table) {
     this.ensureOpen();
@@ -614,30 +597,8 @@ var Database = class _Database {
   }
   async loadExtension(extensionPath) {
     this.ensureOpen();
-    if (!this.driver.capabilities.extensions) {
-      throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
-    }
-    if (!extensionPath || extensionPath.includes("\0")) {
-      throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
-    }
-    for (let i = 0; i < extensionPath.length; i++) {
-      if (extensionPath.charCodeAt(i) <= 31) {
-        throw new ExtensionError(extensionPath, "Extension path contains control characters");
-      }
-    }
-    const segments = extensionPath.split(/[/\\]/);
-    if (segments.includes("..")) {
-      throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
-    }
-    const { resolve } = await import('path');
-    const resolved = resolve(extensionPath);
-    try {
-      const writer = this.pool.acquireWriter();
-      const escaped = resolved.replace(/'/g, "''");
-      await writer.exec(`SELECT load_extension('${escaped}')`);
-    } catch (err) {
-      throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
-    }
+    const writer = this.pool.acquireWriter();
+    await loadExtension(this.driver, writer, extensionPath);
   }
   onBeforeQuery(hook) {
     this.hookRegistry.register("beforeQuery", hook);
@@ -707,11 +668,17 @@ var Database = class _Database {
       this.stopCdcPolling = null;
     }
   }
-  fireBeforeQueryHooks(sql, params) {
+  fireBeforeQueryHooks(sql, params, options) {
     const hasParent = this.parentHooks?.has("beforeQuery");
     const hasLocal = this.hookRegistry.has("beforeQuery");
     if (!hasParent && !hasLocal) return;
-    const ctx = { databaseId: this.id, sql, params };
+    const ctx = {
+      databaseId: this.id,
+      sql,
+      params,
+      writeConcern: options?.writeConcern,
+      readConcern: options?.readConcern
+    };
     this.parentHooks?.invokeSync("beforeQuery", ctx);
     this.hookRegistry.invokeSync("beforeQuery", ctx);
   }
@@ -745,12 +712,11 @@ var LifecycleManager = class {
     const timeout = config.idleTimeout;
     if (timeout && timeout > 0) {
       const interval = Math.min(Math.max(Math.floor(timeout / 2), 100), 6e4);
-      this.idleTimer = setInterval(async () => {
+      const timer = setInterval(async () => {
         await this.#runIdleCheck();
       }, interval);
-      if (typeof this.idleTimer === "object" && "unref" in this.idleTimer) {
-        this.idleTimer.unref();
-      }
+      timer.unref?.();
+      this.idleTimer = timer;
     }
   }
   async resolve(id) {
@@ -1103,4 +1069,4 @@ var Sirannon = class {
   }
 };
 
-export { ConnectionPool, Database, HookRegistry, LifecycleManager, MetricsCollector, MigrationRunner, Sirannon, Transaction, createTenantResolver, execute, executeBatch, query, queryOne, sanitizeTenantId, tenantPath };
+export { ConnectionPool, Database, HookRegistry, LifecycleManager, MetricsCollector, MigrationRunner, Sirannon, createTenantResolver, sanitizeTenantId, tenantPath };

package/dist/{sirannon-B1oTfebD.d.ts → database-BVY1GqE7.d.ts}

@@ -1,6 +1,6 @@
 import { S as SQLiteDriver } from './types-BFSsG77t.js';
-import { Q as QueryHookContext, C as ConnectionHookContext, B as BeforeSubscribeHook, H as HookConfig, M as MetricsConfig, a as QueryMetrics, b as ConnectionMetrics, c as CDCMetrics, D as DatabaseOptions, P as Params, E as ExecuteResult, d as SubscriptionBuilder, e as BackupScheduleOptions, f as BeforeQueryHook, A as AfterQueryHook, g as SirannonOptions, h as BeforeConnectHook, i as DatabaseOpenHook, j as DatabaseCloseHook } from './types-DtDutWRU.js';
-import { T as Transaction, M as Migration, a as MigrationResult, R as RollbackResult } from './types-DRkJlqex.js';
+import { Q as QueryHookContext, f as ConnectionHookContext, g as BeforeSubscribeHook, H as HookConfig, M as MetricsConfig, h as QueryMetrics, i as ConnectionMetrics, j as CDCMetrics, D as DatabaseOptions, P as Params, k as QueryOptions, E as ExecuteResult, T as Transaction, l as SubscriptionBuilder, m as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-D-74JiXb.js';
+import { M as Migration, a as MigrationResult, R as RollbackResult } from './types-BeozgNPr.js';
 
 type HookEvent = 'beforeQuery' | 'afterQuery' | 'beforeConnect' | 'databaseOpen' | 'databaseClose' | 'beforeSubscribe';
 type SubscribeHookContext = Parameters<BeforeSubscribeHook>[0];
@@ -64,11 +64,12 @@ declare class Database {
     private readonly scheduledBackupCancellers;
     private constructor();
     static create(id: string, path: string, driver: SQLiteDriver, options?: DatabaseOptions, internals?: DatabaseInternals): Promise<Database>;
-    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
-    queryOne<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T | undefined>;
-    execute(sql: string, params?: Params): Promise<ExecuteResult>;
-    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
+    queryOne<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T | undefined>;
+    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
     transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
+    private maybeApplyDdlSideEffects;
     watch(table: string): Promise<void>;
     unwatch(table: string): Promise<void>;
     on(table: string): SubscriptionBuilder;
@@ -91,30 +92,4 @@ declare class Database {
     private fireAfterQueryHooks;
 }
 
-declare class Sirannon {
-    readonly options: SirannonOptions;
-    private readonly dbs;
-    private readonly opening;
-    private _shutdown;
-    private readonly _driver;
-    private readonly hookRegistry;
-    private readonly metricsCollector;
-    private readonly lifecycleManager;
-    constructor(options: SirannonOptions);
-    get driver(): SQLiteDriver;
-    open(id: string, path: string, options?: DatabaseOptions): Promise<Database>;
-    close(id: string): Promise<void>;
-    get(id: string): Database | undefined;
-    resolve(id: string): Promise<Database | undefined>;
-    has(id: string): boolean;
-    databases(): Map<string, Database>;
-    shutdown(): Promise<void>;
-    onBeforeQuery(hook: BeforeQueryHook): void;
-    onAfterQuery(hook: AfterQueryHook): void;
-    onBeforeConnect(hook: BeforeConnectHook): void;
-    onDatabaseOpen(hook: DatabaseOpenHook): void;
-    onDatabaseClose(hook: DatabaseCloseHook): void;
-    private ensureRunning;
-}
-
-export { Database as D, type HookDispose as H, MetricsCollector as M, Sirannon as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d, type SubscribeHookContext as e };
+export { Database as D, type HookDispose as H, MetricsCollector as M, type SubscribeHookContext as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d };