orez 0.2.26 → 0.2.29

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

@@ -1,400 +0,0 @@
-/**
- * regression test for restore/reset integration.
- *
- * covers the real integration boundary that previously regressed:
- * - restore data through wire protocol
- * - trigger full zero-state reset via pid-file + SIGUSR1 (same path as pg_restore)
- * - verify zero-cache restarts and live replication still works
- */
-
-import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
-import { homedir, tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { loadModule } from 'pgsql-parser'
-import postgres from 'postgres'
-import { afterAll, beforeAll, describe, expect, test } from 'vitest'
-import WebSocket from 'ws'
-
-import { execDumpFile } from '../cli.js'
-import { startZeroLite } from '../index.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
-function encodeSecProtocols(
-  initConnectionMessage: unknown,
-  authToken: string | undefined
-): string {
-  const payload = JSON.stringify({ initConnectionMessage, authToken })
-  return encodeURIComponent(Buffer.from(payload, 'utf-8').toString('base64'))
-}
-
-import type { PGlite } from '@electric-sql/pglite'
-
-class Queue<T> {
-  private items: T[] = []
-  private waiters: Array<{
-    resolve: (v: T) => void
-    timer?: ReturnType<typeof setTimeout>
-  }> = []
-
-  enqueue(item: T) {
-    const waiter = this.waiters.shift()
-    if (waiter) {
-      if (waiter.timer) clearTimeout(waiter.timer)
-      waiter.resolve(item)
-    } else {
-      this.items.push(item)
-    }
-  }
-
-  dequeue(fallback?: T, timeoutMs = 10000): Promise<T> {
-    if (this.items.length > 0) {
-      return Promise.resolve(this.items.shift()!)
-    }
-    return new Promise<T>((resolve) => {
-      const waiter: { resolve: (v: T) => void; timer?: ReturnType<typeof setTimeout> } = {
-        resolve,
-      }
-      if (fallback !== undefined) {
-        waiter.timer = setTimeout(() => {
-          const idx = this.waiters.indexOf(waiter)
-          if (idx >= 0) this.waiters.splice(idx, 1)
-          resolve(fallback)
-        }, timeoutMs)
-      }
-      this.waiters.push(waiter)
-    })
-  }
-}
-
-function generateFallbackDump(): string {
-  return [
-    'SET statement_timeout = 0;',
-    "SET client_encoding = 'UTF8';",
-    'SET standard_conforming_strings = on;',
-    '',
-    'CREATE TABLE IF NOT EXISTS restore_seed (',
-    '  id integer PRIMARY KEY,',
-    '  note text NOT NULL',
-    ');',
-    '',
-    "INSERT INTO restore_seed (id, note) VALUES (1, 'seeded by fallback dump');",
-    '',
-  ].join('\n')
-}
-
-function resolveDumpFile(): { path: string; cleanup: boolean } {
-  const envDump = process.env.OREZ_RESTORE_SQL_DUMP
-  if (envDump && existsSync(envDump)) {
-    return { path: envDump, cleanup: false }
-  }
-
-  const chatCandidates = [
-    join(homedir(), 'chat', 'tmp', 'restore.sql'),
-    join(homedir(), 'chat', 'tmp', 'backup.sql'),
-    join(homedir(), 'chat', 'restore.sql'),
-    join(homedir(), 'chat', 'backup.sql'),
-  ]
-  for (const candidate of chatCandidates) {
-    if (existsSync(candidate)) {
-      return { path: candidate, cleanup: false }
-    }
-  }
-
-  const tmpDump = join(tmpdir(), `orez-restore-reset-${Date.now()}.sql`)
-  writeFileSync(tmpDump, generateFallbackDump())
-  return { path: tmpDump, cleanup: true }
-}
-
-describe('restore/reset integration regression', { timeout: 150_000 }, () => {
-  let db: PGlite
-  let pgPort: number
-  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
-
-  beforeAll(async () => {
-    await loadModule()
-
-    const dump = resolveDumpFile()
-    dumpFile = dump.path
-    dumpFileIsTemp = dump.cleanup
-
-    dataDir = `.orez-restore-reset-test-${Date.now()}`
-
-    const started = await startZeroLite({
-      pgPort: 27000 + Math.floor(Math.random() * 1000),
-      zeroPort: 28000 + Math.floor(Math.random() * 1000),
-      dataDir,
-      logLevel: 'warn',
-      skipZeroCache: false,
-    })
-
-    db = started.db
-    pgPort = started.pgPort
-    zeroPort = started.zeroPort
-    shutdown = started.stop
-    restartZero = started.restartZero
-    resetZeroFull = started.resetZeroFull
-
-    await waitForZero(zeroPort, 90_000)
-  }, 120_000)
-
-  afterAll(async () => {
-    if (shutdown) await shutdown()
-    if (dataDir) {
-      try {
-        rmSync(dataDir, { recursive: true, force: true })
-      } catch {}
-    }
-    if (dumpFileIsTemp && dumpFile) {
-      try {
-        unlinkSync(dumpFile)
-      } catch {}
-    }
-  })
-
-  test('wire restore + pid signal full reset keeps zero-cache healthy', async () => {
-    const sql = postgres({
-      host: '127.0.0.1',
-      port: pgPort,
-      user: 'user',
-      password: 'password',
-      database: 'postgres',
-      max: 1,
-    })
-
-    try {
-      const wireDb = { exec: (query: string) => sql.unsafe(query) as Promise<unknown> }
-      await execDumpFile(wireDb, dumpFile)
-    } finally {
-      await sql.end({ timeout: 1 }).catch(() => {})
-    }
-
-    // mirror pg_restore behavior: read pid file and signal SIGUSR1 for full reset
-    const pidFile = join(dataDir, 'orez.pid')
-    const pid = Number(readFileSync(pidFile, 'utf-8').trim())
-    expect(pid).toBeGreaterThan(0)
-    process.kill(pid, 'SIGUSR1')
-
-    await waitForZero(zeroPort, 90_000)
-
-    // prove zero-cache is alive after reset and still streams live writes
-    await db.exec(`
-      CREATE TABLE IF NOT EXISTS reset_probe (
-        id text PRIMARY KEY,
-        value text NOT NULL
-      );
-
-      -- install change tracking trigger on the new table
-      DROP TRIGGER IF EXISTS _zero_change_trigger ON public.reset_probe;
-      CREATE TRIGGER _zero_change_trigger
-        AFTER INSERT OR UPDATE OR DELETE ON public.reset_probe
-        FOR EACH ROW EXECUTE FUNCTION public._zero_track_change();
-
-      -- install notify trigger for real-time notifications
-      DROP TRIGGER IF EXISTS _zero_notify_trigger ON public.reset_probe;
-      CREATE TRIGGER _zero_notify_trigger
-        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, '""') + '"'
-      await db
-        .exec(`ALTER PUBLICATION ${quotedPub} ADD TABLE "public"."reset_probe"`)
-        .catch(() => {})
-    }
-    await installAllowAllPermissions(db, ['reset_probe'])
-    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)
-    }
-
-    const downstream = new Queue<unknown>()
-    const ws = await connectAndSubscribeWithRetry(zeroPort, downstream, {
-      table: 'reset_probe',
-      orderBy: [['id', 'asc']],
-    })
-
-    try {
-      await drainInitialPokes(downstream)
-
-      await db.query(`INSERT INTO reset_probe (id, value) VALUES ($1, $2)`, [
-        `post-reset-${Date.now()}`,
-        'ok',
-      ])
-
-      const poke = await waitForPokePart(downstream, 30_000)
-      expect(poke.rowsPatch).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            op: 'put',
-            tableName: 'reset_probe',
-            value: expect.objectContaining({
-              value: 'ok',
-            }),
-          }),
-        ])
-      )
-    } finally {
-      ws.close()
-    }
-  })
-})
-
-function connectAndSubscribe(
-  port: number,
-  downstream: Queue<unknown>,
-  query: Record<string, unknown>
-): Promise<WebSocket> {
-  return new Promise((resolve, reject) => {
-    const ts = Date.now()
-    const clientGroupID = `restore-reset-cg-${ts}`
-    const clientID = 'restore-reset-client'
-    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}&wsid=ws1&schemaVersion=1&baseCookie=&ts=${ts}&lmid=0`,
-      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
-      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'))
-    })
-  })
-}
-
-async function connectAndSubscribeWithRetry(
-  port: number,
-  downstream: Queue<unknown>,
-  query: Record<string, unknown>,
-  timeoutMs = 30_000
-): Promise<WebSocket> {
-  const deadline = Date.now() + timeoutMs
-  let lastErr: unknown
-  while (Date.now() < deadline) {
-    try {
-      return await connectAndSubscribe(port, downstream, query)
-    } catch (err) {
-      lastErr = err
-      await new Promise((r) => setTimeout(r, 300))
-    }
-  }
-  throw new Error(
-    `timed out connecting websocket after reset: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
-  )
-}
-
-async function drainInitialPokes(downstream: Queue<unknown>) {
-  let settled = false
-  const timeout = Date.now() + 30_000
-
-  while (!settled && Date.now() < timeout) {
-    const msg = (await downstream.dequeue('timeout' as any, 3000)) as any
-    if (msg === 'timeout') {
-      settled = true
-    } else if (Array.isArray(msg) && msg[0] === 'pokeEnd') {
-      const next = (await downstream.dequeue('timeout' as any, 2000)) as any
-      if (next === 'timeout') {
-        settled = true
-      }
-    }
-  }
-}
-
-async function waitForPokePart(
-  downstream: Queue<unknown>,
-  timeoutMs = 10_000
-): Promise<Record<string, any>> {
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    const remaining = Math.max(1000, deadline - Date.now())
-    const msg = (await downstream.dequeue('timeout' as any, remaining)) as any
-    if (msg === 'timeout') throw new Error('timed out waiting for pokePart')
-    if (Array.isArray(msg) && msg[0] === 'pokePart' && msg[1]?.rowsPatch) {
-      return msg[1]
-    }
-  }
-  throw new Error('timed out waiting for pokePart')
-}
-
-async function waitForZero(port: number, timeoutMs = 30_000) {
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`http://localhost:${port}/`)
-      if (res.ok || res.status === 404) return
-    } catch {}
-    await new Promise((r) => setTimeout(r, 500))
-  }
-  throw new Error(`zero-cache not ready on port ${port} after ${timeoutMs}ms`)
-}

