@syncular/server-hono 0.0.6-184 → 0.0.6-188

package/src/routes.ts

@@ -17,7 +17,9 @@ import {
   ScopeValuesSchema,
   SyncCombinedRequestSchema,
   SyncCombinedResponseSchema,
+  type SyncPushCommitRequestSchema,
   SyncPushRequestSchema,
+  type SyncPushResponse,
 } from '@syncular/core';
 import type {
   ScopeCacheBackend,
@@ -42,6 +44,7 @@ import {
   parseJsonValue,
   pull,
   pushCommit,
+  pushCommitBatch,
   readSnapshotChunk,
   recordClientCursor,
   resolveEffectiveScopesForSubscriptions,
@@ -880,8 +883,8 @@ export function createSyncRoutes<
   };
 
   type PushRequestBody = Omit<
-    z.infer<typeof SyncPushRequestSchema>,
-    'clientId'
+    z.infer<typeof SyncPushCommitRequestSchema>,
+    never
   >;
 
   type PushExecutionContext = {
@@ -894,11 +897,291 @@ export function createSyncRoutes<
     syncPath: 'http-combined' | 'ws-push';
   };
 
+  type ExecutedPushCommit = Awaited<ReturnType<typeof pushCommit>>;
+
+  type PushExecutionSummary = {
+    durationMs: number;
+    outcome: string;
+    commitSeq: number | null;
+    operationCount: number;
+    tables: string[];
+    results: SyncPushResponse['results'];
+    payloadSnapshot: RequestPayloadSnapshot | null;
+  };
+
+  function notifyRealtimeForAppliedPushes(
+    ctx: PushExecutionContext,
+    pushedCommits: ExecutedPushCommit[]
+  ): void {
+    if (!wsConnectionManager && !realtimeBroadcaster) {
+      return;
+    }
+
+    let latestCommitSeq = 0;
+    let latestActorId = ctx.auth.actorId;
+    let latestCreatedAt: string | undefined;
+    const scopeKeys = new Set<string>();
+    const emittedChanges: ExecutedPushCommit['emittedChanges'] = [];
+
+    for (const pushed of pushedCommits) {
+      if (
+        pushed.response.ok !== true ||
+        pushed.response.status !== 'applied' ||
+        typeof pushed.response.commitSeq !== 'number'
+      ) {
+        continue;
+      }
+
+      latestCommitSeq = Math.max(latestCommitSeq, pushed.response.commitSeq);
+      latestActorId = pushed.commitActorId ?? latestActorId;
+      latestCreatedAt = pushed.commitCreatedAt ?? latestCreatedAt;
+      for (const scopeKey of applyPartitionToScopeKeys(
+        ctx.partitionId,
+        pushed.scopeKeys
+      )) {
+        scopeKeys.add(scopeKey);
+      }
+      emittedChanges.push(...pushed.emittedChanges);
+    }
+
+    if (latestCommitSeq <= 0 || scopeKeys.size === 0) {
+      return;
+    }
+
+    const combinedScopeKeys = Array.from(scopeKeys);
+
+    if (wsConnectionManager) {
+      wsConnectionManager.notifyScopeKeys(combinedScopeKeys, latestCommitSeq, {
+        excludeClientIds: [ctx.clientId],
+        changes: emittedChanges,
+        actorId: latestActorId,
+        createdAt: latestCreatedAt,
+      });
+    }
+
+    if (realtimeBroadcaster) {
+      realtimeBroadcaster
+        .publish({
+          type: 'commit',
+          commitSeq: latestCommitSeq,
+          partitionId: ctx.partitionId,
+          scopeKeys: combinedScopeKeys,
+          sourceInstanceId: instanceId,
+        })
+        .catch((error) => {
+          logAsyncFailureOnce('sync.realtime.broadcast_publish_failed', {
+            event: 'sync.realtime.broadcast_publish_failed',
+            userId: ctx.auth.actorId,
+            clientId: ctx.clientId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+    }
+  }
+
+  function recordPushExecutionSideEffects(
+    ctx: PushExecutionContext,
+    summary: PushExecutionSummary
+  ): void {
+    recordRequestEventInBackground(() => ({
+      partitionId: ctx.partitionId,
+      requestId: ctx.requestId,
+      traceId: ctx.traceContext.traceId,
+      spanId: ctx.traceContext.spanId,
+      eventType: 'push',
+      syncPath: ctx.syncPath,
+      actorId: ctx.auth.actorId,
+      clientId: ctx.clientId,
+      transportPath: ctx.transportPath,
+      statusCode: 200,
+      outcome: summary.outcome,
+      responseStatus: normalizeResponseStatus(200, summary.outcome),
+      durationMs: summary.durationMs,
+      errorCode: firstPushErrorCode(summary.results),
+      commitSeq: summary.commitSeq,
+      operationCount: summary.operationCount,
+      tables: summary.tables,
+      payloadSnapshot: summary.payloadSnapshot,
+    }));
+
+    emitConsoleLiveEvent(consoleLiveEmitter, 'push', () => ({
+      partitionId: ctx.partitionId,
+      requestId: ctx.requestId,
+      traceId: ctx.traceContext.traceId,
+      spanId: ctx.traceContext.spanId,
+      actorId: ctx.auth.actorId,
+      clientId: ctx.clientId,
+      transportPath: ctx.transportPath,
+      syncPath: ctx.syncPath,
+      outcome: summary.outcome,
+      statusCode: 200,
+      durationMs: summary.durationMs,
+      commitSeq: summary.commitSeq,
+      operationCount: summary.operationCount,
+      tables: summary.tables,
+    }));
+  }
+
+  function maybeCountPushConflicts(
+    ctx: PushExecutionContext,
+    results: SyncPushResponse['results'],
+    enabled?: boolean
+  ): void {
+    if (enabled !== true) {
+      return;
+    }
+
+    const detectedConflicts = results.reduce(
+      (count, result) => count + (result.status === 'conflict' ? 1 : 0),
+      0
+    );
+    if (detectedConflicts <= 0) {
+      return;
+    }
+
+    countSyncMetric('sync.conflicts.detected', detectedConflicts, {
+      attributes: {
+        syncPath: ctx.syncPath,
+        transportPath: ctx.transportPath,
+      },
+    });
+  }
+
+  function emitCommitLiveEvents(
+    ctx: PushExecutionContext,
+    pushedCommits: ExecutedPushCommit[]
+  ): void {
+    for (const pushed of pushedCommits) {
+      if (
+        pushed.response.ok !== true ||
+        pushed.response.status !== 'applied' ||
+        typeof pushed.response.commitSeq !== 'number'
+      ) {
+        continue;
+      }
+
+      emitConsoleLiveEvent(consoleLiveEmitter, 'commit', () => ({
+        partitionId: ctx.partitionId,
+        commitSeq: pushed.response.commitSeq,
+        actorId: ctx.auth.actorId,
+        clientId: ctx.clientId,
+        affectedTables: pushed.affectedTables,
+      }));
+    }
+  }
+
+  async function executePushCommitBatchWithSideEffects(
+    ctx: PushExecutionContext,
+    pushBodies: PushRequestBody[],
+    execOptions: {
+      countConflictsMetric?: boolean;
+    } = {}
+  ): Promise<ExecutedPushCommit[]> {
+    const timer = createSyncTimer();
+    const totalOperationCount = pushBodies.reduce(
+      (count, pushBody) => count + (pushBody.operations?.length ?? 0),
+      0
+    );
+    const executedPushes = await pushCommitBatch({
+      db: options.db,
+      dialect: options.dialect,
+      handlers: handlerRegistry,
+      plugins: options.plugins,
+      auth: ctx.auth,
+      suppressTelemetry: true,
+      requests: pushBodies.map((pushBody) => ({
+        clientId: ctx.clientId,
+        clientCommitId: pushBody.clientCommitId,
+        operations: pushBody.operations,
+        schemaVersion: pushBody.schemaVersion,
+      })),
+    });
+    const affectedTables = new Set<string>();
+    for (const pushed of executedPushes) {
+      for (const table of pushed.affectedTables) {
+        affectedTables.add(table);
+      }
+    }
+
+    const pushDurationMs = timer();
+    const latestCommitSeq = executedPushes.reduce((latest, pushed) => {
+      if (typeof pushed.response.commitSeq === 'number') {
+        return Math.max(latest, pushed.response.commitSeq);
+      }
+      return latest;
+    }, 0);
+    const aggregateStatus = executedPushes.every(
+      (pushed) => pushed.response.status === 'cached'
+    )
+      ? 'cached'
+      : executedPushes.every(
+            (pushed) =>
+              pushed.response.status === 'applied' ||
+              pushed.response.status === 'cached'
+          )
+        ? 'applied'
+        : 'rejected';
+    const aggregatedResults = executedPushes.flatMap(
+      (pushed) => pushed.response.results
+    );
+
+    logSyncEvent({
+      event: 'sync.push',
+      userId: ctx.auth.actorId,
+      durationMs: pushDurationMs,
+      operationCount: totalOperationCount,
+      status: aggregateStatus,
+      commitSeq: latestCommitSeq > 0 ? latestCommitSeq : undefined,
+    });
+
+    recordPushExecutionSideEffects(ctx, {
+      durationMs: pushDurationMs,
+      outcome: aggregateStatus,
+      commitSeq: latestCommitSeq > 0 ? latestCommitSeq : null,
+      operationCount: totalOperationCount,
+      tables: Array.from(affectedTables),
+      results: aggregatedResults,
+      payloadSnapshot: shouldCaptureRequestPayloadSnapshots
+        ? {
+            request: {
+              clientId: ctx.clientId,
+              commits: pushBodies.map((pushBody) => ({
+                clientCommitId: pushBody.clientCommitId,
+                schemaVersion: pushBody.schemaVersion,
+                operations: pushBody.operations,
+              })),
+            },
+            response: {
+              ok: true,
+              commits: executedPushes.map((pushed, index) => ({
+                clientCommitId: pushBodies[index]?.clientCommitId ?? '',
+                ...pushed.response,
+              })),
+            },
+          }
+        : null,
+    });
+
+    maybeCountPushConflicts(
+      ctx,
+      aggregatedResults,
+      execOptions.countConflictsMetric
+    );
+
+    notifyRealtimeForAppliedPushes(ctx, executedPushes);
+    emitCommitLiveEvents(ctx, executedPushes);
+
+    return executedPushes;
+  }
+
   async function executePushCommitWithSideEffects(
     ctx: PushExecutionContext,
     pushBody: PushRequestBody,
-    execOptions: { countConflictsMetric?: boolean } = {}
-  ): Promise<Awaited<ReturnType<typeof pushCommit>>> {
+    execOptions: {
+      countConflictsMetric?: boolean;
+      deferRealtimeNotifications?: boolean;
+    } = {}
+  ): Promise<ExecutedPushCommit> {
     const timer = createSyncTimer();
     const pushOps = pushBody.operations ?? [];
 
@@ -927,24 +1210,13 @@ export function createSyncRoutes<
       commitSeq: pushed.response.commitSeq,
     });
 
-    recordRequestEventInBackground(() => ({
-      partitionId: ctx.partitionId,
-      requestId: ctx.requestId,
-      traceId: ctx.traceContext.traceId,
-      spanId: ctx.traceContext.spanId,
-      eventType: 'push',
-      syncPath: ctx.syncPath,
-      actorId: ctx.auth.actorId,
-      clientId: ctx.clientId,
-      transportPath: ctx.transportPath,
-      statusCode: 200,
-      outcome: pushed.response.status,
-      responseStatus: normalizeResponseStatus(200, pushed.response.status),
+    recordPushExecutionSideEffects(ctx, {
       durationMs: pushDurationMs,
-      errorCode: firstPushErrorCode(pushed.response.results),
-      commitSeq: pushed.response.commitSeq,
+      outcome: pushed.response.status,
+      commitSeq: pushed.response.commitSeq ?? null,
       operationCount: pushOps.length,
       tables: pushed.affectedTables,
+      results: pushed.response.results,
       payloadSnapshot: shouldCaptureRequestPayloadSnapshots
         ? {
             request: {
@@ -956,97 +1228,18 @@ export function createSyncRoutes<
             response: pushed.response,
           }
         : null,
-    }));
-
-    emitConsoleLiveEvent(consoleLiveEmitter, 'push', () => ({
-      partitionId: ctx.partitionId,
-      requestId: ctx.requestId,
-      traceId: ctx.traceContext.traceId,
-      spanId: ctx.traceContext.spanId,
-      actorId: ctx.auth.actorId,
-      clientId: ctx.clientId,
-      transportPath: ctx.transportPath,
-      syncPath: ctx.syncPath,
-      outcome: pushed.response.status,
-      statusCode: 200,
-      durationMs: pushDurationMs,
-      commitSeq: pushed.response.commitSeq ?? null,
-      operationCount: pushOps.length,
-      tables: pushed.affectedTables,
-    }));
-
-    if (execOptions.countConflictsMetric === true) {
-      const detectedConflicts = pushed.response.results.reduce(
-        (count, result) => count + (result.status === 'conflict' ? 1 : 0),
-        0
-      );
-      if (detectedConflicts > 0) {
-        countSyncMetric('sync.conflicts.detected', detectedConflicts, {
-          attributes: {
-            syncPath: ctx.syncPath,
-            transportPath: ctx.transportPath,
-          },
-        });
-      }
-    }
-
-    if (
-      wsConnectionManager &&
-      pushed.response.ok === true &&
-      pushed.response.status === 'applied' &&
-      typeof pushed.response.commitSeq === 'number'
-    ) {
-      const scopeKeys = applyPartitionToScopeKeys(
-        ctx.partitionId,
-        pushed.scopeKeys
-      );
-
-      if (scopeKeys.length > 0) {
-        wsConnectionManager.notifyScopeKeys(
-          scopeKeys,
-          pushed.response.commitSeq,
-          {
-            excludeClientIds: [ctx.clientId],
-            changes: pushed.emittedChanges,
-            actorId: pushed.commitActorId ?? ctx.auth.actorId,
-            createdAt: pushed.commitCreatedAt ?? new Date().toISOString(),
-          }
-        );
+    });
 
-        if (realtimeBroadcaster) {
-          realtimeBroadcaster
-            .publish({
-              type: 'commit',
-              commitSeq: pushed.response.commitSeq,
-              partitionId: ctx.partitionId,
-              scopeKeys,
-              sourceInstanceId: instanceId,
-            })
-            .catch((error) => {
-              logAsyncFailureOnce('sync.realtime.broadcast_publish_failed', {
-                event: 'sync.realtime.broadcast_publish_failed',
-                userId: ctx.auth.actorId,
-                clientId: ctx.clientId,
-                error: error instanceof Error ? error.message : String(error),
-              });
-            });
-        }
-      }
-    }
+    maybeCountPushConflicts(
+      ctx,
+      pushed.response.results,
+      execOptions.countConflictsMetric
+    );
 
-    if (
-      pushed.response.ok === true &&
-      pushed.response.status === 'applied' &&
-      typeof pushed.response.commitSeq === 'number'
-    ) {
-      emitConsoleLiveEvent(consoleLiveEmitter, 'commit', () => ({
-        partitionId: ctx.partitionId,
-        commitSeq: pushed.response.commitSeq,
-        actorId: ctx.auth.actorId,
-        clientId: ctx.clientId,
-        affectedTables: pushed.affectedTables,
-      }));
+    if (execOptions.deferRealtimeNotifications !== true) {
+      notifyRealtimeForAppliedPushes(ctx, [pushed]);
     }
+    emitCommitLiveEvents(ctx, [pushed]);
 
     return pushed;
   }
@@ -1465,36 +1658,85 @@ export function createSyncRoutes<
 
       let pushResponse:
         | undefined
-        | Awaited<ReturnType<typeof pushCommit>>['response'];
+        | {
+            ok: true;
+            commits: Array<
+              Awaited<ReturnType<typeof pushCommit>>['response'] & {
+                clientCommitId: string;
+              }
+            >;
+          };
       let pullResponse: undefined | PullResult['response'];
 
       // --- Push phase ---
       if (body.push) {
-        const pushBody = body.push;
-        const pushOps = pushBody.operations ?? [];
-        if (pushOps.length > maxOperationsPerPush) {
-          return c.json(
-            {
-              error: 'TOO_MANY_OPERATIONS',
-              message: `Maximum ${maxOperationsPerPush} operations per push`,
-            },
-            400
-          );
+        const pushBodies = body.push.commits ?? [];
+        const pushedCommits: NonNullable<typeof pushResponse>['commits'] = [];
+        for (const pushBody of pushBodies) {
+          const pushOps = pushBody.operations ?? [];
+          if (pushOps.length > maxOperationsPerPush) {
+            return c.json(
+              {
+                error: 'TOO_MANY_OPERATIONS',
+                message: `Maximum ${maxOperationsPerPush} operations per push`,
+              },
+              400
+            );
+          }
+        }
+        const executedPushes =
+          pushBodies.length > 1
+            ? await executePushCommitBatchWithSideEffects(
+                {
+                  auth,
+                  clientId,
+                  partitionId,
+                  requestId,
+                  traceContext,
+                  transportPath,
+                  syncPath: 'http-combined',
+                },
+                pushBodies,
+                {
+                  countConflictsMetric: true,
+                }
+              )
+            : [];
+
+        for (let index = 0; index < pushBodies.length; index += 1) {
+          const pushBody = pushBodies[index];
+          if (!pushBody) continue;
+          const pushed =
+            pushBodies.length > 1
+              ? executedPushes[index]
+              : await executePushCommitWithSideEffects(
+                  {
+                    auth,
+                    clientId,
+                    partitionId,
+                    requestId,
+                    traceContext,
+                    transportPath,
+                    syncPath: 'http-combined',
+                  },
+                  pushBody,
+                  {
+                    countConflictsMetric: true,
+                  }
+                );
+          if (!pushed) {
+            throw new Error('Server returned incomplete batched push result');
+          }
+          pushedCommits.push({
+            clientCommitId: pushBody.clientCommitId,
+            ...pushed.response,
+          });
         }
-        const pushed = await executePushCommitWithSideEffects(
-          {
-            auth,
-            clientId,
-            partitionId,
-            requestId,
-            traceContext,
-            transportPath,
-            syncPath: 'http-combined',
-          },
-          pushBody
-        );
 
-        pushResponse = pushed.response;
+        pushResponse = {
+          ok: true,
+          commits: pushedCommits,
+        };
       }
 
       // --- Pull phase ---