pomegranate-db 0.1.0

package/dist/adapters/sqlite/SQLiteAdapter.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * SQLite Adapter.
+ *
+ * Implements the StorageAdapter interface using a SQL driver.
+ * The actual SQLite driver is injected — this adapter generates SQL
+ * and delegates execution, enabling different drivers for
+ * React Native (react-native-sqlite-storage) and web (sql.js).
+ *
+ * The driver interface is intentionally minimal so it can wrap
+ * any SQLite library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteAdapter = void 0;
+const sql_1 = require("./sql");
+// ─── SQLite Adapter ───────────────────────────────────────────────────────
+class SQLiteAdapter {
+    _driver;
+    _databaseName;
+    _encryption;
+    _initialized = false;
+    constructor(config) {
+        this._databaseName = config.databaseName;
+        this._encryption = config.encryption;
+        if (config.driver) {
+            this._driver = config.driver;
+        }
+        else {
+            // Use a no-op driver that throws — user must provide one
+            this._driver = createStubDriver();
+        }
+    }
+    // ─── Initialize ──────────────────────────────────────────────────────
+    async initialize(schema) {
+        if (this._initialized)
+            return;
+        await this._driver.open(this._databaseName);
+        // Create metadata table
+        await this._driver.execute(`CREATE TABLE IF NOT EXISTS "__pomegranate_metadata" (
+        "key" TEXT PRIMARY KEY NOT NULL,
+        "value" TEXT
+      )`);
+        // Check existing version
+        const rows = await this._driver.query('SELECT "value" FROM "__pomegranate_metadata" WHERE "key" = \'schema_version\'');
+        const existingVersion = rows.length > 0 ? Number.parseInt(rows[0].value, 10) : 0;
+        if (existingVersion === 0) {
+            // Fresh install — create all tables
+            for (const table of schema.tables) {
+                const sql = (0, sql_1.createTableSQL)(table);
+                // Split multi-statement SQL
+                for (const stmt of sql.split(';\n')) {
+                    const trimmed = stmt.trim().replace(/;$/, '');
+                    if (trimmed) {
+                        await this._driver.execute(trimmed);
+                    }
+                }
+            }
+            // Store version
+            await this._driver.execute('INSERT OR REPLACE INTO "__pomegranate_metadata" ("key", "value") VALUES (\'schema_version\', ?)', [String(schema.version)]);
+        }
+        this._initialized = true;
+    }
+    // ─── Query ──────────────────────────────────────────────────────────
+    async find(query) {
+        const { sql, bindings } = (0, sql_1.selectSQL)(query);
+        const rows = await this._driver.query(sql, bindings);
+        return rows;
+    }
+    async count(query) {
+        const { sql, bindings } = (0, sql_1.countSQL)(query);
+        const rows = await this._driver.query(sql, bindings);
+        return rows[0]?.count ?? 0;
+    }
+    async findById(table, id) {
+        const rows = await this._driver.query(`SELECT * FROM "${table}" WHERE "id" = ?`, [id]);
+        return rows[0] ?? null;
+    }
+    // ─── Insert / Update / Delete ────────────────────────────────────────
+    async insert(table, raw) {
+        const { sql, bindings } = (0, sql_1.insertSQL)(table, raw);
+        await this._driver.execute(sql, bindings);
+    }
+    async update(table, raw) {
+        const { sql, bindings } = (0, sql_1.updateSQL)(table, raw);
+        await this._driver.execute(sql, bindings);
+    }
+    async markAsDeleted(table, id) {
+        await this._driver.execute(`UPDATE "${table}" SET "_status" = 'deleted' WHERE "id" = ?`, [id]);
+    }
+    async destroyPermanently(table, id) {
+        const { sql, bindings } = (0, sql_1.deleteSQL)(table, id);
+        await this._driver.execute(sql, bindings);
+    }
+    // ─── Batch ──────────────────────────────────────────────────────────
+    async batch(operations) {
+        await this._driver.executeInTransaction(async () => {
+            for (const op of operations) {
+                switch (op.type) {
+                    case 'create': {
+                        const { sql, bindings } = (0, sql_1.insertSQL)(op.table, op.rawRecord);
+                        await this._driver.execute(sql, bindings);
+                        break;
+                    }
+                    case 'update': {
+                        const { sql, bindings } = (0, sql_1.updateSQL)(op.table, op.rawRecord);
+                        await this._driver.execute(sql, bindings);
+                        break;
+                    }
+                    case 'delete':
+                        await this._driver.execute(`UPDATE "${op.table}" SET "_status" = 'deleted' WHERE "id" = ?`, [op.id]);
+                        break;
+                    case 'destroyPermanently': {
+                        const { sql, bindings } = (0, sql_1.deleteSQL)(op.table, op.id);
+                        await this._driver.execute(sql, bindings);
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    // ─── Search ──────────────────────────────────────────────────────────
+    async search(descriptor) {
+        const { sql, countSql, bindings, countBindings } = (0, sql_1.searchSQL)(descriptor);
+        const [rows, countRows] = await Promise.all([
+            this._driver.query(sql, bindings),
+            this._driver.query(countSql, countBindings),
+        ]);
+        return {
+            records: rows,
+            total: countRows[0]?.count ?? 0,
+        };
+    }
+    // ─── Sync helpers ──────────────────────────────────────────────────
+    async getLocalChanges(tables) {
+        const result = {};
+        for (const table of tables) {
+            const created = await this._driver.query(`SELECT * FROM "${table}" WHERE "_status" = 'created'`);
+            const updated = await this._driver.query(`SELECT * FROM "${table}" WHERE "_status" = 'updated'`);
+            const deletedRows = await this._driver.query(`SELECT "id" FROM "${table}" WHERE "_status" = 'deleted'`);
+            result[table] = {
+                created: created,
+                updated: updated,
+                deleted: deletedRows.map((r) => r.id),
+            };
+        }
+        return result;
+    }
+    async applyRemoteChanges(changes) {
+        await this._driver.executeInTransaction(async () => {
+            for (const [table, tableChanges] of Object.entries(changes)) {
+                // Apply created records
+                for (const raw of tableChanges.created) {
+                    const record = { ...raw, _status: 'synced', _changed: '' };
+                    // Use INSERT OR REPLACE in case the record already exists locally
+                    const { sql, bindings } = (0, sql_1.insertSQL)(table, record);
+                    const replaceSql = sql.replace('INSERT INTO', 'INSERT OR REPLACE INTO');
+                    await this._driver.execute(replaceSql, bindings);
+                }
+                // Apply updated records
+                for (const raw of tableChanges.updated) {
+                    const record = { ...raw, _status: 'synced', _changed: '' };
+                    // Check if record exists
+                    const existing = await this._driver.query(`SELECT "_status" FROM "${table}" WHERE "id" = ?`, [raw.id]);
+                    if (existing.length > 0) {
+                        const { sql, bindings } = (0, sql_1.updateSQL)(table, record);
+                        await this._driver.execute(sql, bindings);
+                    }
+                    else {
+                        const { sql, bindings } = (0, sql_1.insertSQL)(table, record);
+                        await this._driver.execute(sql, bindings);
+                    }
+                }
+                // Apply deletions
+                for (const id of tableChanges.deleted) {
+                    await this._driver.execute(`DELETE FROM "${table}" WHERE "id" = ?`, [id]);
+                }
+            }
+        });
+    }
+    async markAsSynced(table, ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(', ');
+        await this._driver.execute(`UPDATE "${table}" SET "_status" = 'synced', "_changed" = '' WHERE "id" IN (${placeholders})`, ids);
+    }
+    // ─── Schema version ──────────────────────────────────────────────────
+    async getSchemaVersion() {
+        try {
+            const rows = await this._driver.query('SELECT "value" FROM "__pomegranate_metadata" WHERE "key" = \'schema_version\'');
+            return rows.length > 0 ? Number.parseInt(rows[0].value, 10) : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    // ─── Migration ──────────────────────────────────────────────────────
+    async migrate(migrations) {
+        const currentVersion = await this.getSchemaVersion();
+        const applicable = migrations
+            .filter((m) => m.fromVersion >= currentVersion)
+            .toSorted((a, b) => a.fromVersion - b.fromVersion);
+        await this._driver.executeInTransaction(async () => {
+            for (const migration of applicable) {
+                for (const step of migration.steps) {
+                    switch (step.type) {
+                        case 'createTable': {
+                            const sql = (0, sql_1.createTableSQL)(step.schema);
+                            for (const stmt of sql.split(';\n')) {
+                                const trimmed = stmt.trim().replace(/;$/, '');
+                                if (trimmed)
+                                    await this._driver.execute(trimmed);
+                            }
+                            break;
+                        }
+                        case 'addColumn':
+                            await this._driver.execute(`ALTER TABLE "${step.table}" ADD COLUMN "${step.column}" ${step.columnType}${step.isOptional ? '' : ' NOT NULL DEFAULT ""'}`);
+                            break;
+                        case 'destroyTable':
+                            await this._driver.execute(`DROP TABLE IF EXISTS "${step.table}"`);
+                            break;
+                        case 'sql':
+                            await this._driver.execute(step.query);
+                            break;
+                    }
+                }
+                await this._driver.execute('INSERT OR REPLACE INTO "__pomegranate_metadata" ("key", "value") VALUES (\'schema_version\', ?)', [String(migration.toVersion)]);
+            }
+        });
+    }
+    // ─── Reset ──────────────────────────────────────────────────────────
+    async reset() {
+        // Get all user tables
+        const tables = await this._driver.query('SELECT name FROM sqlite_master WHERE type=\'table\' AND name NOT LIKE \'sqlite_%\'');
+        await this._driver.executeInTransaction(async () => {
+            for (const t of tables) {
+                await this._driver.execute(`DROP TABLE IF EXISTS "${t.name}"`);
+            }
+        });
+        this._initialized = false;
+    }
+    // ─── Close ──────────────────────────────────────────────────────────
+    async close() {
+        await this._driver.close();
+    }
+}
+exports.SQLiteAdapter = SQLiteAdapter;
+// ─── Stub Driver ──────────────────────────────────────────────────────────
+function notConfigured() {
+    throw new Error('No SQLite driver configured. Provide a driver in SQLiteAdapterConfig.driver, ' +
+        'or use LokiAdapter for in-memory/web use.');
+}
+function createStubDriver() {
+    return {
+        open: async () => notConfigured(),
+        execute: async () => notConfigured(),
+        query: async () => {
+            notConfigured();
+            return [];
+        },
+        executeInTransaction: async () => notConfigured(),
+        close: async () => { },
+    };
+}
+//# sourceMappingURL=SQLiteAdapter.js.map

package/dist/adapters/sqlite/index.d.ts

@@ -0,0 +1,2 @@
+export { SQLiteAdapter } from './SQLiteAdapter';
+export type { SQLiteDriver, SQLiteAdapterConfig } from './SQLiteAdapter';

package/dist/adapters/sqlite/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteAdapter = void 0;
+var SQLiteAdapter_1 = require("./SQLiteAdapter");
+Object.defineProperty(exports, "SQLiteAdapter", { enumerable: true, get: function () { return SQLiteAdapter_1.SQLiteAdapter; } });
+//# sourceMappingURL=index.js.map

package/dist/adapters/sqlite/sql.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SQL generation utilities.
+ *
+ * Translates QueryDescriptor / SearchDescriptor into SQL strings + bindings.
+ * Used by the SQLite adapter.
+ */
+import type { QueryDescriptor, SearchDescriptor } from '../../query/types';
+import type { TableSchema } from '../../schema/types';
+export declare function createTableSQL(table: TableSchema): string;
+export declare function selectSQL(descriptor: QueryDescriptor): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function countSQL(descriptor: QueryDescriptor): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function searchSQL(descriptor: SearchDescriptor): {
+    sql: string;
+    countSql: string;
+    bindings: unknown[];
+    countBindings: unknown[];
+};
+export declare function insertSQL(table: string, raw: Record<string, unknown>): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function updateSQL(table: string, raw: Record<string, unknown>): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function deleteSQL(table: string, id: string): {
+    sql: string;
+    bindings: unknown[];
+};

package/dist/adapters/sqlite/sql.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * SQL generation utilities.
+ *
+ * Translates QueryDescriptor / SearchDescriptor into SQL strings + bindings.
+ * Used by the SQLite adapter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTableSQL = createTableSQL;
+exports.selectSQL = selectSQL;
+exports.countSQL = countSQL;
+exports.searchSQL = searchSQL;
+exports.insertSQL = insertSQL;
+exports.updateSQL = updateSQL;
+exports.deleteSQL = deleteSQL;
+const utils_1 = require("../../utils");
+// ─── CREATE TABLE ──────────────────────────────────────────────────────────
+function createTableSQL(table) {
+    const tableName = (0, utils_1.sanitizeTableName)(table.name);
+    const columnDefs = [
+        '"id" TEXT PRIMARY KEY NOT NULL',
+        '"_status" TEXT NOT NULL DEFAULT \'created\'',
+        '"_changed" TEXT NOT NULL DEFAULT \'\'',
+        ...table.columns.map((col) => {
+            const name = (0, utils_1.sanitizeColumnName)(col.name);
+            let sqlType;
+            switch (col.type) {
+                case 'text':
+                    sqlType = 'TEXT';
+                    break;
+                case 'number':
+                    sqlType = 'REAL';
+                    break;
+                case 'boolean':
+                    sqlType = 'INTEGER';
+                    break;
+                case 'date':
+                    sqlType = 'REAL';
+                    break;
+                default:
+                    sqlType = 'TEXT';
+            }
+            const nullable = col.isOptional ? '' : ' NOT NULL';
+            const defaultVal = col.isOptional ? ' DEFAULT NULL' : getDefaultClause(col.type);
+            return `"${name}" ${sqlType}${nullable}${defaultVal}`;
+        }),
+    ];
+    const createSQL = `CREATE TABLE IF NOT EXISTS "${tableName}" (${columnDefs.join(', ')})`;
+    // Build index statements
+    const indexes = table.columns
+        .filter((col) => col.isIndexed)
+        .map((col) => {
+        const colName = (0, utils_1.sanitizeColumnName)(col.name);
+        return `CREATE INDEX IF NOT EXISTS "${tableName}_${colName}" ON "${tableName}" ("${colName}")`;
+    });
+    // Always index _status
+    indexes.unshift(`CREATE INDEX IF NOT EXISTS "${tableName}__status" ON "${tableName}" ("_status")`);
+    return [createSQL, ...indexes].join(';\n') + ';';
+}
+function getDefaultClause(type) {
+    switch (type) {
+        case 'text':
+            return " DEFAULT ''";
+        case 'number':
+            return ' DEFAULT 0';
+        case 'boolean':
+            return ' DEFAULT 0';
+        case 'date':
+            return ' DEFAULT NULL';
+        default:
+            return '';
+    }
+}
+// ─── SELECT query ──────────────────────────────────────────────────────────
+function selectSQL(descriptor) {
+    const bindings = [];
+    const table = (0, utils_1.sanitizeTableName)(descriptor.table);
+    let sql = `SELECT * FROM "${table}"`;
+    // JOINs
+    for (const join of descriptor.joins) {
+        const joinTable = (0, utils_1.sanitizeTableName)(join.table);
+        const leftCol = (0, utils_1.sanitizeColumnName)(join.leftColumn);
+        const rightCol = (0, utils_1.sanitizeColumnName)(join.rightColumn);
+        sql += ` JOIN "${joinTable}" ON "${table}"."${leftCol}" = "${joinTable}"."${rightCol}"`;
+    }
+    // WHERE
+    if (descriptor.conditions.length > 0) {
+        const whereClause = conditionsToSQL(descriptor.conditions, bindings);
+        sql += ` WHERE ${whereClause}`;
+    }
+    // ORDER BY
+    if (descriptor.orderBy.length > 0) {
+        const orderClauses = descriptor.orderBy.map((ob) => {
+            const col = (0, utils_1.sanitizeColumnName)(ob.column);
+            return `"${col}" ${ob.order === 'desc' ? 'DESC' : 'ASC'}`;
+        });
+        sql += ` ORDER BY ${orderClauses.join(', ')}`;
+    }
+    // LIMIT / OFFSET
+    if (descriptor.limit !== undefined) {
+        sql += ' LIMIT ?';
+        bindings.push(descriptor.limit);
+    }
+    if (descriptor.offset !== undefined) {
+        sql += ' OFFSET ?';
+        bindings.push(descriptor.offset);
+    }
+    return { sql, bindings };
+}
+// ─── COUNT query ───────────────────────────────────────────────────────────
+function countSQL(descriptor) {
+    const bindings = [];
+    const table = (0, utils_1.sanitizeTableName)(descriptor.table);
+    let sql = `SELECT COUNT(*) as count FROM "${table}"`;
+    if (descriptor.conditions.length > 0) {
+        const whereClause = conditionsToSQL(descriptor.conditions, bindings);
+        sql += ` WHERE ${whereClause}`;
+    }
+    return { sql, bindings };
+}
+// ─── SEARCH query (LIKE-based) ─────────────────────────────────────────────
+function searchSQL(descriptor) {
+    const bindings = [];
+    const countBindings = [];
+    const table = (0, utils_1.sanitizeTableName)(descriptor.table);
+    const pattern = `%${escapeLike(descriptor.term)}%`;
+    // Build search conditions
+    const searchConditions = descriptor.fields.map((field) => {
+        const col = (0, utils_1.sanitizeColumnName)(field);
+        bindings.push(pattern);
+        countBindings.push(pattern);
+        return `"${col}" LIKE ?`;
+    });
+    const searchWhere = `(${searchConditions.join(' OR ')})`;
+    // Additional conditions
+    let extraWhere = '';
+    if (descriptor.conditions.length > 0) {
+        const extraBindings = [];
+        extraWhere = ` AND ${conditionsToSQL(descriptor.conditions, extraBindings)}`;
+        bindings.push(...extraBindings);
+        countBindings.push(...extraBindings);
+    }
+    // Count query
+    const countSql = `SELECT COUNT(*) as count FROM "${table}" WHERE ${searchWhere}${extraWhere}`;
+    // Result query
+    let sql = `SELECT * FROM "${table}" WHERE ${searchWhere}${extraWhere}`;
+    if (descriptor.orderBy.length > 0) {
+        const orderClauses = descriptor.orderBy.map((ob) => {
+            const col = (0, utils_1.sanitizeColumnName)(ob.column);
+            return `"${col}" ${ob.order === 'desc' ? 'DESC' : 'ASC'}`;
+        });
+        sql += ` ORDER BY ${orderClauses.join(', ')}`;
+    }
+    sql += ' LIMIT ? OFFSET ?';
+    bindings.push(descriptor.limit, descriptor.offset);
+    return { sql, countSql, bindings, countBindings };
+}
+// ─── INSERT ────────────────────────────────────────────────────────────────
+function insertSQL(table, raw) {
+    const tableName = (0, utils_1.sanitizeTableName)(table);
+    const keys = Object.keys(raw);
+    const columns = keys.map((k) => `"${(0, utils_1.sanitizeColumnName)(k)}"`).join(', ');
+    const placeholders = keys.map(() => '?').join(', ');
+    const bindings = keys.map((k) => raw[k]);
+    return {
+        sql: `INSERT INTO "${tableName}" (${columns}) VALUES (${placeholders})`,
+        bindings,
+    };
+}
+// ─── UPDATE ────────────────────────────────────────────────────────────────
+function updateSQL(table, raw) {
+    const tableName = (0, utils_1.sanitizeTableName)(table);
+    const keys = Object.keys(raw).filter((k) => k !== 'id');
+    const setClauses = keys.map((k) => `"${(0, utils_1.sanitizeColumnName)(k)}" = ?`).join(', ');
+    const bindings = [...keys.map((k) => raw[k]), raw.id];
+    return {
+        sql: `UPDATE "${tableName}" SET ${setClauses} WHERE "id" = ?`,
+        bindings,
+    };
+}
+// ─── DELETE ────────────────────────────────────────────────────────────────
+function deleteSQL(table, id) {
+    return {
+        sql: `DELETE FROM "${(0, utils_1.sanitizeTableName)(table)}" WHERE "id" = ?`,
+        bindings: [id],
+    };
+}
+// ─── Condition helpers ─────────────────────────────────────────────────────
+function conditionsToSQL(conditions, bindings) {
+    return conditions.map((c) => conditionToSQL(c, bindings)).join(' AND ');
+}
+function conditionToSQL(condition, bindings) {
+    switch (condition.type) {
+        case 'where':
+            return whereToSQL(condition, bindings);
+        case 'and':
+            return `(${condition.conditions.map((c) => conditionToSQL(c, bindings)).join(' AND ')})`;
+        case 'or':
+            return `(${condition.conditions.map((c) => conditionToSQL(c, bindings)).join(' OR ')})`;
+        case 'not':
+            return `NOT (${conditionToSQL(condition.condition, bindings)})`;
+        default:
+            throw new Error(`Unknown condition type: ${condition.type}`);
+    }
+}
+function whereToSQL(clause, bindings) {
+    const col = `"${(0, utils_1.sanitizeColumnName)(clause.column)}"`;
+    switch (clause.operator) {
+        case 'eq':
+            bindings.push(clause.value);
+            return `${col} = ?`;
+        case 'neq':
+            bindings.push(clause.value);
+            return `${col} != ?`;
+        case 'gt':
+            bindings.push(clause.value);
+            return `${col} > ?`;
+        case 'gte':
+            bindings.push(clause.value);
+            return `${col} >= ?`;
+        case 'lt':
+            bindings.push(clause.value);
+            return `${col} < ?`;
+        case 'lte':
+            bindings.push(clause.value);
+            return `${col} <= ?`;
+        case 'in':
+            const arr = clause.value;
+            const placeholders = arr.map(() => '?').join(', ');
+            bindings.push(...arr);
+            return `${col} IN (${placeholders})`;
+        case 'notIn':
+            const arr2 = clause.value;
+            const placeholders2 = arr2.map(() => '?').join(', ');
+            bindings.push(...arr2);
+            return `${col} NOT IN (${placeholders2})`;
+        case 'like':
+            bindings.push(clause.value);
+            return `${col} LIKE ?`;
+        case 'notLike':
+            bindings.push(clause.value);
+            return `${col} NOT LIKE ?`;
+        case 'between':
+            const [low, high] = clause.value;
+            bindings.push(low, high);
+            return `${col} BETWEEN ? AND ?`;
+        case 'isNull':
+            return `${col} IS NULL`;
+        case 'isNotNull':
+            return `${col} IS NOT NULL`;
+        default:
+            throw new Error(`Unknown operator: ${clause.operator}`);
+    }
+}
+function escapeLike(str) {
+    return str.replaceAll('%', String.raw `\%`).replaceAll('_', String.raw `\_`);
+}
+//# sourceMappingURL=sql.js.map

package/dist/adapters/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Storage adapter interface.
+ *
+ * All database operations go through this interface, enabling
+ * pluggable backends (SQLite, LokiJS, etc.).
+ */
+import type { QueryDescriptor, SearchDescriptor, BatchOperation } from '../query/types';
+import type { DatabaseSchema, RawRecord, TableSchema } from '../schema/types';
+export interface AdapterConfig {
+    readonly databaseName: string;
+    /** Optional schema version override; normally derived from DatabaseSchema. */
+    readonly schemaVersion?: number;
+}
+export interface EncryptionConfig {
+    readonly enabled: boolean;
+    readonly keyProvider: () => Promise<Uint8Array>;
+}
+export interface Migration {
+    readonly fromVersion: number;
+    readonly toVersion: number;
+    readonly steps: MigrationStep[];
+}
+export type MigrationStep = {
+    type: 'createTable';
+    schema: TableSchema;
+} | {
+    type: 'addColumn';
+    table: string;
+    column: string;
+    columnType: string;
+    isOptional?: boolean;
+} | {
+    type: 'destroyTable';
+    table: string;
+} | {
+    type: 'sql';
+    query: string;
+};
+export interface StorageAdapter {
+    /** Initialize the adapter. Creates tables if needed. */
+    initialize(schema: DatabaseSchema): Promise<void>;
+    /** Find records matching a query descriptor. */
+    find(query: QueryDescriptor): Promise<RawRecord[]>;
+    /** Count records matching a query descriptor. */
+    count(query: QueryDescriptor): Promise<number>;
+    /** Find a single record by ID. */
+    findById(table: string, id: string): Promise<RawRecord | null>;
+    /** Insert a new raw record. */
+    insert(table: string, raw: RawRecord): Promise<void>;
+    /** Update an existing raw record. */
+    update(table: string, raw: RawRecord): Promise<void>;
+    /** Mark a record as deleted (_status = 'deleted'). */
+    markAsDeleted(table: string, id: string): Promise<void>;
+    /** Permanently remove a record from the database. */
+    destroyPermanently(table: string, id: string): Promise<void>;
+    /** Execute a batch of operations atomically. */
+    batch(operations: BatchOperation[]): Promise<void>;
+    /** Full-text search. */
+    search(descriptor: SearchDescriptor): Promise<{
+        records: RawRecord[];
+        total: number;
+    }>;
+    /** Return all records with _status != 'synced' */
+    getLocalChanges(tables: string[]): Promise<Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>>;
+    /** Apply synced changes from remote (in a transaction). */
+    applyRemoteChanges(changes: Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>): Promise<void>;
+    /** Mark synced records as _status = 'synced'. */
+    markAsSynced(table: string, ids: string[]): Promise<void>;
+    /** Get the database schema version currently stored. */
+    getSchemaVersion(): Promise<number>;
+    /** Run migrations. */
+    migrate(migrations: Migration[]): Promise<void>;
+    /** Completely reset the database. */
+    reset(): Promise<void>;
+    /** Close the database connection. */
+    close(): Promise<void>;
+}
+export type AdapterEvent = {
+    type: 'initialized';
+} | {
+    type: 'batch_completed';
+    operations: BatchOperation[];
+} | {
+    type: 'reset';
+};

package/dist/adapters/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Storage adapter interface.
+ *
+ * All database operations go through this interface, enabling
+ * pluggable backends (SQLite, LokiJS, etc.).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map