orez 0.1.7 → 0.1.8

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/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')
   })