fix(realtime): unwrap cause for schema codes, drop sleep after final attempt

- isSchemaMismatch now walks the error.cause chain — drizzle wraps the driver
  error, so the SQLSTATE often lives on the inner cause, not the outer throw.
  Without this a wrapped 42703/42P01 was retried 5x and mis-reported as
  "database unreachable" instead of failing fast.
- No longer sleeps after the final failed attempt (~6-10s of dead wait that
  undermined the fail-fast contract); sleep now only happens between attempts.
- Tests: assert sleep is called exactly 4 times on exhaustion, and add a
  wrapped-cause fail-fast case.

Author: waleedlatif1

apps/realtime/src/database/preflight.test.ts

@@ -39,6 +39,11 @@ function pgError(code: string): Error & { code: string } {
   return Object.assign(new Error(`pg error ${code}`), { code })
 }
 
+/** Mirrors how drizzle wraps the driver error: the SQLSTATE lives on `cause`, not the outer error. */
+function wrappedPgError(code: string): Error {
+  return new Error('Failed query', { cause: pgError(code) })
+}
+
 describe('assertSchemaCompatibility', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -69,6 +74,15 @@ describe('assertSchemaCompatibility', () => {
     expect(mockLimit).toHaveBeenCalledTimes(1)
   })
 
+  it('detects a schema mismatch wrapped in error.cause and fails fast', async () => {
+    mockLimit.mockRejectedValue(wrappedPgError('42703'))
+
+    await expect(assertSchemaCompatibility()).rejects.toThrow(/incompatible with the live database/)
+
+    expect(mockLimit).toHaveBeenCalledTimes(1)
+    expect(sleep).not.toHaveBeenCalled()
+  })
+
   it('retries transient connection errors and resolves once reachable', async () => {
     mockLimit
       .mockRejectedValueOnce(pgError('ECONNREFUSED'))
@@ -87,5 +101,6 @@ describe('assertSchemaCompatibility', () => {
     await expect(assertSchemaCompatibility()).rejects.toThrow(/database unreachable/)
 
     expect(mockLimit).toHaveBeenCalledTimes(5)
+    expect(sleep).toHaveBeenCalledTimes(4)
   })
 })

apps/realtime/src/database/preflight.ts

@@ -20,9 +20,22 @@ const MAX_CONNECT_ATTEMPTS = 5
  */
 const SCHEMA_MISMATCH_CODES = new Set(['42703', '42P01', '42883'])
 
+/**
+ * Walks the `cause` chain so a SQLSTATE code is found even when drizzle wraps the
+ * driver error (the code commonly lives on the inner `cause`, not the outer throw).
+ */
 function isSchemaMismatch(error: unknown): boolean {
-  const code = (error as { code?: unknown })?.code
-  return typeof code === 'string' && SCHEMA_MISMATCH_CODES.has(code)
+  const seen = new Set<unknown>()
+  let current: unknown = error
+  while (current && typeof current === 'object' && !seen.has(current)) {
+    seen.add(current)
+    const code = (current as { code?: unknown }).code
+    if (typeof code === 'string' && SCHEMA_MISMATCH_CODES.has(code)) {
+      return true
+    }
+    current = (current as { cause?: unknown }).cause
+  }
+  return false
 }
 
 /**
@@ -66,6 +79,10 @@ export async function assertSchemaCompatibility(): Promise<void> {
         )
       }
 
+      if (attempt === MAX_CONNECT_ATTEMPTS) {
+        break
+      }
+
       const delay = backoffWithJitter(attempt, null)
       logger.warn(
         `Schema-compatibility check could not reach the database (attempt ${attempt}/${MAX_CONNECT_ATTEMPTS}), retrying in ${Math.round(delay)}ms`,