@syncular/server 0.15.44 → 0.15.46

package/src/push.ts

@@ -33,6 +33,12 @@ import type { SyncRequestContext } from './context';
 import { clockOf } from './context';
 import type { CrdtMergerRegistry } from './crdt-merger';
 import { SyncError } from './errors';
+import { emitEvent } from './events';
+import {
+  prepareReactions,
+  type PreparedReaction,
+  toNewReactions,
+} from './reactions';
 import type { CompiledSchema, CompiledTable } from './schema';
 import type { ResolvedScopes } from './scopes';
 import { authorizeWrite, renderScopeValue, storedScopesForRow } from './scopes';
@@ -837,6 +843,31 @@ export async function processPushCommitWithTrace(
   resolved: ResolvedScopes,
   clientId: string,
   frame: PushCommitFrame,
+): Promise<ProcessedPushCommit> {
+  return processPushOperationsWithTrace(
+    ctx,
+    schema,
+    resolved,
+    clientId,
+    frame.clientCommitId,
+    async () => frame.operations,
+  );
+}
+
+/**
+ * Shared serialized apply path for SSP2 commits and authoritative commands.
+ * The builder runs after the partition lock and idempotency re-check, so its
+ * reads and the returned operations share the transaction that is committed.
+ */
+export async function processPushOperationsWithTrace(
+  ctx: SyncRequestContext,
+  schema: CompiledSchema,
+  resolved: ResolvedScopes,
+  clientId: string,
+  clientCommitId: string,
+  buildOperations: (
+    tx: StorageTransaction,
+  ) => Promise<readonly PushOperation[]>,
 ): Promise<ProcessedPushCommit> {
   const { storage, partition } = ctx;
   let persisted: StoredPushResult | undefined;
@@ -844,7 +875,7 @@ export async function processPushCommitWithTrace(
     persisted = await storage.getPushResult(
       partition,
       clientId,
-      frame.clientCommitId,
+      clientCommitId,
     );
   } catch (error) {
     if (
@@ -854,14 +885,14 @@ export async function processPushCommitWithTrace(
       // §6.3: answer the retryable cache-miss for this commit rather than
       // re-applying. Not persisted — a retry may find a readable record.
       return {
-        frame: idempotencyCacheMissFrame(frame.clientCommitId, error),
+        frame: idempotencyCacheMissFrame(clientCommitId, error),
         replayed: false,
       };
     }
     throw error;
   }
   if (persisted !== undefined) {
-    return processedPushCommit(frame.clientCommitId, persisted, true);
+    return processedPushCommit(clientCommitId, persisted, true);
   }
 
   const createdAtMs = clockOf(ctx)();
@@ -869,6 +900,7 @@ export async function processPushCommitWithTrace(
   const crdtMergers = ctx.crdtMergers;
   const validators = ctx.validators;
   const commitValidator = ctx.commitValidator;
+  const reactionPlanner = ctx.reactionPlanner;
   const tx = await storage.begin(partition);
   const lockPartitionForPush =
     tx.lockPartitionForPush?.bind(tx) ??
@@ -877,10 +909,11 @@ export async function processPushCommitWithTrace(
   try {
     if (
       lockPartitionForPush === undefined ||
-      commitRejectedPushResult === undefined
+      commitRejectedPushResult === undefined ||
+      (reactionPlanner !== undefined && tx.enqueueReactions === undefined)
     ) {
       throw new Error(
-        'storage transaction does not support serialized push apply and atomic rejection finalization',
+        'storage transaction does not support serialized push apply, atomic rejection finalization, and configured durable reactions',
       );
     }
     await lockPartitionForPush();
@@ -895,19 +928,11 @@ export async function processPushCommitWithTrace(
     try {
       const serializedPersisted =
         tx.getPushResult !== undefined
-          ? await tx.getPushResult(clientId, frame.clientCommitId)
-          : await storage.getPushResult(
-              partition,
-              clientId,
-              frame.clientCommitId,
-            );
+          ? await tx.getPushResult(clientId, clientCommitId)
+          : await storage.getPushResult(partition, clientId, clientCommitId);
       if (serializedPersisted !== undefined) {
         await tx.rollback();
-        return processedPushCommit(
-          frame.clientCommitId,
-          serializedPersisted,
-          true,
-        );
+        return processedPushCommit(clientCommitId, serializedPersisted, true);
       }
     } catch (error) {
       if (
@@ -916,7 +941,7 @@ export async function processPushCommitWithTrace(
       ) {
         await tx.rollback();
         return {
-          frame: idempotencyCacheMissFrame(frame.clientCommitId, error),
+          frame: idempotencyCacheMissFrame(clientCommitId, error),
           replayed: false,
         };
       }
@@ -926,8 +951,9 @@ export async function processPushCommitWithTrace(
     const changes: NewChange[] = [];
     const validatedOperations: ValidateCommitOperation[] = [];
     let terminated: PushOperationResult | undefined;
-    for (let opIndex = 0; opIndex < frame.operations.length; opIndex++) {
-      const op = frame.operations[opIndex];
+    const operations = await buildOperations(tx);
+    for (let opIndex = 0; opIndex < operations.length; opIndex++) {
+      const op = operations[opIndex];
       if (op === undefined) continue;
       const outcome = await applyOperation(
         tx,
@@ -956,7 +982,7 @@ export async function processPushCommitWithTrace(
         tx,
         schema,
         clientId,
-        frame.clientCommitId,
+        clientCommitId,
         ctx.actorId,
         partition,
         validatedOperations,
@@ -966,6 +992,18 @@ export async function processPushCommitWithTrace(
       }
     }
 
+    let preparedReactions: PreparedReaction[] = [];
+    if (terminated === undefined && reactionPlanner !== undefined) {
+      preparedReactions = await prepareReactions(reactionPlanner, {
+        clientId,
+        clientCommitId,
+        actorId: ctx.actorId,
+        partition,
+        operations: validatedOperations,
+        read: commitValidationReader(tx, schema),
+      });
+    }
+
     if (terminated !== undefined) {
       // §6.3 rejected: only the terminating operation's record; §6.4:
       // every write of the commit rolls back.
@@ -975,11 +1013,11 @@ export async function processPushCommitWithTrace(
       });
       // Discard candidates and persist the rejection while retaining the same
       // partition lock. There is no unlock gap in which a duplicate can rerun.
-      await commitRejectedPushResult(clientId, frame.clientCommitId, stored);
+      await commitRejectedPushResult(clientId, clientCommitId, stored);
       const canonical = await storage.getPushResult(
         partition,
         clientId,
-        frame.clientCommitId,
+        clientCommitId,
       );
       if (canonical === undefined) {
         throw new Error(
@@ -987,7 +1025,7 @@ export async function processPushCommitWithTrace(
         );
       }
       return processedPushCommit(
-        frame.clientCommitId,
+        clientCommitId,
         canonical,
         canonical.cacheIdentity !== stored.cacheIdentity,
       );
@@ -995,18 +1033,48 @@ export async function processPushCommitWithTrace(
 
     const commitSeq = await tx.appendCommit({
       clientId,
-      clientCommitId: frame.clientCommitId,
+      clientCommitId,
       actorId: ctx.actorId,
       createdAtMs,
       changes,
     });
+    const newReactions = toNewReactions(preparedReactions, {
+      clientId,
+      clientCommitId,
+      commitSeq,
+      createdAtMs,
+    });
+    if (newReactions.length > 0) {
+      const enqueueReactions = tx.enqueueReactions;
+      if (enqueueReactions === undefined) {
+        throw new Error('storage lost durable reaction enqueue support');
+      }
+      await enqueueReactions.call(tx, newReactions);
+    }
     const stored = newStoredPushResult(createdAtMs, {
       status: 'applied',
       commitSeq,
       results,
     });
-    await tx.putPushResult(clientId, frame.clientCommitId, stored);
+    await tx.putPushResult(clientId, clientCommitId, stored);
     await tx.commit();
+    if (ctx.events !== undefined) {
+      const atMs = clockOf(ctx)();
+      for (const reaction of newReactions) {
+        emitEvent(ctx.events, {
+          type: 'reaction.queued',
+          atMs,
+          partition,
+          actorId: ctx.actorId,
+          clientId,
+          clientCommitId,
+          commitSeq,
+          idempotencyKey: reaction.idempotencyKey,
+          reactionType: reaction.type,
+          version: reaction.version,
+        });
+      }
+    }
     if (ctx.realtime !== undefined && changes.length > 0) {
       await ctx.realtime.notifyCommit(partition, {
         commitSeq,
@@ -1015,7 +1083,7 @@ export async function processPushCommitWithTrace(
         changes,
       });
     }
-    return processedPushCommit(frame.clientCommitId, stored, false);
+    return processedPushCommit(clientCommitId, stored, false);
   } catch (error) {
     if (error instanceof StorageConstraintError) {
       const stored = newStoredPushResult(createdAtMs, {
@@ -1037,11 +1105,11 @@ export async function processPushCommitWithTrace(
         );
       }
       try {
-        await commitRejectedPushResult(clientId, frame.clientCommitId, stored);
+        await commitRejectedPushResult(clientId, clientCommitId, stored);
         const canonical = await storage.getPushResult(
           partition,
           clientId,
-          frame.clientCommitId,
+          clientCommitId,
         );
         if (canonical === undefined) {
           throw new Error(
@@ -1049,7 +1117,7 @@ export async function processPushCommitWithTrace(
           );
         }
         return processedPushCommit(
-          frame.clientCommitId,
+          clientCommitId,
           canonical,
           canonical.cacheIdentity !== stored.cacheIdentity,
         );