orez 0.1.7 → 0.1.9

package/src/integration/restore-live-stress.test.ts

@@ -18,11 +18,26 @@ import WebSocket from 'ws'
 import { execDumpFile } from '../cli.js'
 import { startZeroLite } from '../index.js'
 import { installChangeTracking } from '../replication/change-tracker.js'
-import { installAllowAllPermissions } from './test-permissions.js'
+import {
+  ensureTablesInPublications,
+  hasNonNullPermissions,
+  installAllowAllPermissions,
+} from './test-permissions.js'
 
 import type { PGlite } from '@electric-sql/pglite'
 
 const SYNC_PROTOCOL_VERSION = 45
+const LIVE_CLIENT_SCHEMA = {
+  tables: {
+    restore_live_probe: {
+      columns: {
+        id: { type: 'string' },
+        value: { type: 'string' },
+      },
+      primaryKey: ['id'],
+    },
+  },
+}
 
 function encodeSecProtocols(
   initConnectionMessage: unknown,
@@ -128,78 +143,52 @@ function connectAndSubscribe(
   query: Record<string, unknown>
 ): Promise<WebSocket> {
   return new Promise((resolve, reject) => {
-    const ts = Date.now()
-    const clientGroupID = `restore-live-cg-${ts}`
-    const urlBase =
+    const initConnectionMessage: [string, Record<string, unknown>] = [
+      'initConnection',
+      {
+        desiredQueriesPatch: [{ op: 'put', hash: 'q1', ast: query }],
+        clientSchema: LIVE_CLIENT_SCHEMA,
+      },
+    ]
+    const secProtocol = encodeSecProtocols(initConnectionMessage, undefined)
+    const ws = new WebSocket(
       `ws://127.0.0.1:${port}/sync/v${SYNC_PROTOCOL_VERSION}/connect` +
-      `?clientGroupID=${clientGroupID}` +
-      `&clientID=restore-live-client` +
-      `&schemaVersion=1&baseCookie=&ts=${Date.now()}&lmid=0`
-
-    const bootstrapProtocol = encodeSecProtocols(
-      ['initConnection', { desiredQueriesPatch: [] }],
-      undefined
+        `?clientGroupID=restore-live-cg-${Date.now()}` +
+        `&clientID=restore-live-client` +
+        `&wsid=ws1&schemaVersion=1&baseCookie=&ts=${Date.now()}&lmid=0`,
+      secProtocol
     )
-    const bootstrapWs = new WebSocket(`${urlBase}&wsid=bootstrap`, bootstrapProtocol)
 
-    const fail = (err: unknown) => {
-      clearTimeout(bootstrapTimer)
+    let settled = false
+    const failTimer = setTimeout(() => {
+      if (settled) return
+      settled = true
       try {
-        bootstrapWs.close()
+        ws.close()
       } catch {}
-      reject(err)
-    }
-
-    const bootstrapTimer = setTimeout(() => {
-      fail(new Error('bootstrap websocket timeout'))
+      reject(new Error('websocket connected but no downstream messages'))
     }, 7000)
-    bootstrapWs.once('error', fail)
-    bootstrapWs.once('message', () => {
-      clearTimeout(bootstrapTimer)
-      try {
-        bootstrapWs.close()
-      } catch {}
 
-      const initConnectionMessage: [string, Record<string, unknown>] = [
-        'initConnection',
-        {
-          desiredQueriesPatch: [{ op: 'put', hash: 'q1', ast: query }],
-        },
-      ]
-      const secProtocol = encodeSecProtocols(initConnectionMessage, undefined)
-      const ws = new WebSocket(`${urlBase}&wsid=ws1`, secProtocol)
-
-      let settled = false
-      const failTimer = setTimeout(() => {
-        if (settled) return
-        settled = true
-        try {
-          ws.close()
-        } catch {}
-        reject(new Error('websocket connected but no downstream messages'))
-      }, 7000)
-
-      ws.on('message', (data) => {
-        const msg = JSON.parse(data.toString())
-        downstream.enqueue(msg)
-        if (!settled) {
-          settled = true
-          clearTimeout(failTimer)
-          resolve(ws)
-        }
-      })
-      ws.once('error', (err) => {
-        if (settled) return
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data.toString())
+      downstream.enqueue(msg)
+      if (!settled) {
         settled = true
         clearTimeout(failTimer)
-        reject(err)
-      })
-      ws.once('close', () => {
-        if (settled) return
-        settled = true
-        clearTimeout(failTimer)
-        reject(new Error('websocket closed before initial downstream message'))
-      })
+        resolve(ws)
+      }
+    })
+    ws.once('error', (err) => {
+      if (settled) return
+      settled = true
+      clearTimeout(failTimer)
+      reject(err)
+    })
+    ws.once('close', () => {
+      if (settled) return
+      settled = true
+      clearTimeout(failTimer)
+      reject(new Error('websocket closed before initial downstream message'))
     })
   })
 }
@@ -299,6 +288,7 @@ describe('live restore stress with connected frontend', { timeout: 360_000 }, ()
   let zeroPort: number
   let shutdown: () => Promise<void>
   let restartZero: (() => Promise<void>) | undefined
+  let resetZeroFull: (() => Promise<void>) | undefined
   let dataDir: string
   let dumpFile: string
 
@@ -330,6 +320,7 @@ describe('live restore stress with connected frontend', { timeout: 360_000 }, ()
     zeroPort = started.zeroPort
     shutdown = started.stop
     restartZero = started.restartZero
+    resetZeroFull = started.resetZeroFull
     await waitForZero(zeroPort, 90_000)
   }, 180_000)
 
@@ -352,8 +343,13 @@ describe('live restore stress with connected frontend', { timeout: 360_000 }, ()
         value TEXT NOT NULL
       )
     `)
+    await ensureTablesInPublications(db, ['restore_live_probe'])
     await installAllowAllPermissions(db, ['restore_live_probe'])
-    if (restartZero) {
+    expect(await hasNonNullPermissions(db)).toBe(true)
+    if (resetZeroFull) {
+      await resetZeroFull()
+      await waitForZero(zeroPort, 90_000)
+    } else if (restartZero) {
       await restartZero()
       await waitForZero(zeroPort, 60_000)
     }

package/src/integration/restore-reset.test.ts

@@ -18,10 +18,25 @@ import WebSocket from 'ws'
 
 import { execDumpFile } from '../cli.js'
 import { startZeroLite } from '../index.js'
-import { installAllowAllPermissions } from './test-permissions.js'
+import {
+  ensureTablesInPublications,
+  hasNonNullPermissions,
+  installAllowAllPermissions,
+} from './test-permissions.js'
 
 // zero-cache protocol version (from @rocicorp/zero/out/zero-protocol/src/protocol-version.js)
 const PROTOCOL_VERSION = 45
+const RESET_CLIENT_SCHEMA = {
+  tables: {
+    reset_probe: {
+      columns: {
+        id: { type: 'string' },
+        value: { type: 'string' },
+      },
+      primaryKey: ['id'],
+    },
+  },
+}
 
 // encode initConnection message for sec-websocket-protocol header
 // matches zero-protocol's encodeSecProtocols implementation
@@ -117,6 +132,7 @@ describe('restore/reset integration regression', { timeout: 150_000 }, () => {
   let zeroPort: number
   let shutdown: () => Promise<void>
   let restartZero: (() => Promise<void>) | undefined
+  let resetZeroFull: (() => Promise<void>) | undefined
   let dataDir: string
   let dumpFile: string
   let dumpFileIsTemp = false
@@ -143,6 +159,7 @@ describe('restore/reset integration regression', { timeout: 150_000 }, () => {
     zeroPort = started.zeroPort
     shutdown = started.stop
     restartZero = started.restartZero
+    resetZeroFull = started.resetZeroFull
 
     await waitForZero(zeroPort, 90_000)
   }, 120_000)
@@ -205,6 +222,7 @@ describe('restore/reset integration regression', { timeout: 150_000 }, () => {
         AFTER INSERT OR UPDATE OR DELETE ON public.reset_probe
         FOR EACH STATEMENT EXECUTE FUNCTION public._zero_notify_change();
     `)
+    await ensureTablesInPublications(db, ['reset_probe'])
     const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
     if (pubName) {
       const quotedPub = '"' + pubName.replace(/"/g, '""') + '"'
@@ -213,7 +231,11 @@ describe('restore/reset integration regression', { timeout: 150_000 }, () => {
         .catch(() => {})
     }
     await installAllowAllPermissions(db, ['reset_probe'])
-    if (restartZero) {
+    expect(await hasNonNullPermissions(db)).toBe(true)
+    if (resetZeroFull) {
+      await resetZeroFull()
+      await waitForZero(zeroPort, 90_000)
+    } else if (restartZero) {
       await restartZero()
       await waitForZero(zeroPort, 60_000)
     }
@@ -259,79 +281,54 @@ function connectAndSubscribe(
     const ts = Date.now()
     const clientGroupID = `restore-reset-cg-${ts}`
     const clientID = 'restore-reset-client'
-    const urlBase =
+    const initConnectionMessage: [string, Record<string, unknown>] = [
+      'initConnection',
+      {
+        desiredQueriesPatch: [{ op: 'put', hash: 'q1', ast: query }],
+        clientSchema: RESET_CLIENT_SCHEMA,
+      },
+    ]
+    const secProtocol = encodeSecProtocols(initConnectionMessage, undefined)
+    const ws = new WebSocket(
       `ws://127.0.0.1:${port}/sync/v${PROTOCOL_VERSION}/connect` +
-      `?clientGroupID=${clientGroupID}&clientID=${clientID}&schemaVersion=1&baseCookie=&ts=${ts}&lmid=0`
-
-    // bootstrap the client group first so the query connection is not "new group"
-    const bootstrapProtocol = encodeSecProtocols(
-      ['initConnection', { desiredQueriesPatch: [] }],
-      undefined
+        `?clientGroupID=${clientGroupID}&clientID=${clientID}&wsid=ws1&schemaVersion=1&baseCookie=&ts=${ts}&lmid=0`,
+      secProtocol
     )
-    const bootstrapWs = new WebSocket(`${urlBase}&wsid=bootstrap`, bootstrapProtocol)
-    const bootstrapTimer = setTimeout(() => {
-      fail(new Error('bootstrap websocket timeout'))
-    }, 7000)
-
-    const fail = (err: unknown) => {
-      clearTimeout(bootstrapTimer)
-      try {
-        bootstrapWs.close()
-      } catch {}
-      reject(err)
-    }
 
-    bootstrapWs.once('error', fail)
-    bootstrapWs.once('message', () => {
-      clearTimeout(bootstrapTimer)
+    let settled = false
+    let sawMessage = false
+    const failTimer = setTimeout(() => {
+      if (settled) return
+      settled = true
       try {
-        bootstrapWs.close()
+        ws.close()
       } catch {}
+      reject(new Error('websocket connected but no downstream messages'))
+    }, 7000)
 
-      const initConnectionMessage: [string, Record<string, unknown>] = [
-        'initConnection',
-        {
-          desiredQueriesPatch: [{ op: 'put', hash: 'q1', ast: query }],
-        },
-      ]
-      const secProtocol = encodeSecProtocols(initConnectionMessage, undefined)
-      const ws = new WebSocket(`${urlBase}&wsid=ws1`, secProtocol)
-
-      let settled = false
-      let sawMessage = false
-      const failTimer = setTimeout(() => {
-        if (settled) return
-        settled = true
-        try {
-          ws.close()
-        } catch {}
-        reject(new Error('websocket connected but no downstream messages'))
-      }, 7000)
-
-      ws.on('message', (data) => {
-        const msg = JSON.parse(data.toString())
-        downstream.enqueue(msg)
-        if (!sawMessage && !settled) {
-          sawMessage = true
-          settled = true
-          clearTimeout(failTimer)
-          resolve(ws)
-        }
-      })
-
-      ws.once('error', (err) => {
-        if (settled) return
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data.toString())
+      downstream.enqueue(msg)
+      if (!sawMessage && !settled) {
+        sawMessage = true
         settled = true
         clearTimeout(failTimer)
-        reject(err)
-      })
+        resolve(ws)
+      }
+    })
 
-      ws.once('close', () => {
-        if (settled) return
-        settled = true
-        clearTimeout(failTimer)
-        reject(new Error('websocket closed before initial downstream message'))
-      })
+    ws.once('error', (err) => {
+      if (settled) return
+      settled = true
+      clearTimeout(failTimer)
+      reject(err)
+    })
+
+    ws.once('close', () => {
+      if (settled) return
+      settled = true
+      clearTimeout(failTimer)
+      reject(new Error('websocket closed before initial downstream message'))
     })
   })
 }

package/src/integration/test-permissions.ts

@@ -84,6 +84,42 @@ export async function installAllowAllPermissions(
   }
 }
 
+export async function hasNonNullPermissions(db: DbLike): Promise<boolean> {
+  const schemas = await findPermissionsSchemas(db)
+  for (const schema of schemas) {
+    const quotedSchema = '"' + schema.replace(/"/g, '""') + '"'
+    const result = await db.query<{ has_permissions: boolean }>(
+      `SELECT (permissions IS NOT NULL) AS has_permissions
+       FROM ${quotedSchema}.permissions
+       WHERE lock = true
+       LIMIT 1`
+    )
+    if (result.rows[0]?.has_permissions) return true
+  }
+  return false
+}
+
+export async function ensureTablesInPublications(
+  db: DbLike,
+  tables: string[]
+): Promise<void> {
+  const pubs = await db.query<{ pubname: string }>(
+    `SELECT pubname
+     FROM pg_publication
+     WHERE pubname NOT LIKE '%metadata%'
+     ORDER BY pubname`
+  )
+  for (const { pubname } of pubs.rows) {
+    const quotedPub = '"' + pubname.replace(/"/g, '""') + '"'
+    for (const table of tables) {
+      const quotedTable = '"' + table.replace(/"/g, '""') + '"'
+      await db
+        .exec(`ALTER PUBLICATION ${quotedPub} ADD TABLE "public".${quotedTable}`)
+        .catch(() => {})
+    }
+  }
+}
+
 function parsePermissions(value: unknown): { tables?: Record<string, unknown> } {
   if (!value) return {}
   if (typeof value === 'string') {

package/src/pg-proxy.ts

@@ -261,6 +261,43 @@ function readInt32BE(data: Uint8Array, offset: number): number {
   )
 }
 
+// pglite transaction state warnings to suppress (benign, but noisy)
+// 25001: "there is already a transaction in progress"
+// 25P01: "there is no transaction in progress"
+const SUPPRESS_NOTICE_CODES = new Set(['25001', '25P01'])
+
+/**
+ * extract SQLSTATE code from a NoticeResponse message.
+ * returns null if not a NoticeResponse or code not found.
+ */
+function extractNoticeCode(
+  data: Uint8Array,
+  offset: number,
+  totalLen: number
+): string | null {
+  if (data[offset] !== 0x4e) return null // not a NoticeResponse
+
+  let pos = offset + 5 // skip type byte + length
+  const end = offset + totalLen
+
+  while (pos < end) {
+    const fieldType = data[pos++]
+    if (fieldType === 0) break // terminator
+
+    // find null-terminated string
+    const strStart = pos
+    while (pos < end && data[pos] !== 0) pos++
+    if (pos >= end) break
+
+    if (fieldType === 0x43) {
+      // 'C' = SQLSTATE code
+      return new TextDecoder().decode(data.subarray(strStart, pos))
+    }
+    pos++ // skip null terminator
+  }
+  return null
+}
+
 /**
  * strip ReadyForQuery messages from a response buffer.
  */
@@ -297,6 +334,48 @@ function stripReadyForQuery(data: Uint8Array): Uint8Array {
   return result
 }
 
+/**
+ * strip NoticeResponse messages with specific SQLSTATE codes from a response buffer.
+ * pglite emits benign transaction state warnings that we suppress to reduce noise.
+ */
+function stripTransactionWarnings(data: Uint8Array): Uint8Array {
+  if (data.length === 0) return data
+
+  const parts: Uint8Array[] = []
+  let offset = 0
+  let stripped = false
+
+  while (offset < data.length) {
+    if (offset + 5 > data.length) break
+    const msgLen = readInt32BE(data, offset + 1)
+    const totalLen = 1 + msgLen
+
+    if (totalLen <= 0 || offset + totalLen > data.length) break
+
+    const code = extractNoticeCode(data, offset, totalLen)
+    if (code && SUPPRESS_NOTICE_CODES.has(code)) {
+      stripped = true
+    } else {
+      parts.push(data.subarray(offset, offset + totalLen))
+    }
+
+    offset += totalLen
+  }
+
+  if (!stripped) return data
+  if (parts.length === 0) return new Uint8Array(0)
+  if (parts.length === 1) return parts[0]
+
+  const total = parts.reduce((sum, p) => sum + p.length, 0)
+  const result = new Uint8Array(total)
+  let pos = 0
+  for (const p of parts) {
+    result.set(p, pos)
+    pos += p.length
+  }
+  return result
+}
+
 export async function startPgProxy(
   dbInput: PGlite | PGliteInstances,
   config: ZeroLiteConfig
@@ -436,6 +515,9 @@ export async function startPgProxy(
             throw err
           }
 
+          // strip benign transaction state warnings from pglite
+          result = stripTransactionWarnings(result)
+
           // strip ReadyForQuery from non-Sync/non-SimpleQuery responses
           if (data[0] !== 0x53 && data[0] !== 0x51) {
             result = stripReadyForQuery(result)
@@ -510,9 +592,10 @@ async function handleReplicationMessage(
     data = interceptQuery(data)
 
     // fall through to pglite for unrecognized queries
-    return await db.execProtocolRaw(data, {
+    const result = await db.execProtocolRaw(data, {
       throwOnError: false,
     })
+    return stripTransactionWarnings(result)
   } finally {
     mutex.release()
   }

package/src/sqlite-mode/native-binary.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 
-import { resolvePackage } from './resolve-mode.js'
+import { resolvePackage } from './package-resolve.js'
 
 const NATIVE_BINARY_RELATIVE_PATHS = ['build/Release/better_sqlite3.node']
 

package/src/sqlite-mode/package-resolve.ts

@@ -0,0 +1,17 @@
+import { createRequire } from 'node:module'
+
+/**
+ * resolve a package entry path
+ * import.meta.resolve doesn't work in vitest, so we fall back to require.resolve
+ */
+export function resolvePackage(pkg: string): string {
+  try {
+    const resolved = import.meta.resolve(pkg)
+    if (resolved) return resolved.replace('file://', '')
+  } catch {}
+  try {
+    const require = createRequire(import.meta.url)
+    return require.resolve(pkg)
+  } catch {}
+  return ''
+}

package/src/sqlite-mode/resolve-mode.ts

@@ -1,33 +1,42 @@
 /**
  * mode resolution - canonical place to determine sqlite mode from config/env
+ *
+ * priority:
+ * 1. explicit --disable-wasm-sqlite flag → native
+ * 2. explicit --force-wasm-sqlite flag → wasm
+ * 3. native binary available → native (auto-detect)
+ * 4. fallback → wasm
  */
 
-import { createRequire } from 'node:module'
+import { inspectNativeSqliteBinary } from './native-binary.js'
+import { resolvePackage } from './package-resolve.js'
 
 import type { SqliteMode, SqliteModeConfig } from './types.js'
-
-/**
- * resolve a package entry path
- * import.meta.resolve doesn't work in vitest, so we fall back to require.resolve
- */
-export function resolvePackage(pkg: string): string {
-  try {
-    const resolved = import.meta.resolve(pkg)
-    if (resolved) return resolved.replace('file://', '')
-  } catch {}
-  try {
-    const require = createRequire(import.meta.url)
-    return require.resolve(pkg)
-  } catch {}
-  return ''
-}
+export { resolvePackage } from './package-resolve.js'
 
 /**
  * resolve sqlite mode from config
  * single source of truth for mode selection
+ *
+ * @param disableWasmSqlite - explicit flag to force native mode
+ * @param forceWasmSqlite - explicit flag to force wasm mode (overrides auto-detect)
  */
-export function resolveSqliteMode(disableWasmSqlite: boolean): SqliteMode {
-  return disableWasmSqlite ? 'native' : 'wasm'
+export function resolveSqliteMode(
+  disableWasmSqlite: boolean,
+  forceWasmSqlite: boolean = false
+): SqliteMode {
+  // explicit native request
+  if (disableWasmSqlite) return 'native'
+
+  // explicit wasm request
+  if (forceWasmSqlite) return 'wasm'
+
+  // auto-detect: prefer native if binary is available
+  const nativeCheck = inspectNativeSqliteBinary()
+  if (nativeCheck.found) return 'native'
+
+  // fallback to wasm
+  return 'wasm'
 }
 
 /**
@@ -35,9 +44,10 @@ export function resolveSqliteMode(disableWasmSqlite: boolean): SqliteMode {
  * returns null if required packages aren't installed
  */
 export function resolveSqliteModeConfig(
-  disableWasmSqlite: boolean
+  disableWasmSqlite: boolean,
+  forceWasmSqlite: boolean = false
 ): SqliteModeConfig | null {
-  const mode = resolveSqliteMode(disableWasmSqlite)
+  const mode = resolveSqliteMode(disableWasmSqlite, forceWasmSqlite)
   const zeroSqlitePath = resolvePackage('@rocicorp/zero-sqlite3') || undefined
 
   // native mode may still need zero-sqlite3 path for restoring from a prior shim

package/src/sqlite-mode/sqlite-mode.test.ts

@@ -28,16 +28,22 @@ describe('sqlite mode types', () => {
 })
 
 describe('sqlite mode resolution', () => {
-  it('resolves wasm mode when disableWasmSqlite is false', () => {
-    expect(resolveSqliteMode(false)).toBe('wasm')
+  it('resolves native mode when disableWasmSqlite is true', () => {
+    expect(resolveSqliteMode(true, false)).toBe('native')
   })
 
-  it('resolves native mode when disableWasmSqlite is true', () => {
-    expect(resolveSqliteMode(true)).toBe('native')
+  it('resolves wasm mode when forceWasmSqlite is true', () => {
+    expect(resolveSqliteMode(false, true)).toBe('wasm')
+  })
+
+  it('auto-detects mode based on native binary availability', () => {
+    // when neither flag is set, mode depends on whether native binary exists
+    const mode = resolveSqliteMode(false, false)
+    expect(['wasm', 'native']).toContain(mode)
   })
 
   it('returns config with mode for native', () => {
-    const config = resolveSqliteModeConfig(true)
+    const config = resolveSqliteModeConfig(true, false)
     expect(config).not.toBeNull()
     expect(config?.mode).toBe('native')
   })