Function waitForReplicaCatchup

packages/db/src/session-consistency.ts:99–151

(
  prismaClient: BarePrismaClient,
  sessionId: string,
)

// Method not used for now,
// Need a way to check LSN on the actual replica that will be used for the read.
async function waitForReplicaCatchup(
  prismaClient: BarePrismaClient,
  sessionId: string,
): Promise<boolean> {
  const expectedLsn = await getCachedWalLsn(sessionId);

  if (!expectedLsn) {
    return true;
  }

  for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
    const currentLsn = await getCurrentWalLsn(prismaClient);
    if (!currentLsn) {
      return true;
    }

    // Check if replica has caught up (current >= expected)
    if (compareWalLsn(currentLsn, expectedLsn) >= 0) {
      logger.debug(
        {
          attempt: attempt + 1,
          currentLsn,
          expectedLsn,
          sessionId,
        },
        'Replica caught up',
      );
      return true;
    }

    // Exponential backoff
    if (attempt < MAX_RETRY_ATTEMPTS - 1) {
      const delayMs = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
      logger.debug(
        {
          attempt: attempt + 1,
          delayMs,
          currentLsn,
          expectedLsn,
          sessionId,
        },
        'Waiting for replica to catch up',
      );
      await sleep(delayMs);
    }
  }

  logger.warn(
    { sessionId, expectedLsn },
    'Replica did not catch up after max retries, falling back to primary',
  );
  return false;
}

/**
 * Prisma extension for session-based read-after-write consistency.