@syncular/server 0.37.0 → 0.39.0

package/src/sqlite-storage.ts

@@ -2,7 +2,7 @@ import { retainRollbackFailure, rollbackAfterError } from './storage-errors';
 import { validateCommitPruneQuery } from './prune';
 import { StorageQueryError } from './storage-errors';
 import type { CommitPruneQuery, CommitPruneResult } from './storage';
-import { serveGateRefusal } from './storage';
+import { PARTITION_TOUCH_INTERVAL_MS, serveGateRefusal } from './storage';
 import { serveNotReadyError } from './readiness';
 /**
  * SQLite server storage over the shared synchronous driver.
@@ -45,6 +45,9 @@ import {
   type StoredColumnLayout,
   scanRowPageSql,
   schemaDdl,
+  SQLITE_TABLE_INDEXES_SQL,
+  type SqliteTableIndexRow,
+  sqliteIndexSignatures,
   selectRowScopesSql,
   selectRowSql,
   selectRowsForRewriteSql,
@@ -653,10 +656,8 @@ END`);
       // rewrite stored rows (payload re-encode for layout changes, and/or
       // projection backfill for flipped-on materialization). One
       // transaction: a failed bump leaves no half-state.
-      const layouts = parseLayouts(marker?.layouts);
-      const retiredTables = retiredTableNames(schema, layouts);
       const existing = new Map<string, ReadonlySet<string>>();
-      const existingIndexes = new Map<string, ReadonlySet<string>>();
+      const existingIndexes = new Map<string, ReadonlyMap<string, string>>();
       for (const table of schema.tables.values()) {
         const escapedTableName = table.name.replaceAll('"', '""');
         const columns = this.db
@@ -666,15 +667,19 @@ END`);
           .all();
         if (columns.length > 0) {
           existing.set(table.name, new Set(columns.map((c) => c.name)));
-          const indexes = this.db
-            .query<{ name: string; origin: string }, []>(
-              `PRAGMA index_list("${escapedTableName}")`,
-            )
-            .all()
-            .filter((index) => index.origin === 'c');
           existingIndexes.set(
             table.name,
-            new Set(indexes.map((index) => index.name)),
+            new Map(
+              Object.entries(
+                sqliteIndexSignatures(
+                  this.db
+                    .query<SqliteTableIndexRow, [string]>(
+                      SQLITE_TABLE_INDEXES_SQL,
+                    )
+                    .all(table.name),
+                ),
+              ),
+            ),
           );
         }
       }
@@ -686,6 +691,25 @@ END`);
       await this.#serializeWrite(() => {
         this.db.exec('BEGIN IMMEDIATE');
         try {
+          // Another process sharing the database may have bumped between the
+          // marker read above and the writer lock; the locked marker decides
+          // (SPEC "Schema upgrade writer fence").
+          const locked = this.db
+            .query<{ schema_version: number; layouts: string }, []>(
+              'SELECT schema_version, layouts FROM sync_schema_meta WHERE id=1',
+            )
+            .get();
+          if (locked !== null && locked.schema_version > schema.version) {
+            throw new Error(
+              `stored schema version ${locked.schema_version} is newer than the configured schema (${schema.version}) — refusing to run an older server against a migrated database`,
+            );
+          }
+          if (locked !== null && locked.schema_version === schema.version) {
+            this.db.exec('COMMIT');
+            return;
+          }
+          const layouts = parseLayouts(locked?.layouts);
+          const retiredTables = retiredTableNames(schema, layouts);
           for (const tableName of retiredTables) {
             this.db
               .query('DELETE FROM sync_row_scopes WHERE tbl=?')
@@ -763,28 +787,34 @@ END`);
     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);
+    const select = 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=?`,
+    );
+    let row = select.get(partition);
+    if (
+      row === null ||
+      authenticatedAtMs - row.last_authenticated_at_ms >=
+        PARTITION_TOUCH_INTERVAL_MS
+    ) {
+      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);
+      row = select.get(partition);
+    }
     if (row === null)
       throw new Error('partition registry write did not persist');
     return {
@@ -867,7 +897,7 @@ END`);
     oldLayout: readonly StoredColumnLayout[] | undefined,
   ): void {
     const select = selectRowsForRewriteSql(table, 'sqlite');
-    const update = this.db.query(rewriteRowSql(table, 'sqlite'));
+    const update = this.db.query(rewriteRowSql(table));
     const BATCH = 500;
     let afterPartition = '';
     let afterRowId = '';

package/src/storage.ts

@@ -358,6 +358,9 @@ export interface ClientCursorInfo {
 }
 
 /** Durable partition identity refreshed after host authentication (§2.1). */
+/** Longest age of `lastAuthenticatedAtMs` that `touchPartition` leaves unwritten. */
+export const PARTITION_TOUCH_INTERVAL_MS = 60_000;
+
 export interface PartitionRegistryEntry {
   readonly partition: string;
   readonly logEpoch: string;
@@ -651,7 +654,12 @@ export interface ServerStorage {
     checkpoints?: readonly CheckpointDeclaration[],
   ): Promise<void>;
 
-  /** Create or refresh the authenticated partition registry row (§2.1). */
+  /**
+   * Create or refresh the authenticated partition registry row (§2.1). A
+   * row whose `lastAuthenticatedAtMs` is less than
+   * {@link PARTITION_TOUCH_INTERVAL_MS} behind `authenticatedAtMs` is read
+   * back without a write, so a request that only reads takes no write lock.
+   */
   touchPartition(
     partition: string,
     authenticatedAtMs: number,