@syncular/server 0.42.2 → 0.44.0

package/dist/d1-storage.js

@@ -1,7 +1,7 @@
 var _a;
 import { validateCommitPruneQuery } from './prune.js';
 import { StorageQueryError } from './storage-errors.js';
-import { clientRoundState, PARTITION_TOUCH_INTERVAL_MS } from './storage.js';
+import { clientRoundState, PARTITION_TOUCH_INTERVAL_MS, rowsLiveAfterDelete, } from './storage.js';
 /**
  * Cloudflare D1 server storage for Workers deployments.
  *
@@ -308,7 +308,7 @@ class D1Transaction {
         }
         return queryAuthoritativeOn(this.#db, this.#partition, this.#prepareQuery(query));
     }
-    async lockPartitionForPush() {
+    async preparePushApply(clientId, clientCommitId, runningSchemaVersion, _targets = []) {
         this.#assertOpen();
         if (!this.#pushApplySerialized) {
             throw new Error('D1 push apply requires externally serialized partition writes');
@@ -316,6 +316,10 @@ class D1Transaction {
         // D1 has no interactive lock. The caller explicitly asserted that every
         // write for this partition is already serialized (normally by its DO).
         this.#pushApplyCheckpoint = this.#buffer.length;
+        return {
+            gate: await this.readServeGate(runningSchemaVersion),
+            persisted: await this.getPushResult(clientId, clientCommitId),
+        };
     }
     advanceCheckpoint(_name, _ownerEpoch, _watermark, _observedRows, _nowMs) {
         // D1 installs no fence and declares no checkpoints in this release.
@@ -345,6 +349,9 @@ class D1Transaction {
         this.#applicationOpIndexes.clear();
         await this.putPushResult(clientId, clientCommitId, result);
         await this.commit();
+        // The idempotency re-check found no record under the serialized apply, so
+        // the insert above is the canonical outcome.
+        return result;
     }
     async #assertNoUniqueCollision(table, row, opIndex) {
         if (!table.materialize)
@@ -480,6 +487,7 @@ class D1Transaction {
             commit.actorId,
             commit.createdAtMs,
         ]);
+        const liveAfterDelete = rowsLiveAfterDelete(commit.changes);
         commit.changes.forEach((change, idx) => {
             this.#buffer_('INSERT INTO sync_changes(partition, commit_seq, idx, tbl, row_id, op, row_version, scopes, payload) VALUES (?,?,?,?,?,?,?,?,?)', [
                 p,
@@ -492,9 +500,11 @@ class D1Transaction {
                 JSON.stringify(change.scopes),
                 change.payload ?? null,
             ]);
-            if (change.op === 'delete') {
+            if (change.op === 'delete' &&
+                !liveAfterDelete.has(`${change.table}\u0000${change.rowId}`)) {
                 // §5 delete precedence: every applied delete leaves a tombstone,
-                // pruned with the commit log (§4.6).
+                // pruned with the commit log (§4.6). A delete that the same commit
+                // follows with an upsert is a §2.2 scope move, not a deletion.
                 this.#buffer_(`INSERT INTO sync_tombstones(partition, tbl, row_id, commit_seq) VALUES (?,?,?,?)
            ON CONFLICT(partition, tbl, row_id) DO UPDATE SET commit_seq=excluded.commit_seq`, [p, change.table, change.rowId, commitSeq]);
             }

package/dist/operations.d.ts

@@ -51,6 +51,11 @@ export type CommandMutation = {
     readonly table: string;
     readonly op: 'upsert';
     readonly values: Readonly<Record<string, RowValue>>;
+} | {
+    readonly table: string;
+    readonly op: 'rescope';
+    /** Full row; only its scope columns may differ from the stored row. */
+    readonly values: Readonly<Record<string, RowValue>>;
 } | {
     readonly table: string;
     readonly op: 'delete';

package/dist/operations.js

@@ -256,23 +256,23 @@ function commandOperations(mutations, schema) {
         const supplied = new Set(Object.keys(mutation.values));
         for (const name of supplied) {
             if (!table.columnIndex.has(name)) {
-                throw syncError('operation.invalid_request', 'command upsert has an unknown column');
+                throw syncError('operation.invalid_request', 'command upsert or rescope has an unknown column');
             }
         }
         const values = table.columns.map((column) => {
             if (!supplied.has(column.name)) {
-                throw syncError('operation.invalid_request', 'command upsert must provide a full row');
+                throw syncError('operation.invalid_request', 'command upsert or rescope must provide a full row');
             }
             return mutation.values[column.name] ?? null;
         });
         const rowId = renderScopeValue(values[table.primaryKeyIndex]);
         if (rowId === undefined) {
-            throw syncError('operation.invalid_request', 'command upsert requires a non-empty primary key');
+            throw syncError('operation.invalid_request', 'command upsert or rescope requires a non-empty primary key');
         }
         return {
             table: table.name,
             rowId,
-            op: 'upsert',
+            op: mutation.op,
             payload: encodeSparseRow(table.columns, table.primaryKeyIndex, values),
         };
     });