package/src/integration/restore.test.ts

@@ -1,274 +0,0 @@
-/**
- * integration test for pg_restore through a running orez instance.
- *
- * generates a pg_dump-style SQL file, starts fresh orez, restores via wire
- * protocol, then verifies data via wire queries + zero-cache websocket sync.
- */
-
-import { writeFileSync, unlinkSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { loadModule } from 'pgsql-parser'
-import postgres from 'postgres'
-import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-
-import { execDumpFile } from '../cli.js'
-import { startZeroLite } from '../index.js'
-
-import type { PGlite } from '@electric-sql/pglite'
-
-// generate a pg_dump-style SQL file with our test schema + data
-function generateDump(): string {
-  const lines: string[] = []
-
-  // preamble (mimics pg_dump)
-  lines.push('SET statement_timeout = 0;')
-  lines.push("SET client_encoding = 'UTF8';")
-  lines.push('SET standard_conforming_strings = on;')
-  lines.push('')
-
-  // tables
-  lines.push(`CREATE TABLE items (
-  id integer NOT NULL,
-  name text NOT NULL,
-  data text,
-  score integer DEFAULT 0
-);`)
-  lines.push('')
-  lines.push(
-    `CREATE SEQUENCE items_id_seq AS integer START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE CACHE 1;`
-  )
-  lines.push(`ALTER SEQUENCE items_id_seq OWNED BY items.id;`)
-  lines.push(
-    `ALTER TABLE ONLY items ALTER COLUMN id SET DEFAULT nextval('items_id_seq'::regclass);`
-  )
-  lines.push('')
-
-  lines.push(`CREATE TABLE tags (
-  id integer NOT NULL,
-  item_id integer,
-  label text NOT NULL
-);`)
-  lines.push('')
-  lines.push(
-    `CREATE SEQUENCE tags_id_seq AS integer START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE CACHE 1;`
-  )
-  lines.push(`ALTER SEQUENCE tags_id_seq OWNED BY tags.id;`)
-  lines.push(
-    `ALTER TABLE ONLY tags ALTER COLUMN id SET DEFAULT nextval('tags_id_seq'::regclass);`
-  )
-  lines.push('')
-
-  // view + function
-  lines.push(`CREATE VIEW item_summary AS
-  SELECT i.id, i.name, count(t.id) AS tag_count
-  FROM items i LEFT JOIN tags t ON t.item_id = i.id
-  GROUP BY i.id, i.name;`)
-  lines.push('')
-  lines.push(
-    `CREATE FUNCTION item_count() RETURNS integer LANGUAGE sql AS $$SELECT count(*)::integer FROM items$$;`
-  )
-  lines.push('')
-
-  // COPY items data (200 rows)
-  lines.push('COPY items (id, name, data, score) FROM stdin;')
-  for (let i = 0; i < 200; i++) {
-    const id = i + 1
-    const name = i % 7 === 0 ? `O'Brien's item #${i}` : `item-${i}`
-    const data = i % 11 === 0 ? '\\N' : `data-${'x'.repeat(100)}-${i}`
-    const score = i * 10
-    // COPY text format: tab-separated, \N for NULL, backslash escapes
-    lines.push(`${id}\t${escapeCopy(name)}\t${data}\t${score}`)
-  }
-  lines.push('\\.')
-  lines.push('')
-
-  // COPY tags data (50 rows)
-  lines.push('COPY tags (id, item_id, label) FROM stdin;')
-  for (let i = 0; i < 50; i++) {
-    lines.push(`${i + 1}\t${(i % 200) + 1}\ttag-${i}`)
-  }
-  lines.push('\\.')
-  lines.push('')
-
-  // constraints (pg_dump adds these after data)
-  lines.push('ALTER TABLE ONLY items ADD CONSTRAINT items_pkey PRIMARY KEY (id);')
-  lines.push('ALTER TABLE ONLY tags ADD CONSTRAINT tags_pkey PRIMARY KEY (id);')
-  lines.push(
-    'ALTER TABLE ONLY tags ADD CONSTRAINT tags_item_id_fkey FOREIGN KEY (item_id) REFERENCES items(id);'
-  )
-  lines.push('')
-
-  // sequence values
-  lines.push(`SELECT pg_catalog.setval('items_id_seq', 200, true);`)
-  lines.push(`SELECT pg_catalog.setval('tags_id_seq', 50, true);`)
-  lines.push('')
-
-  return lines.join('\n')
-}
-
-// escape a value for COPY text format
-function escapeCopy(val: string): string {
-  return val.replace(/\\/g, '\\\\').replace(/\t/g, '\\t').replace(/\n/g, '\\n')
-}
-
-describe('restore integration', { timeout: 120_000 }, () => {
-  let db: PGlite
-  let pgPort: number
-  let zeroPort: number
-  let shutdown: () => Promise<void>
-  let dataDir: string
-  let dumpFile: string
-
-  beforeAll(async () => {
-    await loadModule()
-
-    // write dump file
-    dumpFile = join(tmpdir(), `orez-restore-test-${Date.now()}.sql`)
-    writeFileSync(dumpFile, generateDump())
-    dataDir = `.orez-restore-test-${Date.now()}`
-
-    // start orez without zero-cache (restore doesn't need sync)
-    const fresh = await startZeroLite({
-      pgPort: 25000 + Math.floor(Math.random() * 1000),
-      zeroPort: 26000 + Math.floor(Math.random() * 1000),
-      dataDir,
-      logLevel: 'warn',
-      skipZeroCache: true,
-    })
-
-    db = fresh.db
-    pgPort = fresh.pgPort
-    zeroPort = fresh.zeroPort
-    shutdown = fresh.stop
-
-    // restore via wire protocol
-    const sql = postgres({
-      host: '127.0.0.1',
-      port: pgPort,
-      user: 'user',
-      password: 'password',
-      database: 'postgres',
-      max: 1,
-    })
-
-    const wireDb = { exec: (query: string) => sql.unsafe(query) as Promise<unknown> }
-    const result = await execDumpFile(wireDb, dumpFile)
-    console.log(
-      `[restore-test] restored: ${result.executed} executed, ${result.skipped} skipped`
-    )
-    await sql.end()
-  }, 60_000)
-
-  afterAll(async () => {
-    if (shutdown) await shutdown()
-    if (dataDir) {
-      try {
-        rmSync(dataDir, { recursive: true, force: true })
-      } catch {}
-    }
-    if (dumpFile) {
-      try {
-        unlinkSync(dumpFile)
-      } catch {}
-    }
-  })
-
-  test('tables exist and row counts match', async () => {
-    const sql = wireClient()
-    try {
-      const items = await sql`SELECT count(*) as cnt FROM items`
-      expect(Number(items[0].cnt)).toBe(200)
-
-      const tags = await sql`SELECT count(*) as cnt FROM tags`
-      expect(Number(tags[0].cnt)).toBe(50)
-    } finally {
-      await sql.end()
-    }
-  })
-
-  test('data integrity preserved (quotes, nulls, large values)', async () => {
-    const sql = wireClient()
-    try {
-      const quoted =
-        await sql`SELECT name FROM items WHERE name LIKE ${"O'Brien%"} LIMIT 1`
-      expect(quoted[0].name).toContain("O'Brien")
-
-      const nulls = await sql`SELECT count(*) as cnt FROM items WHERE data IS NULL`
-      expect(Number(nulls[0].cnt)).toBeGreaterThan(0)
-
-      const scores = await sql`SELECT min(score) as lo, max(score) as hi FROM items`
-      expect(Number(scores[0].lo)).toBe(0)
-      expect(Number(scores[0].hi)).toBe(1990)
-    } finally {
-      await sql.end()
-    }
-  })
-
-  test('views work after restore', async () => {
-    const sql = wireClient()
-    try {
-      const summary = await sql`SELECT * FROM item_summary ORDER BY id LIMIT 3`
-      expect(summary.length).toBe(3)
-      expect(summary[0]).toHaveProperty('name')
-      expect(summary[0]).toHaveProperty('tag_count')
-    } finally {
-      await sql.end()
-    }
-  })
-
-  test('functions work after restore', async () => {
-    const sql = wireClient()
-    try {
-      const result = await sql`SELECT item_count() as cnt`
-      expect(Number(result[0].cnt)).toBe(200)
-    } finally {
-      await sql.end()
-    }
-  })
-
-  test('foreign keys intact', async () => {
-    const sql = wireClient()
-    try {
-      const joined =
-        await sql`SELECT t.label, i.name FROM tags t JOIN items i ON i.id = t.item_id LIMIT 1`
-      expect(joined.length).toBe(1)
-
-      // FK enforced — inserting with nonexistent item_id should fail
-      try {
-        await sql`INSERT INTO tags (item_id, label) VALUES (99999, 'bad')`
-        expect.unreachable('should have thrown FK violation')
-      } catch (err: any) {
-        expect(err.message).toContain('foreign key')
-      }
-    } finally {
-      await sql.end()
-    }
-  })
-
-  test('new inserts via wire protocol work after restore', async () => {
-    const sql = wireClient()
-    try {
-      await sql`INSERT INTO items (name, score) VALUES ('post-restore', 9999)`
-      const result = await sql`SELECT * FROM items WHERE name = 'post-restore'`
-      expect(result.length).toBe(1)
-      expect(Number(result[0].score)).toBe(9999)
-    } finally {
-      await sql.end()
-    }
-  })
-
-  // --- helpers ---
-
-  function wireClient() {
-    return postgres({
-      host: '127.0.0.1',
-      port: pgPort,
-      user: 'user',
-      password: 'password',
-      database: 'postgres',
-      max: 1,
-    })
-  }
-})