@syncular/server 0.15.46 → 0.15.47

package/src/sqlite-node-driver.ts

@@ -0,0 +1,46 @@
+import { DatabaseSync, type SQLInputValue } from 'node:sqlite';
+import type {
+  SqliteDatabase,
+  SqliteRunResult,
+  SqliteStatement,
+  SqliteValue,
+} from './sqlite-driver';
+
+function bind(value: SqliteValue): SQLInputValue {
+  return typeof value === 'boolean' ? (value ? 1 : 0) : value;
+}
+
+function row<Row>(value: Record<string, unknown> | undefined): Row | null {
+  return (value ?? null) as Row | null;
+}
+
+export class NodeSqliteDatabase implements SqliteDatabase {
+  readonly native: DatabaseSync;
+
+  constructor(path = ':memory:') {
+    this.native = new DatabaseSync(path);
+  }
+
+  exec(sql: string): void {
+    this.native.exec(sql);
+  }
+
+  run(sql: string, bindings: readonly SqliteValue[] = []): SqliteRunResult {
+    return this.native.prepare(sql).run(...bindings.map(bind));
+  }
+
+  query<Row, Params extends readonly SqliteValue[]>(
+    sql: string,
+  ): SqliteStatement<Row, Params> {
+    const statement = this.native.prepare(sql);
+    return {
+      run: (...params) => statement.run(...params.map(bind)),
+      get: (...params) => row<Row>(statement.get(...params.map(bind))),
+      all: (...params) => statement.all(...params.map(bind)) as Row[],
+    };
+  }
+
+  close(): void {
+    this.native.close();
+  }
+}

package/src/sqlite-node.ts

