@framers/sql-storage-adapter 0.7.1 → 0.7.3

package/dist/cjs/core/contracts/context.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Runtime context and introspection types for storage adapters.
+ *
+ * These types enable runtime inspection of adapter capabilities,
+ * connection state, and performance characteristics without requiring
+ * developers to manually check capability flags.
+ */
+import type { StorageAdapter, StorageCapability } from './index.js';
+import type { PerformanceMetrics } from './extensions.js';
+/**
+ * Type of database connection.
+ */
+export type ConnectionType = 'file' | 'memory' | 'network';
+/**
+ * Database engine identifier.
+ */
+export type DatabaseEngine = 'sqlite' | 'postgres' | 'mysql' | 'sqljs' | 'capacitor' | 'supabase' | 'electron';
+/**
+ * Adapter identifier used by the resolver.
+ */
+export type AdapterKind = 'postgres' | 'better-sqlite3' | 'capacitor' | 'sqljs' | 'indexeddb' | 'supabase' | 'electron-main' | 'electron-renderer';
+/**
+ * Information about the current database connection.
+ */
+export interface ConnectionInfo {
+    /** Type of connection (file-based, in-memory, or network) */
+    type: ConnectionType;
+    /** Database engine being used */
+    engine: DatabaseEngine;
+    /** Engine version (if available) */
+    version?: string;
+    /** File path for file-based databases */
+    filePath?: string;
+    /** Host for network databases */
+    host?: string;
+    /** Database name for network databases */
+    database?: string;
+    /** Whether the connection is read-only */
+    readOnly: boolean;
+    /** When the connection was established */
+    connectedAt?: Date;
+}
+/**
+ * Concurrency model supported by the adapter.
+ */
+export type ConcurrencyModel = 'single' | 'pooled' | 'unlimited';
+/**
+ * Persistence model of the adapter.
+ */
+export type PersistenceModel = 'memory' | 'file' | 'network';
+/**
+ * Performance characteristics of an adapter.
+ */
+export interface PerformanceCharacteristics {
+    /** Concurrency model */
+    concurrency: ConcurrencyModel;
+    /** Persistence model */
+    persistence: PersistenceModel;
+    /** Supported transaction isolation levels */
+    transactionIsolation: string[];
+    /** Whether the adapter uses connection pooling */
+    usesConnectionPool: boolean;
+    /** Whether queries are executed asynchronously */
+    asyncExecution: boolean;
+}
+/**
+ * Adapter-specific limitations and constraints.
+ */
+export interface AdapterLimitations {
+    /** Maximum number of concurrent connections (if applicable) */
+    maxConnections?: number;
+    /** Maximum length of a single SQL statement (in bytes/characters) */
+    maxStatementLength?: number;
+    /** Maximum number of operations in a single batch */
+    maxBatchSize?: number;
+    /** Maximum size of a single parameter value (in bytes) */
+    maxParameterSize?: number;
+    /** Data types supported by this adapter */
+    supportedDataTypes: string[];
+    /** Features that are explicitly not supported */
+    unsupportedFeatures: string[];
+    /** Performance characteristics */
+    performanceCharacteristics: PerformanceCharacteristics;
+    /** Additional adapter-specific constraints */
+    constraints?: Record<string, unknown>;
+}
+/**
+ * Current health and status of the adapter.
+ */
+export interface AdapterStatus {
+    /** Whether the adapter is functioning correctly */
+    healthy: boolean;
+    /** Whether the adapter is currently connected */
+    connected: boolean;
+    /** Last error encountered (if any) */
+    lastError?: Error;
+    /** Timestamp of last successful query */
+    lastQuery?: Date;
+    /** Total number of queries executed */
+    totalQueries: number;
+    /** Total number of errors encountered */
+    errors: number;
+    /** Time since adapter was opened (in milliseconds) */
+    uptime: number;
+    /** Performance metrics (if available) */
+    metrics?: PerformanceMetrics;
+}
+/**
+ * Runtime context providing introspection into the current adapter.
+ *
+ * This interface provides a high-level API for querying adapter
+ * capabilities, connection state, and performance without requiring
+ * manual capability flag checking.
+ *
+ * @example
+ * ```typescript
+ * const context = adapter.context;
+ *
+ * // Simple boolean checks
+ * if (context.supportsBatch) {
+ *   await adapter.batch(operations);
+ * }
+ *
+ * // Get detailed status
+ * const status = context.getStatus();
+ * console.log(`Healthy: ${status.healthy}, Queries: ${status.totalQueries}`);
+ *
+ * // Get limitations
+ * const limits = context.getLimitations();
+ * console.log(`Max batch size: ${limits.maxBatchSize}`);
+ * ```
+ */
+export interface AdapterContext {
+    /** Reference to the underlying adapter */
+    readonly adapter: StorageAdapter;
+    /** Adapter kind identifier */
+    readonly kind: AdapterKind;
+    /** Set of capabilities supported by this adapter */
+    readonly capabilities: ReadonlySet<StorageCapability>;
+    /** Whether the adapter is currently open/connected */
+    readonly isOpen: boolean;
+    /** Whether the adapter supports synchronous operations */
+    readonly supportsSync: boolean;
+    /** Whether the adapter supports ACID transactions */
+    readonly supportsTransactions: boolean;
+    /** Whether the adapter supports batch operations */
+    readonly supportsBatch: boolean;
+    /** Whether the adapter supports prepared statements */
+    readonly supportsPrepared: boolean;
+    /** Whether the adapter supports streaming results */
+    readonly supportsStreaming: boolean;
+    /** Whether the adapter supports Write-Ahead Logging */
+    readonly supportsWAL: boolean;
+    /** Whether the adapter supports native JSON operations */
+    readonly supportsJSON: boolean;
+    /** Whether the adapter supports array data types */
+    readonly supportsArrays: boolean;
+    /** Whether the adapter supports concurrent connections */
+    readonly supportsConcurrent: boolean;
+    /** Whether the adapter persists data across restarts */
+    readonly supportsPersistence: boolean;
+    /** Information about the current connection */
+    readonly connectionInfo: ConnectionInfo;
+    /**
+     * Check if a specific capability is supported.
+     *
+     * @param capability - The capability to check
+     * @returns True if the capability is supported
+     *
+     * @example
+     * ```typescript
+     * if (context.hasCapability('streaming')) {
+     *   // Use streaming API
+     * }
+     * ```
+     */
+    hasCapability(capability: StorageCapability): boolean;
+    /**
+     * Require a specific capability, throwing an error if not supported.
+     *
+     * @param capability - The required capability
+     * @throws {Error} If the capability is not supported
+     *
+     * @example
+     * ```typescript
+     * context.requiresCapability('transactions');
+     * // Safe to use transactions now
+     * await adapter.transaction(async (trx) => { ... });
+     * ```
+     */
+    requiresCapability(capability: StorageCapability): void;
+    /**
+     * Get detailed limitations and constraints for this adapter.
+     *
+     * @returns Adapter-specific limitations
+     *
+     * @example
+     * ```typescript
+     * const limits = context.getLimitations();
+     * if (operations.length > limits.maxBatchSize) {
+     *   // Split into chunks
+     * }
+     * ```
+     */
+    getLimitations(): AdapterLimitations;
+    /**
+     * Get current health and status information.
+     *
+     * @returns Current adapter status
+     *
+     * @example
+     * ```typescript
+     * const status = context.getStatus();
+     * if (!status.healthy) {
+     *   logger.error('Database unhealthy', status.lastError);
+     * }
+     * ```
+     */
+    getStatus(): AdapterStatus;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/cjs/core/contracts/context.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/cjs/core/contracts/dialect.d.ts

@@ -0,0 +1,154 @@
+/**
+ * SQL dialect abstraction for cross-platform SQL generation.
+ *
+ * Each method returns a SQL string fragment or full statement.
+ * Implementations are pure string transformers — no database calls.
+ *
+ * Expressions and placeholders passed in are inserted as written; numbers,
+ * units, types and JSON paths are checked, so nothing a caller passes as a
+ * value reaches the SQL text unchecked.
+ */
+export interface SqlDialect {
+    /** Dialect identifier. */
+    readonly name: 'sqlite' | 'postgres';
+    /**
+     * Generate an INSERT OR IGNORE statement.
+     * SQLite: `INSERT OR IGNORE INTO t (a, b) VALUES (?, ?)`
+     * Postgres: `INSERT INTO t (a, b) VALUES ($1, $2) ON CONFLICT DO NOTHING`
+     */
+    insertOrIgnore(table: string, columns: string[], placeholders: string[]): string;
+    /**
+     * Generate an upsert on the primary key that updates the existing row in
+     * place, on both engines:
+     * `INSERT INTO t (a, b) VALUES (?, ?) ON CONFLICT (a) DO UPDATE SET b = excluded.b`.
+     * The row keeps the columns the statement does not name, and its dependents.
+     * When every column is the key, the statement does nothing on a conflict.
+     *
+     * @param primaryKey - The conflict target. Defaults to the first column.
+     */
+    insertOrReplace(table: string, columns: string[], placeholders: string[], primaryKey?: string): string;
+    /**
+     * An upsert with an explicit conflict target that updates the existing row
+     * in place on both engines (SQLite 3.24 and later):
+     * `INSERT INTO t (a, b, c) VALUES (?, ?, ?) ON CONFLICT (a) DO UPDATE SET b = excluded.b, c = excluded.c`.
+     *
+     * @param conflictColumns - The unique or primary-key columns of the conflict target.
+     * @param updateColumns - The columns to update; by default every column outside the target. None left: DO NOTHING.
+     */
+    upsert(table: string, columns: string[], placeholders: string[], conflictColumns: string[], updateColumns?: string[]): string;
+    /**
+     * Generate a JSON field extraction expression.
+     * SQLite: `json_extract(col, '$.key')`
+     * Postgres: `(col::jsonb)->>'key'`
+     */
+    jsonExtract(column: string, jsonPath: string): string;
+    /**
+     * A value at `jsonPath` (`$.a.b`, `$.a[0]`) read as text, an integer or a
+     * real, with the same result on both engines; `json` reads the JSON value
+     * itself (jsonb on PostgreSQL, JSON text on SQLite), for use inside another
+     * expression such as jsonArrayContains. A path outside that form is refused.
+     */
+    jsonExtractAs(column: string, jsonPath: string, type: JsonValueType): string;
+    /**
+     * Whether the JSON array `jsonArray` holds the value `valueExpr`, compared
+     * as text, so a string or a number matches on both engines.
+     */
+    jsonArrayContains(jsonArray: string, valueExpr: string): string;
+    /**
+     * Generate a null-coalesce expression.
+     * SQLite: `ifnull(expr, fallback)`
+     * Postgres: `COALESCE(expr, fallback)`
+     */
+    ifnull(expr: string, fallback: string): string;
+    /**
+     * Column definition for an auto-incrementing integer primary key.
+     * SQLite: `INTEGER PRIMARY KEY AUTOINCREMENT`
+     * Postgres: `INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY`
+     */
+    autoIncrementPrimaryKey(): string;
+    /**
+     * A column type for DDL. PostgreSQL: TEXT, INTEGER, BIGINT, DOUBLE
+     * PRECISION, BOOLEAN, TIMESTAMPTZ, JSONB, UUID, BYTEA. SQLite: TEXT,
+     * INTEGER, INTEGER, REAL, INTEGER, TEXT, TEXT, TEXT, BLOB. The values a
+     * column returns follow each engine (a PostgreSQL boolean is `true`, a
+     * SQLite one 1); `typeParsers` and the bound-value conversions narrow that.
+     */
+    columnType(kind: ColumnKind): string;
+    /**
+     * Generate a PRAGMA statement or equivalent.
+     * SQLite: `PRAGMA key = value`
+     * Postgres: returns null (skip — Postgres enforces FKs by default, etc.)
+     */
+    pragma(key: string, value: string): string | null;
+    /**
+     * Parameter placeholder for the given 0-based index.
+     * SQLite: `?`
+     * Postgres: `$1`, `$2`, etc.
+     */
+    placeholder(index: number): string;
+    /**
+     * The current time. PostgreSQL: `now()` (timestamptz). SQLite: ISO 8601
+     * UTC text with milliseconds, the form a bound Date takes, so text
+     * comparisons with stored times order correctly.
+     */
+    now(): string;
+    /**
+     * `expr` cast to a type both engines read the same way. `timestamp` is
+     * timestamptz on PostgreSQL and ISO 8601 UTC text on SQLite.
+     */
+    cast(expr: string, type: CastType): string;
+    /**
+     * The time `expr` moved by `amount` units (negative moves back), as an
+     * exact number of seconds on both engines. PostgreSQL: timestamptz.
+     * SQLite: ISO 8601 UTC text.
+     */
+    addInterval(expr: string, amount: number, unit: IntervalUnit): string;
+    /**
+     * The start of the minute, hour, day, month or year that holds `expr`, in
+     * UTC, as ISO 8601 text (`2026-10-15T00:00:00.000Z`) on both engines.
+     */
+    dateBucket(unit: DateBucketUnit, expr: string): string;
+    /**
+     * Case-insensitive LIKE. PostgreSQL: ILIKE. SQLite: LIKE, which folds only
+     * ASCII letters.
+     */
+    ilike(expr: string, pattern: string): string;
+    /** `expr IN (...)` over the given placeholders or expressions; an empty list matches nothing. */
+    inList(expr: string, items: string[]): string;
+    /**
+     * Membership in an array bound as one parameter. PostgreSQL: `= ANY(param)`
+     * (pg binds a JavaScript array as an array). SQLite: `IN (SELECT value
+     * FROM json_each(param))` over the JSON text the array binds as.
+     */
+    inArray(expr: string, arrayParam: string): string;
+    /**
+     * A row-lock clause to append to a SELECT. PostgreSQL: ` FOR UPDATE` or
+     * ` FOR SHARE`, with ` SKIP LOCKED` or ` NOWAIT`. SQLite: `''`, since a
+     * write transaction there holds the whole database.
+     */
+    rowLock(mode: 'update' | 'share', wait?: 'wait' | 'skipLocked' | 'noWait'): string;
+    /**
+     * A statement that takes a transaction-scoped advisory lock on an integer
+     * key, released at COMMIT or ROLLBACK. PostgreSQL:
+     * `SELECT pg_advisory_xact_lock(key)`. SQLite: null, to skip, since its
+     * write transactions already run one at a time.
+     */
+    advisoryTransactionLock(keyExpr: string): string | null;
+    /** The largest of the expressions, NULLs skipped on both engines; NULL when all are. */
+    greatest(...exprs: string[]): string;
+    /** The smallest of the expressions, NULLs skipped on both engines; NULL when all are. */
+    least(...exprs: string[]): string;
+    /** A random version 4 UUID as text. PostgreSQL: `gen_random_uuid()` (13 and later). SQLite: built from randomblob(). */
+    uuid(): string;
+}
+/** The types jsonExtractAs reads. */
+export type JsonValueType = 'text' | 'integer' | 'real' | 'json';
+/** The types cast takes. */
+export type CastType = 'text' | 'integer' | 'real' | 'timestamp';
+/** The units addInterval takes. Months and years are left out: the engines clamp a month's end differently. */
+export type IntervalUnit = 'seconds' | 'minutes' | 'hours' | 'days';
+/** The units dateBucket takes. */
+export type DateBucketUnit = 'minute' | 'hour' | 'day' | 'month' | 'year';
+/** The column kinds columnType declares. */
+export type ColumnKind = 'text' | 'integer' | 'bigint' | 'real' | 'boolean' | 'timestamp' | 'json' | 'uuid' | 'blob';
+//# sourceMappingURL=dialect.d.ts.map

package/dist/cjs/core/contracts/dialect.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 dialect_exports = {};
+module.exports = __toCommonJS(dialect_exports);

package/dist/cjs/core/contracts/events.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Event system types for adapter lifecycle and query monitoring.
+ *
+ * These types enable applications to subscribe to adapter events
+ * for logging, monitoring, debugging, and analytics purposes.
+ */
+import type { StorageParameters } from './index.js';
+import type { AdapterContext } from './context.js';
+/**
+ * Event emitted when a connection is opened.
+ */
+export interface ConnectionOpenedEvent {
+    type: 'connection:opened';
+    context: AdapterContext;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a connection is closed.
+ */
+export interface ConnectionClosedEvent {
+    type: 'connection:closed';
+    context: AdapterContext;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a connection error occurs.
+ */
+export interface ConnectionErrorEvent {
+    type: 'connection:error';
+    error: Error;
+    context: AdapterContext;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a query starts execution.
+ */
+export interface QueryStartEvent {
+    type: 'query:start';
+    statement: string;
+    parameters?: StorageParameters;
+    timestamp: Date;
+    queryId?: string;
+}
+/**
+ * Event emitted when a query completes successfully.
+ */
+export interface QueryCompleteEvent {
+    type: 'query:complete';
+    statement: string;
+    duration: number;
+    rows?: number;
+    timestamp: Date;
+    queryId?: string;
+}
+/**
+ * Event emitted when a query fails.
+ */
+export interface QueryErrorEvent {
+    type: 'query:error';
+    statement: string;
+    error: Error;
+    duration: number;
+    timestamp: Date;
+    queryId?: string;
+}
+/**
+ * Event emitted when a transaction starts.
+ */
+export interface TransactionStartEvent {
+    type: 'transaction:start';
+    id: string;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a transaction commits successfully.
+ */
+export interface TransactionCommitEvent {
+    type: 'transaction:commit';
+    id: string;
+    duration: number;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a transaction is rolled back.
+ */
+export interface TransactionRollbackEvent {
+    type: 'transaction:rollback';
+    id: string;
+    error?: Error;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a slow query is detected.
+ */
+export interface PerformanceSlowQueryEvent {
+    type: 'performance:slow-query';
+    statement: string;
+    duration: number;
+    threshold: number;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a cache hit occurs.
+ */
+export interface CacheHitEvent {
+    type: 'cache:hit';
+    key: string;
+    statement: string;
+    timestamp: Date;
+}
+/**
+ * Event emitted when a cache miss occurs.
+ */
+export interface CacheMissEvent {
+    type: 'cache:miss';
+    key: string;
+    statement: string;
+    timestamp: Date;
+}
+/**
+ * Event emitted when the cache is cleared.
+ */
+export interface CacheClearEvent {
+    type: 'cache:clear';
+    entriesCleared: number;
+    timestamp: Date;
+}
+/**
+ * Union of all possible adapter events.
+ */
+export type AdapterEvent = ConnectionOpenedEvent | ConnectionClosedEvent | ConnectionErrorEvent | QueryStartEvent | QueryCompleteEvent | QueryErrorEvent | TransactionStartEvent | TransactionCommitEvent | TransactionRollbackEvent | PerformanceSlowQueryEvent | CacheHitEvent | CacheMissEvent | CacheClearEvent;
+/**
+ * Extract event type from AdapterEvent discriminated union.
+ */
+export type AdapterEventType = AdapterEvent['type'];
+/**
+ * Listener function for adapter events.
+ */
+export type AdapterEventListener<T extends AdapterEvent = AdapterEvent> = (event: T) => void;
+/**
+ * Unsubscribe function returned by event listeners.
+ */
+export type UnsubscribeFn = () => void;
+/**
+ * Event emitter interface for storage adapters.
+ *
+ * Provides a simple pub/sub mechanism for monitoring adapter
+ * lifecycle and query execution.
+ *
+ * @example
+ * ```typescript
+ * // Subscribe to all query errors
+ * const unsubscribe = events.on('query:error', (event) => {
+ *   console.error('Query failed:', event.statement, event.error);
+ * });
+ *
+ * // Later, unsubscribe
+ * unsubscribe();
+ *
+ * // Subscribe to slow queries
+ * events.on('performance:slow-query', (event) => {
+ *   if (event.duration > 5000) {
+ *     analytics.track('very_slow_query', {
+ *       statement: event.statement,
+ *       duration: event.duration
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export interface AdapterEventEmitter {
+    /**
+     * Subscribe to an event type.
+     *
+     * @param eventType - The type of event to listen for
+     * @param listener - Callback function to invoke when event occurs
+     * @returns Unsubscribe function
+     */
+    on<T extends AdapterEventType>(eventType: T, listener: AdapterEventListener<Extract<AdapterEvent, {
+        type: T;
+    }>>): UnsubscribeFn;
+    /**
+     * Subscribe to an event type once (auto-unsubscribes after first call).
+     *
+     * @param eventType - The type of event to listen for
+     * @param listener - Callback function to invoke when event occurs
+     * @returns Unsubscribe function
+     */
+    once<T extends AdapterEventType>(eventType: T, listener: AdapterEventListener<Extract<AdapterEvent, {
+        type: T;
+    }>>): UnsubscribeFn;
+    /**
+     * Emit an event to all subscribers.
+     *
+     * @param event - The event to emit
+     */
+    emit(event: AdapterEvent): void;
+    /**
+     * Remove all event listeners.
+     */
+    removeAllListeners(): void;
+    /**
+     * Remove all listeners for a specific event type.
+     *
+     * @param eventType - The event type to clear listeners for
+     */
+    removeListeners(eventType: AdapterEventType): void;
+    /**
+     * Get the number of listeners for an event type.
+     *
+     * @param eventType - The event type to count listeners for
+     * @returns Number of active listeners
+     */
+    listenerCount(eventType: AdapterEventType): number;
+}
+/**
+ * Helper type for creating type-safe event emitter implementations.
+ */
+export interface EventEmitterOptions {
+    /** Maximum number of listeners before warning (default: 10) */
+    maxListeners?: number;
+    /** Whether to log warnings for too many listeners */
+    warnOnMaxListeners?: boolean;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/cjs/core/contracts/events.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 events_exports = {};
+module.exports = __toCommonJS(events_exports);

package/dist/cjs/core/contracts/exporter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Database export abstraction.
+ *
+ * SQLite: VACUUM INTO or db.export().
+ * Postgres: pg_dump via child_process.
+ */
+export interface IDatabaseExporter {
+    /** Export the full database to a file at the given path. */
+    exportToFile(outputPath: string): Promise<void>;
+    /** Export the full database as raw bytes. */
+    exportToBytes(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=exporter.d.ts.map

package/dist/cjs/core/contracts/exporter.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 exporter_exports = {};
+module.exports = __toCommonJS(exporter_exports);