@tallyui/storage-sqlite 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { RxStorage } from 'rxdb';
+
+interface SQLiteDatabase {
+    execSync(source: string): void;
+    getAllSync<T>(source: string, params?: any[]): T[];
+    runSync(source: string, params?: any[]): {
+        changes: number;
+        lastInsertRowId: number;
+    };
+}
+interface SQLiteStorageSettings {
+    database: SQLiteDatabase;
+}
+
+interface SQLiteStorageInternals {
+    database: SQLiteDatabase;
+    tableName: string;
+}
+
+type RxStorageSQLite = RxStorage<SQLiteStorageInternals, SQLiteStorageSettings>;
+declare function getRxStorageSQLite(database: SQLiteDatabase): RxStorageSQLite;
+
+export { type SQLiteDatabase, type SQLiteStorageSettings, getRxStorageSQLite };

package/dist/index.js

@@ -0,0 +1,401 @@
+// src/rx-storage-sqlite.ts
+import { ensureRxStorageInstanceParamsAreCorrect } from "rxdb";
+import { RXDB_VERSION } from "rxdb/plugins/utils";
+
+// src/storage-instance.ts
+import { categorizeBulkWriteRows, getQueryMatcher, getSortComparator } from "rxdb";
+import { now, ensureNotFalsy } from "rxdb/plugins/utils";
+import { Subject } from "rxjs";
+
+// src/mango-to-sql.ts
+function mangoQueryToSQL(query) {
+  const params = [];
+  const conditions = [];
+  conditions.push(`json_extract(data, '$._deleted') = 0`);
+  if (query.selector && Object.keys(query.selector).length > 0) {
+    const selectorSql = selectorToSQL(query.selector, params);
+    if (selectorSql) {
+      conditions.push(selectorSql);
+    }
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  let orderBy = "";
+  if (query.sort && query.sort.length > 0) {
+    const orderParts = query.sort.map((sortPart) => {
+      const entries = Object.entries(sortPart);
+      if (entries.length === 0) return "";
+      const [field, direction] = entries[0];
+      const jsonPath = fieldToJsonExtract(field);
+      return `${jsonPath} ${direction === "desc" ? "DESC" : "ASC"}`;
+    }).filter(Boolean);
+    if (orderParts.length > 0) {
+      orderBy = `ORDER BY ${orderParts.join(", ")}`;
+    }
+  }
+  const limitParams = [];
+  let limit = "";
+  if (query.limit !== void 0 && query.limit !== null) {
+    limit = "LIMIT ?";
+    limitParams.push(query.limit);
+  }
+  if (query.skip && query.skip > 0) {
+    if (!limit) {
+      limit = "LIMIT -1";
+    }
+    limit += " OFFSET ?";
+    limitParams.push(query.skip);
+  }
+  return { where, params, orderBy, limit, limitParams };
+}
+function buildQuerySQL(tableName, query) {
+  const result = mangoQueryToSQL(query);
+  const allParams = [...result.params, ...result.limitParams];
+  const parts = [
+    `SELECT data FROM "${tableName}"`,
+    result.where,
+    result.orderBy,
+    result.limit
+  ].filter(Boolean);
+  return { sql: parts.join(" "), params: allParams };
+}
+function buildCountSQL(tableName, query) {
+  const result = mangoQueryToSQL(query);
+  const parts = [
+    `SELECT COUNT(*) as count FROM "${tableName}"`,
+    result.where
+  ].filter(Boolean);
+  return { sql: parts.join(" "), params: result.params };
+}
+function fieldToJsonExtract(field) {
+  return `json_extract(data, '$.${field}')`;
+}
+function selectorToSQL(selector, params) {
+  const conditions = [];
+  for (const [key, value] of Object.entries(selector)) {
+    if (key === "$and") {
+      const andConditions = value.map(
+        (sub) => selectorToSQL(sub, params)
+      ).filter(Boolean);
+      if (andConditions.length > 0) {
+        conditions.push(`(${andConditions.join(" AND ")})`);
+      }
+    } else if (key === "$or") {
+      const orConditions = value.map(
+        (sub) => selectorToSQL(sub, params)
+      ).filter(Boolean);
+      if (orConditions.length > 0) {
+        conditions.push(`(${orConditions.join(" OR ")})`);
+      }
+    } else {
+      const fieldSql = fieldConditionToSQL(key, value, params);
+      if (fieldSql) {
+        conditions.push(fieldSql);
+      }
+    }
+  }
+  return conditions.join(" AND ");
+}
+function fieldConditionToSQL(field, value, params) {
+  const jsonPath = fieldToJsonExtract(field);
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+    params.push(value);
+    return `${jsonPath} = ?`;
+  }
+  const conditions = [];
+  for (const [op, opValue] of Object.entries(value)) {
+    switch (op) {
+      case "$eq":
+        params.push(opValue);
+        conditions.push(`${jsonPath} = ?`);
+        break;
+      case "$ne":
+        params.push(opValue);
+        conditions.push(`${jsonPath} != ?`);
+        break;
+      case "$gt":
+        params.push(opValue);
+        conditions.push(`${jsonPath} > ?`);
+        break;
+      case "$gte":
+        params.push(opValue);
+        conditions.push(`${jsonPath} >= ?`);
+        break;
+      case "$lt":
+        params.push(opValue);
+        conditions.push(`${jsonPath} < ?`);
+        break;
+      case "$lte":
+        params.push(opValue);
+        conditions.push(`${jsonPath} <= ?`);
+        break;
+      case "$in": {
+        const arr = opValue;
+        if (arr.length === 0) {
+          conditions.push("0");
+        } else {
+          const placeholders = arr.map(() => "?").join(", ");
+          params.push(...arr);
+          conditions.push(`${jsonPath} IN (${placeholders})`);
+        }
+        break;
+      }
+      case "$nin": {
+        const arr = opValue;
+        if (arr.length === 0) {
+        } else {
+          const placeholders = arr.map(() => "?").join(", ");
+          params.push(...arr);
+          conditions.push(`${jsonPath} NOT IN (${placeholders})`);
+        }
+        break;
+      }
+      case "$regex": {
+        const regexStr = typeof opValue === "string" ? opValue : opValue.source;
+        const likePattern = regexToLike(regexStr);
+        params.push(likePattern);
+        conditions.push(`${jsonPath} LIKE ?`);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return conditions.join(" AND ");
+}
+function regexToLike(regex) {
+  let pattern = regex;
+  let prefix = "%";
+  let suffix = "%";
+  if (pattern.startsWith("^")) {
+    prefix = "";
+    pattern = pattern.slice(1);
+  }
+  if (pattern.endsWith("$")) {
+    suffix = "";
+    pattern = pattern.slice(0, -1);
+  }
+  pattern = pattern.replace(/\.\*/g, "%");
+  pattern = pattern.replace(/\./g, "_");
+  return `${prefix}${pattern}${suffix}`;
+}
+
+// src/storage-instance.ts
+function sanitizeTableName(databaseName, collectionName, schemaVersion) {
+  return `${databaseName}_${collectionName}_v${schemaVersion}`.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+var RxStorageInstanceSQLite = class {
+  constructor(storage, params, database) {
+    this.storage = storage;
+    this.database = database;
+    this.databaseName = params.databaseName;
+    this.collectionName = params.collectionName;
+    this.schema = params.schema;
+    this.options = params.options;
+    this.primaryPath = typeof params.schema.primaryKey === "string" ? params.schema.primaryKey : params.schema.primaryKey.key;
+    const tableName = sanitizeTableName(params.databaseName, params.collectionName, params.schema.version);
+    this.internals = { database, tableName };
+    this.createTable();
+  }
+  databaseName;
+  collectionName;
+  schema;
+  internals;
+  options;
+  primaryPath;
+  changes$ = new Subject();
+  closed = false;
+  /**
+   * Create the SQLite table for this collection if it does not exist.
+   * Stores documents as JSON with indexed columns for _deleted, _rev, _meta.lwt and the primary key.
+   */
+  createTable() {
+    this.database.execSync(
+      `CREATE TABLE IF NOT EXISTS "${this.internals.tableName}" (  id TEXT PRIMARY KEY NOT NULL,  data TEXT NOT NULL,  _deleted INTEGER NOT NULL DEFAULT 0,  _meta_lwt REAL NOT NULL DEFAULT 0)`
+    );
+  }
+  /**
+   * Read documents from SQLite by their primary keys.
+   * Returns a Map<primaryKey, RxDocumentData> for use with categorizeBulkWriteRows.
+   */
+  getDocsByIdMap(ids) {
+    const map = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return map;
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.database.getAllSync(
+      `SELECT id, data FROM "${this.internals.tableName}" WHERE id IN (${placeholders})`,
+      ids
+    );
+    for (const row of rows) {
+      const doc = JSON.parse(row.data);
+      map.set(row.id, doc);
+    }
+    return map;
+  }
+  async bulkWrite(documentWrites, context) {
+    if (this.closed) {
+      throw new Error("RxStorageInstanceSQLite: storage is closed");
+    }
+    const ids = documentWrites.map(
+      (row) => row.document[this.primaryPath]
+    );
+    const docsInDb = this.getDocsByIdMap(ids);
+    const categorized = categorizeBulkWriteRows(
+      this,
+      this.primaryPath,
+      docsInDb,
+      documentWrites,
+      context
+    );
+    const error = categorized.errors;
+    for (const row of categorized.bulkInsertDocs) {
+      const doc = row.document;
+      const docId = doc[this.primaryPath];
+      const json = JSON.stringify(doc);
+      this.database.runSync(
+        `INSERT OR REPLACE INTO "${this.internals.tableName}" (id, data, _deleted, _meta_lwt) VALUES (?, ?, ?, ?)`,
+        [docId, json, doc._deleted ? 1 : 0, doc._meta.lwt]
+      );
+    }
+    for (const row of categorized.bulkUpdateDocs) {
+      const doc = row.document;
+      const docId = doc[this.primaryPath];
+      const json = JSON.stringify(doc);
+      this.database.runSync(
+        `UPDATE "${this.internals.tableName}" SET data = ?, _deleted = ?, _meta_lwt = ? WHERE id = ?`,
+        [json, doc._deleted ? 1 : 0, doc._meta.lwt, docId]
+      );
+    }
+    if (categorized.eventBulk.events.length > 0) {
+      const lastState = ensureNotFalsy(categorized.newestRow).document;
+      categorized.eventBulk.checkpoint = {
+        id: lastState[this.primaryPath],
+        lwt: lastState._meta.lwt
+      };
+      this.changes$.next(categorized.eventBulk);
+    }
+    return { error };
+  }
+  async findDocumentsById(ids, withDeleted) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    let sql = `SELECT data FROM "${this.internals.tableName}" WHERE id IN (${placeholders})`;
+    if (!withDeleted) {
+      sql += " AND _deleted = 0";
+    }
+    const rows = this.database.getAllSync(sql, ids);
+    return rows.map((row) => JSON.parse(row.data));
+  }
+  async query(preparedQuery) {
+    const { query } = preparedQuery;
+    try {
+      const { sql, params } = buildQuerySQL(this.internals.tableName, query);
+      const rows = this.database.getAllSync(sql, params);
+      const documents = rows.map(
+        (row) => JSON.parse(row.data)
+      );
+      return { documents };
+    } catch {
+      return this.queryInMemory(query);
+    }
+  }
+  async count(preparedQuery) {
+    const { query } = preparedQuery;
+    try {
+      const { sql, params } = buildCountSQL(this.internals.tableName, query);
+      const rows = this.database.getAllSync(sql, params);
+      if (rows.length > 0 && typeof rows[0].count === "number") {
+        return { count: rows[0].count, mode: "fast" };
+      }
+    } catch {
+    }
+    const result = await this.queryInMemory(query);
+    return { count: result.documents.length, mode: "slow" };
+  }
+  /**
+   * In-memory query fallback using RxDB's built-in query matcher and sort comparator.
+   * Used when the Mango-to-SQL translation fails (e.g., unsupported operators).
+   */
+  async queryInMemory(query) {
+    const rows = this.database.getAllSync(
+      `SELECT data FROM "${this.internals.tableName}" WHERE _deleted = 0`
+    );
+    let documents = rows.map(
+      (row) => JSON.parse(row.data)
+    );
+    const queryMatcher = getQueryMatcher(this.schema, query);
+    documents = documents.filter((doc) => queryMatcher(doc));
+    const sortComparator = getSortComparator(this.schema, query);
+    documents.sort(sortComparator);
+    const skip = query.skip ?? 0;
+    const limit = query.limit ?? Infinity;
+    documents = documents.slice(skip, skip + limit);
+    return { documents };
+  }
+  getAttachmentData(_documentId, _attachmentId, _digest) {
+    throw new Error("Attachments not supported by SQLite storage");
+  }
+  async getChangedDocumentsSince(limit, checkpoint) {
+    let sql;
+    let params;
+    if (checkpoint) {
+      sql = `SELECT data FROM "${this.internals.tableName}" WHERE (_meta_lwt > ?) OR (_meta_lwt = ? AND id > ?) ORDER BY _meta_lwt ASC, id ASC LIMIT ?`;
+      params = [checkpoint.lwt, checkpoint.lwt, checkpoint.id, limit];
+    } else {
+      sql = `SELECT data FROM "${this.internals.tableName}" ORDER BY _meta_lwt ASC, id ASC LIMIT ?`;
+      params = [limit];
+    }
+    const rows = this.database.getAllSync(sql, params);
+    const documents = rows.map(
+      (row) => JSON.parse(row.data)
+    );
+    const lastDoc = documents.length > 0 ? documents[documents.length - 1] : void 0;
+    const newCheckpoint = lastDoc ? {
+      id: lastDoc[this.primaryPath],
+      lwt: lastDoc._meta.lwt
+    } : checkpoint ?? { id: "", lwt: 0 };
+    return {
+      documents,
+      checkpoint: newCheckpoint
+    };
+  }
+  changeStream() {
+    return this.changes$.asObservable();
+  }
+  async cleanup(minimumDeletedTime) {
+    const maxDeletionTime = now() - minimumDeletedTime;
+    this.database.runSync(
+      `DELETE FROM "${this.internals.tableName}" WHERE _deleted = 1 AND _meta_lwt < ?`,
+      [maxDeletionTime]
+    );
+    return true;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.changes$.complete();
+  }
+  async remove() {
+    this.database.execSync(`DROP TABLE IF EXISTS "${this.internals.tableName}"`);
+    await this.close();
+  }
+};
+async function createSQLiteStorageInstance(storage, params, database) {
+  const instance = new RxStorageInstanceSQLite(storage, params, database);
+  return instance;
+}
+
+// src/rx-storage-sqlite.ts
+function getRxStorageSQLite(database) {
+  const storage = {
+    name: "sqlite",
+    rxdbVersion: RXDB_VERSION,
+    createStorageInstance(params) {
+      ensureRxStorageInstanceParamsAreCorrect(params);
+      return createSQLiteStorageInstance(storage, params, database);
+    }
+  };
+  return storage;
+}
+export {
+  getRxStorageSQLite
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@tallyui/storage-sqlite",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "RxDB storage adapter for SQLite via expo-sqlite",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "rxdb": "16.21.1",
+    "rxjs": "7.8.2"
+  },
+  "peerDependencies": {
+    "expo-sqlite": ">=15.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { getRxStorageSQLite } from './rx-storage-sqlite';
+export type { SQLiteDatabase, SQLiteStorageSettings } from './types';

package/src/integration.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Integration test: RxDB -> SQLite storage round-trip.
+ *
+ * Creates a real RxDB database backed by the SQLite storage adapter
+ * (using the mock in-memory SQLite) and proves that documents can
+ * be inserted, queried, and updated through the full RxDB pipeline.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createRxDatabase, addRxPlugin, type RxDatabase, type RxCollection } from 'rxdb';
+import { RxDBDevModePlugin } from 'rxdb/plugins/dev-mode';
+import { wrappedValidateAjvStorage } from 'rxdb/plugins/validate-ajv';
+import { createMockSQLiteDatabase } from './mock-sqlite';
+import { getRxStorageSQLite } from './rx-storage-sqlite';
+
+// Enable dev mode for better error messages in tests
+addRxPlugin(RxDBDevModePlugin);
+
+interface HeroDocType {
+  id: string;
+  name: string;
+  power: number;
+}
+
+type HeroCollection = RxCollection<HeroDocType>;
+type HeroDatabase = RxDatabase<{ heroes: HeroCollection }>;
+
+const heroSchema = {
+  version: 0,
+  primaryKey: 'id',
+  type: 'object' as const,
+  properties: {
+    id: { type: 'string' as const, maxLength: 100 },
+    name: { type: 'string' as const },
+    power: { type: 'number' as const },
+  },
+  required: ['id', 'name', 'power'] as const,
+};
+
+describe('RxDB + SQLite storage integration', () => {
+  let db: HeroDatabase;
+
+  beforeEach(async () => {
+    const mockDb = createMockSQLiteDatabase();
+    const baseStorage = getRxStorageSQLite(mockDb);
+    // Wrap with ajv validator to satisfy dev-mode requirements
+    const storage = wrappedValidateAjvStorage({ storage: baseStorage });
+
+    db = await createRxDatabase<{ heroes: HeroCollection }>({
+      name: 'integration_test_' + Date.now(),
+      storage,
+      multiInstance: false,
+      ignoreDuplicate: true,
+    });
+
+    await db.addCollections({
+      heroes: { schema: heroSchema },
+    });
+  });
+
+  afterEach(async () => {
+    if (db) {
+      await db.close();
+    }
+  });
+
+  it('should insert a document and query it back', async () => {
+    // Insert
+    const doc = await db.heroes.insert({
+      id: 'hero1',
+      name: 'Superman',
+      power: 100,
+    });
+    expect(doc.id).toBe('hero1');
+    expect(doc.name).toBe('Superman');
+
+    // Query back
+    const found = await db.heroes.findOne('hero1').exec();
+    expect(found).not.toBeNull();
+    expect(found!.name).toBe('Superman');
+    expect(found!.power).toBe(100);
+  });
+
+  it('should insert multiple documents and find them all', async () => {
+    await db.heroes.bulkInsert([
+      { id: 'h1', name: 'Batman', power: 80 },
+      { id: 'h2', name: 'Wonder Woman', power: 95 },
+      { id: 'h3', name: 'Flash', power: 90 },
+    ]);
+
+    const all = await db.heroes.find().exec();
+    expect(all).toHaveLength(3);
+
+    const names = all.map((d) => d.name).sort();
+    expect(names).toEqual(['Batman', 'Flash', 'Wonder Woman']);
+  });
+
+  it('should update a document', async () => {
+    const doc = await db.heroes.insert({
+      id: 'hero1',
+      name: 'Superman',
+      power: 100,
+    });
+
+    // Update using RxDB's patch method
+    await doc.patch({ power: 150 });
+
+    // Query back the updated version
+    const updated = await db.heroes.findOne('hero1').exec();
+    expect(updated).not.toBeNull();
+    expect(updated!.power).toBe(150);
+  });
+
+  it('should delete a document', async () => {
+    const doc = await db.heroes.insert({
+      id: 'hero1',
+      name: 'Superman',
+      power: 100,
+    });
+
+    await doc.remove();
+
+    const found = await db.heroes.findOne('hero1').exec();
+    expect(found).toBeNull();
+  });
+
+  it('should support querying by selector', async () => {
+    await db.heroes.bulkInsert([
+      { id: 'h1', name: 'Batman', power: 80 },
+      { id: 'h2', name: 'Superman', power: 100 },
+      { id: 'h3', name: 'Flash', power: 90 },
+    ]);
+
+    // Query for heroes with power > 85
+    // Use in-memory fallback since mock doesn't support json_extract
+    const powerful = await db.heroes.find({
+      selector: { power: { $gt: 85 } },
+    }).exec();
+
+    expect(powerful).toHaveLength(2);
+    const names = powerful.map((d) => d.name).sort();
+    expect(names).toEqual(['Flash', 'Superman']);
+  });
+
+  it('should handle the full create-read-update-delete cycle', async () => {
+    // Create
+    const doc = await db.heroes.insert({
+      id: 'lifecycle',
+      name: 'Temp Hero',
+      power: 50,
+    });
+    expect(doc.id).toBe('lifecycle');
+
+    // Read
+    let found = await db.heroes.findOne('lifecycle').exec();
+    expect(found).not.toBeNull();
+    expect(found!.name).toBe('Temp Hero');
+
+    // Update
+    await found!.patch({ name: 'Updated Hero', power: 75 });
+    found = await db.heroes.findOne('lifecycle').exec();
+    expect(found!.name).toBe('Updated Hero');
+    expect(found!.power).toBe(75);
+
+    // Delete
+    await found!.remove();
+    found = await db.heroes.findOne('lifecycle').exec();
+    expect(found).toBeNull();
+  });
+});