@@ -0,0 +1,62 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SqliteBlobStore as SharedSqliteBlobStore } from './sqlite-blob-store';
+import type { SqliteDatabase } from './sqlite-driver';
+import { type SqliteImageBuilder, writeSqliteImage } from './sqlite-image';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store';
+import { NodeSqliteDatabase } from './sqlite-node-driver';
+import { SqliteSegmentStore as SharedSqliteSegmentStore } from './sqlite-segment-store';
+import { SqliteServerStorage as SharedSqliteServerStorage } from './sqlite-storage';
+
+function database(value: SqliteDatabase | string): SqliteDatabase {
+  return typeof value === 'string' ? new NodeSqliteDatabase(value) : value;
+}
+
+export class SqliteServerStorage extends SharedSqliteServerStorage {
+  constructor(value: SqliteDatabase | string = ':memory:') {
+    super(database(value));
+  }
+}
+
+export class SqliteSegmentStore extends SharedSqliteSegmentStore {
+  constructor(
+    value: SqliteDatabase | string = ':memory:',
+    options?: { ttlMs?: number },
+  ) {
+    super(database(value), options);
+  }
+}
+
+export class SqliteBlobStore extends SharedSqliteBlobStore {
+  constructor(value: SqliteDatabase | string = ':memory:') {
+    super(database(value));
+  }
+}
+
+export class SqliteLeaseStore extends SharedSqliteLeaseStore {
+  constructor(
+    value: SqliteDatabase | string = ':memory:',
+    options?: { readonly leaseId?: () => string },
+  ) {
+    super(database(value), options);
+  }
+}
+
+export const buildSqliteImage: SqliteImageBuilder = (input) => {
+  const directory = mkdtempSync(join(tmpdir(), 'syncular-server-image-'));
+  const path = join(directory, 'segment.db');
+  const db = new NodeSqliteDatabase(path);
+  try {
+    try {
+      writeSqliteImage(db, input);
+    } finally {
+      db.close();
+    }
+    return new Uint8Array(readFileSync(path));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+};
+
+export { NodeSqliteDatabase } from './sqlite-node-driver';

package/src/sqlite-segment-store.ts

@@ -1,13 +1,6 @@
 /**
- * SQLite-backed segment store via `bun:sqlite` (dev/bench convenience,
- * dependency-free). Bun-specific by design: it imports `bun:sqlite` at the
- * top level, so it lives in its own module — importing it opts into the Bun
- * runtime. The runtime-neutral `SegmentStore` interface, `MemorySegmentStore`,
- * and `segmentIdFor` stay in `segment-store.ts` so the Workers/edge core can
- * import them without pulling in `bun:sqlite` (runtime neutrality is enforced
- * by `test/runtime-neutrality.test.ts`).
+ * SQLite-backed segment store over the shared synchronous driver.
  */
-import { Database } from 'bun:sqlite';
 import {
   DEFAULT_SEGMENT_TTL_MS,
   type SegmentFindKey,
@@ -17,16 +10,23 @@ import {
   type SegmentStoreStats,
   segmentIdFor,
 } from './segment-store';
+import {
+  SqliteAdapterRequiredError,
+  type SqliteDatabase,
+} from './sqlite-driver';
 
 export class SqliteSegmentStore implements SegmentStore {
-  readonly db: Database;
+  readonly db: SqliteDatabase;
   #ttlMs: number;
 
   constructor(
-    db: Database | string = ':memory:',
+    db: SqliteDatabase | string = ':memory:',
     options?: { ttlMs?: number },
   ) {
-    this.db = typeof db === 'string' ? new Database(db) : db;
+    if (typeof db === 'string') {
+      throw new SqliteAdapterRequiredError();
+    }
+    this.db = db;
     this.#ttlMs = options?.ttlMs ?? DEFAULT_SEGMENT_TTL_MS;
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS sync_segments(

package/src/sqlite-storage.ts

@@ -1,12 +1,11 @@
 /**
- * SQLite storage via `bun:sqlite` (dev-speed, dependency-free).
+ * SQLite server storage over the shared synchronous driver.
  *
  * Scope fanout is index-first: both the commit log and the
  * current-row table carry a (table, variable, value) inverted index; reads
  * select candidates from the index and verify the full multi-variable
  * match against the stored scope map — never a log scan.
  */
-import { Database } from 'bun:sqlite';
 import {
   bindAuthoritativePartition,
   prepareAuthoritativeQuery,
@@ -45,6 +44,10 @@ import {
   serializePushResult,
   toStoredRow,
 } from './sqlite-dialect';
+import {
+  SqliteAdapterRequiredError,
+  type SqliteDatabase,
+} from './sqlite-driver';
 import type {
   AuthoritativeQueryRequest,
   AuthoritativeQueryResult,
@@ -160,7 +163,7 @@ class SqliteTransaction implements StorageTransaction {
     clientCommitId: string,
   ): Promise<StoredPushResult | undefined> {
     this.#assertOpen();
-    // One shared bun:sqlite connection — this read runs inside this
+    // One shared SQLite connection: this read runs inside this
     // transaction's BEGIN IMMEDIATE.
     return this.#storage.getPushResult(
       this.#partition,
@@ -379,8 +382,8 @@ class SqliteTransaction implements StorageTransaction {
 }
 
 export class SqliteServerStorage implements ServerStorage {
-  readonly db: Database;
-  /** One bun:sqlite connection can own only one transaction at a time. */
+  readonly db: SqliteDatabase;
+  /** One SQLite connection can own only one transaction at a time. */
   #transactionTail: Promise<void> = Promise.resolve();
   /** Set by `ensureSchema`: app-table lookup for the relational row store. */
   #tables: ReadonlyMap<string, CompiledTable> | undefined;
@@ -400,8 +403,11 @@ export class SqliteServerStorage implements ServerStorage {
     }
   }
 
-  constructor(db: Database | string = ':memory:') {
-    this.db = typeof db === 'string' ? new Database(db) : db;
+  constructor(db: SqliteDatabase | string = ':memory:') {
+    if (typeof db === 'string') {
+      throw new SqliteAdapterRequiredError();
+    }
+    this.db = db;
     this.db.exec(SQLITE_DDL);
   }
 

package/src/storage-errors.ts

@@ -52,6 +52,7 @@ export class StorageQueryError extends Error {
 interface DriverError {
   readonly code?: unknown;
   readonly errno?: unknown;
+  readonly errcode?: unknown;
   readonly message?: unknown;
 }
 
@@ -72,7 +73,9 @@ export function isSqliteConstraintError(error: unknown): boolean {
     return true;
   }
   const errno = candidate?.errno;
-  return typeof errno === 'number' && (errno & 0xff) === 19;
+  if (typeof errno === 'number' && (errno & 0xff) === 19) return true;
+  const errcode = candidate?.errcode;
+  return typeof errcode === 'number' && (errcode & 0xff) === 19;
 }
 
 /** PostgreSQL SQLSTATE class 23: integrity constraint violation. */