@syncular/server 0.15.46 → 0.15.48

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,
@@ -59,6 +62,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -160,7 +164,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 +383,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,9 +404,20 @@ 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);
+    const clientColumns = this.db
+      .query<{ name: string }, []>('PRAGMA table_info("sync_clients")')
+      .all();
+    if (!clientColumns.some((column) => column.name === 'wire_version')) {
+      this.db.exec(
+        'ALTER TABLE sync_clients ADD COLUMN wire_version INTEGER NOT NULL DEFAULT 1',
+      );
+    }
   }
 
   /** Resolve a table's compiled schema; row operations require `ensureSchema`. */
@@ -498,6 +513,106 @@ export class SqliteServerStorage implements ServerStorage {
     this.#schemaVersion = schema.version;
   }
 
+  async touchPartition(
+    partition: string,
+    authenticatedAtMs: number,
+    initialLogEpoch: string,
+  ): Promise<PartitionRegistryEntry> {
+    if (initialLogEpoch.length === 0) {
+      throw new Error('initial log epoch must be non-empty');
+    }
+    this.db
+      .query(
+        `INSERT INTO sync_partition_registry(
+           partition, log_epoch, last_authenticated_at_ms
+         ) VALUES (?,?,?)
+         ON CONFLICT(partition) DO UPDATE SET
+           last_authenticated_at_ms=excluded.last_authenticated_at_ms`,
+      )
+      .run(partition, initialLogEpoch, authenticatedAtMs);
+    const row = this.db
+      .query<
+        {
+          log_epoch: string;
+          epoch_required: number;
+          last_authenticated_at_ms: number;
+        },
+        [string]
+      >(
+        `SELECT log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry WHERE partition=?`,
+      )
+      .get(partition);
+    if (row === null)
+      throw new Error('partition registry write did not persist');
+    return {
+      partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required === 1,
+      lastAuthenticatedAtMs: row.last_authenticated_at_ms,
+    };
+  }
+
+  async rotatePartitionLogEpoch(
+    partition: string,
+    logEpoch: string,
+    authenticatedAtMs: number,
+  ): Promise<PartitionRegistryEntry> {
+    if (logEpoch.length === 0) throw new Error('log epoch must be non-empty');
+    return this.#serializeReactionWrite(() => {
+      this.db.exec('BEGIN IMMEDIATE');
+      try {
+        this.db
+          .query(
+            `INSERT INTO sync_partition_registry(
+               partition, log_epoch, epoch_required, last_authenticated_at_ms
+             ) VALUES (?,?,1,?)
+             ON CONFLICT(partition) DO UPDATE SET
+               log_epoch=excluded.log_epoch,
+               epoch_required=1,
+               last_authenticated_at_ms=excluded.last_authenticated_at_ms`,
+          )
+          .run(partition, logEpoch, authenticatedAtMs);
+        this.db
+          .query('DELETE FROM sync_clients WHERE partition=?')
+          .run(partition);
+        this.db.exec('COMMIT');
+      } catch (error) {
+        this.db.exec('ROLLBACK');
+        throw error;
+      }
+      return {
+        partition,
+        logEpoch,
+        epochRequired: true,
+        lastAuthenticatedAtMs: authenticatedAtMs,
+      };
+    });
+  }
+
+  async listPartitionRegistry(): Promise<PartitionRegistryEntry[]> {
+    return this.db
+      .query<
+        {
+          partition: string;
+          log_epoch: string;
+          epoch_required: number;
+          last_authenticated_at_ms: number;
+        },
+        []
+      >(
+        `SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+           FROM sync_partition_registry ORDER BY partition`,
+      )
+      .all()
+      .map((row) => ({
+        partition: row.partition,
+        logEpoch: row.log_epoch,
+        epochRequired: row.epoch_required === 1,
+        lastAuthenticatedAtMs: row.last_authenticated_at_ms,
+      }));
+  }
+
   /**
    * Migration rewrite: keyset-paged walk of a row table. When `oldLayout` is
    * given every payload re-encodes under
@@ -1071,19 +1186,21 @@ export class SqliteServerStorage implements ServerStorage {
         {
           client_id: string;
           actor_id: string;
+          wire_version: number;
           cursor: number;
           subscriptions: string;
           updated_at_ms: number;
         },
         [string, string]
       >(
-        'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?',
+        'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? AND client_id=?',
       )
       .get(partition, clientId);
     if (record === null) return undefined;
     return {
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: record.wire_version,
       cursor: record.cursor,
       updatedAtMs: record.updated_at_ms,
       subscriptions: JSON.parse(record.subscriptions) as ClientSubscription[],
@@ -1096,12 +1213,13 @@ export class SqliteServerStorage implements ServerStorage {
   ): Promise<void> {
     this.db
       .query(
-        'INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?)',
+        'INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?,?)',
       )
       .run(
         partition,
         record.clientId,
         record.actorId,
+        record.wireVersion,
         record.cursor,
         JSON.stringify(record.subscriptions),
         record.updatedAtMs,
@@ -1181,18 +1299,20 @@ export class SqliteServerStorage implements ServerStorage {
         {
           client_id: string;
           actor_id: string;
+          wire_version: number;
           cursor: number;
           subscriptions: string;
           updated_at_ms: number;
         },
         [string]
       >(
-        'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC',
+        'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=? ORDER BY updated_at_ms DESC',
       )
       .all(partition);
     return records.map((record) => ({
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: record.wire_version,
       cursor: record.cursor,
       updatedAtMs: record.updated_at_ms,
       subscriptions: JSON.parse(record.subscriptions) as ClientSubscription[],
@@ -1318,14 +1438,6 @@ export class SqliteServerStorage implements ServerStorage {
   }
 
   async listPartitions(): Promise<string[]> {
-    // Union: the registry row appears on first commit, the client row on
-    // first pull — a partition with only one of the two still shows up.
-    const rows = this.db
-      .query<{ partition: string }, []>(
-        `SELECT partition FROM sync_partitions
-         UNION SELECT partition FROM sync_clients ORDER BY partition`,
-      )
-      .all();
-    return rows.map((r) => r.partition);
+    return (await this.listPartitionRegistry()).map((entry) => entry.partition);
   }
 }

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. */

