orez 0.2.12 → 0.2.14

package/src/replication/handler.test.ts

@@ -4,8 +4,10 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import { Mutex } from '../mutex'
 import { installChangeTracking } from './change-tracker'
 import {
+  extractStartLsn,
   handleReplicationQuery,
   handleStartReplication,
+  lsnFromString,
   resetReplicationState,
   signalReplicationChange,
   type ReplicationWriter,
@@ -404,3 +406,71 @@ describe('InProcessWriter', () => {
     expect(rw.closed).toBe(false)
   })
 })
+
+describe('lsnFromString', () => {
+  it('parses 0/0 to 0n', () => {
+    expect(lsnFromString('0/0')).toBe(0n)
+  })
+
+  it('parses simple LSN', () => {
+    expect(lsnFromString('0/1000000')).toBe(0x1000000n)
+  })
+
+  it('combines high and low halves', () => {
+    expect(lsnFromString('1/0')).toBe(0x100000000n)
+    expect(lsnFromString('1/1')).toBe(0x100000001n)
+    expect(lsnFromString('A/B')).toBe(0xa0000000bn)
+  })
+
+  it('is case-insensitive', () => {
+    expect(lsnFromString('0/ff')).toBe(0xffn)
+    expect(lsnFromString('0/FF')).toBe(0xffn)
+  })
+
+  it('tolerates surrounding whitespace', () => {
+    expect(lsnFromString('  0/100  ')).toBe(0x100n)
+  })
+
+  it('returns null for malformed input', () => {
+    expect(lsnFromString('0')).toBeNull()
+    expect(lsnFromString('0/')).toBeNull()
+    expect(lsnFromString('/0')).toBeNull()
+    expect(lsnFromString('xyz')).toBeNull()
+    expect(lsnFromString('')).toBeNull()
+  })
+})
+
+describe('extractStartLsn', () => {
+  it('extracts from a basic START_REPLICATION query', () => {
+    expect(extractStartLsn('START_REPLICATION SLOT "zero" LOGICAL 0/01000300')).toBe(
+      0x1000300n
+    )
+  })
+
+  it('handles trailing options', () => {
+    expect(
+      extractStartLsn(
+        `START_REPLICATION SLOT "zero" LOGICAL 0/01000300 (proto_version '4', publication_names 'orez_zero_public')`
+      )
+    ).toBe(0x1000300n)
+  })
+
+  it('handles 0/0 (fresh slot)', () => {
+    expect(extractStartLsn('START_REPLICATION SLOT "zero" LOGICAL 0/0')).toBe(0n)
+  })
+
+  it('handles quoted LSN', () => {
+    expect(extractStartLsn(`START_REPLICATION SLOT "zero" LOGICAL '0/01000300'`)).toBe(
+      0x1000300n
+    )
+  })
+
+  it('is case-insensitive on the keyword', () => {
+    expect(extractStartLsn('start_replication slot "z" logical 0/abc')).toBe(0xabcn)
+  })
+
+  it('returns null when no LSN is present', () => {
+    expect(extractStartLsn('START_REPLICATION SLOT "z"')).toBeNull()
+    expect(extractStartLsn('IDENTIFY_SYSTEM')).toBeNull()
+  })
+})

package/src/replication/handler.ts

@@ -133,6 +133,30 @@ function lsnToString(lsn: bigint): string {
   return `${high.toString(16).toUpperCase()}/${low.toString(16).toUpperCase()}`
 }
 
+/**
+ * parse an LSN string like "0/01000300" into a bigint.
+ * returns null if the string doesn't match (e.g. "0/0" still parses to 0n).
+ */
+function lsnFromString(s: string): bigint | null {
+  const m = s.trim().match(/^([0-9a-f]+)\/([0-9a-f]+)$/i)
+  if (!m) return null
+  return (BigInt('0x' + m[1]) << 32n) | BigInt('0x' + m[2])
+}
+
+/**
+ * extract the client-supplied LSN from a START_REPLICATION query.
+ * format: START_REPLICATION SLOT name LOGICAL <high>/<low> [proto_version 'N', publication_names 'X']
+ * accepts optional surrounding quotes (some clients send `LOGICAL '0/0'`).
+ * returns null if no parseable LSN is found.
+ */
+export function extractStartLsn(query: string): bigint | null {
+  const m = query.match(/\bLOGICAL\s+'?([0-9a-f]+\/[0-9a-f]+)'?/i)
+  if (!m) return null
+  return lsnFromString(m[1])
+}
+
+export { lsnFromString }
+
 function nowMicros(): bigint {
   return BigInt(Date.now()) * 1000n
 }
@@ -359,6 +383,23 @@ export async function handleStartReplication(
 ): Promise<void> {
   log.debug.repl('entering streaming mode')
 
+  // honor zero-cache's resume LSN. without this, after a page reload the
+  // in-memory currentLsn / lastStreamedWatermark are reset to defaults but
+  // changeLog persists with prior LSNs — re-streaming from BIGINT 0 makes
+  // the change-streamer try to INSERT (watermark, pos) tuples that already
+  // exist, hitting `changeLog_pkey` violations and tearing down the loop.
+  // by advancing currentLsn past the client's last-seen LSN we guarantee
+  // newly-emitted batches use strictly higher LSNs, and by jumping
+  // lastStreamedWatermark to the current sequence value we skip already-
+  // streamed _zero_changes rows.
+  const clientStartLsn = extractStartLsn(query)
+  if (clientStartLsn !== null && clientStartLsn > currentLsn) {
+    log.debug.repl(
+      `advancing currentLsn ${lsnToString(currentLsn)} → ${lsnToString(clientStartLsn)} from client START_REPLICATION`
+    )
+    currentLsn = clientStartLsn
+  }
+
   // send CopyBothResponse to enter streaming mode
   const copyBoth = new Uint8Array(1 + 4 + 1 + 2)
   copyBoth[0] = 0x57 // 'W' CopyBothResponse
@@ -368,7 +409,29 @@ export async function handleStartReplication(
   writer.write(copyBoth)
 
   // resume from where the previous handler left off to avoid
-  // replaying already-streamed changes after reconnect
+  // replaying already-streamed changes after reconnect.
+  // when client supplied a NON-ZERO LSN (i.e. this is a reconnect to an
+  // existing slot with prior progress), also bump lastStreamedWatermark to
+  // the current sequence value — anything before that has already been
+  // written to changeLog, so re-streaming would just produce duplicate-key
+  // errors. `0/0` indicates "fresh slot" and must NOT trigger this jump,
+  // otherwise we'd skip rows that legitimately need to be streamed for the
+  // initial sync.
+  if (clientStartLsn !== null && clientStartLsn > 0n) {
+    try {
+      const currentWm = await getCurrentWatermark(db)
+      if (currentWm > lastStreamedWatermark) {
+        log.debug.repl(
+          `advancing lastStreamedWatermark ${lastStreamedWatermark} → ${currentWm} on reconnect`
+        )
+        lastStreamedWatermark = currentWm
+      }
+    } catch (err) {
+      log.repl(
+        `getCurrentWatermark failed on reconnect: ${(err as Error)?.message || err}`
+      )
+    }
+  }
   let lastWatermark = lastStreamedWatermark
 
   // use cached setup results on reconnect to avoid holding the mutex