package/src/storage.ts

@@ -164,6 +164,8 @@ export interface ClientSubscription {
 export interface ClientRecord {
   readonly clientId: string;
   readonly actorId: string;
+  /** SSP2 version last accepted from this client; selects realtime deltas. */
+  readonly wireVersion: number;
   /** Minimum `nextCursor` across the last pull's active subscriptions. */
   readonly cursor: number;
   readonly updatedAtMs: number;
@@ -220,6 +222,14 @@ export interface ClientCursorInfo {
   readonly updatedAtMs: number;
 }
 
+/** Durable partition identity refreshed after host authentication (§2.1). */
+export interface PartitionRegistryEntry {
+  readonly partition: string;
+  readonly logEpoch: string;
+  readonly epochRequired: boolean;
+  readonly lastAuthenticatedAtMs: number;
+}
+
 /**
  * Commit-log metadata (no change payloads) for the admin/console read
  * surface. `changeCount` is the number of changes the commit carries;
@@ -397,6 +407,21 @@ export interface ServerStorage {
    */
   ensureSchema(schema: CompiledSchema): Promise<void>;
 
+  /** Create or refresh the authenticated partition registry row (§2.1). */
+  touchPartition(
+    partition: string,
+    authenticatedAtMs: number,
+    initialLogEpoch: string,
+  ): Promise<PartitionRegistryEntry>;
+  /** Rotate log continuity after restore and discard stale cursor records. */
+  rotatePartitionLogEpoch(
+    partition: string,
+    logEpoch: string,
+    authenticatedAtMs: number,
+  ): Promise<PartitionRegistryEntry>;
+  /** Registry entries ordered by partition for maintenance loops. */
+  listPartitionRegistry(): Promise<PartitionRegistryEntry[]>;
+
   begin(partition: string): Promise<StorageTransaction>;
 
   getMaxCommitSeq(partition: string): Promise<number>;
@@ -551,10 +576,8 @@ export interface ServerStorage {
    * change scope index (never a log scan).
    * `getRowScopes`: the (table, rowId) row's current server_version and
    * stored scopes without decoding its payload — the row inspector.
-   * `listPartitions`: every partition this storage holds state for — the
-   * union of the partition registry (commit log counters) and client
-   * records, sorted. Powers the console's fleet view / partition picker;
-   * deliberately NOT partition-scoped (the one cross-partition read).
+   * `listPartitions`: the partition-only compatibility view of
+   * `listPartitionRegistry`, sorted.
    */
   listClientRecords?(partition: string): Promise<ClientRecord[]>;
   listCommitMetadata?(
@@ -572,7 +595,7 @@ export interface ServerStorage {
   ): Promise<
     { serverVersion: number; scopes: Record<string, string> } | undefined
   >;
-  listPartitions?(): Promise<string[]>;
+  listPartitions(): Promise<string[]>;
 }
 
 /** A row referencing a blob, with the scopes needed to authorize download. */