orez 0.0.47 → 0.0.48

package/src/cli.ts

@@ -788,23 +788,24 @@ const main = defineCommand({
   },
   async run({ args }) {
     const startTime = Date.now()
-    const { config, stop, logStore, zeroEnv, actions, httpLogStore } = await startZeroLite({
-      pgPort: Number(args['pg-port']),
-      zeroPort: Number(args['zero-port']),
-      dataDir: args['data-dir'],
-      migrationsDir: args.migrations,
-      seedFile: args.seed,
-      pgUser: args['pg-user'],
-      pgPassword: args['pg-password'],
-      skipZeroCache: args['skip-zero-cache'],
-      disableWasmSqlite: args['disable-wasm-sqlite'],
-      logLevel: (args['log-level'] as 'error' | 'warn' | 'info' | 'debug') || undefined,
-      logEnv: args['log-env'],
-      onDbReady: args['on-db-ready'],
-      admin: args.admin,
-      adminPort: Number(args['admin-port']),
-      adminLogs: args['admin-logs'],
-    })
+    const { config, stop, logStore, zeroEnv, actions, httpLogStore } =
+      await startZeroLite({
+        pgPort: Number(args['pg-port']),
+        zeroPort: Number(args['zero-port']),
+        dataDir: args['data-dir'],
+        migrationsDir: args.migrations,
+        seedFile: args.seed,
+        pgUser: args['pg-user'],
+        pgPassword: args['pg-password'],
+        skipZeroCache: args['skip-zero-cache'],
+        disableWasmSqlite: args['disable-wasm-sqlite'],
+        logLevel: (args['log-level'] as 'error' | 'warn' | 'info' | 'debug') || undefined,
+        logEnv: args['log-env'],
+        onDbReady: args['on-db-ready'],
+        admin: args.admin,
+        adminPort: Number(args['admin-port']),
+        adminLogs: args['admin-logs'],
+      })
 
     let s3Server: import('node:http').Server | null = null
     if (args.s3) {
@@ -818,7 +819,7 @@ const main = defineCommand({
     let adminServer: import('node:http').Server | null = null
     if (args.admin && logStore) {
       const { findPort } = await import('./port.js')
-      const adminPort = Number(args['admin-port']) || (config.zeroPort + 2)
+      const adminPort = Number(args['admin-port']) || config.zeroPort + 2
       const resolvedPort = await findPort(adminPort)
       const { startAdminServer } = await import('./admin/server.js')
       adminServer = await startAdminServer({

package/src/index.ts

@@ -7,7 +7,14 @@
  */
 
 import { spawn, type ChildProcess } from 'node:child_process'
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import { createRequire } from 'node:module'
 import { totalmem } from 'node:os'
 import { dirname, resolve } from 'node:path'
@@ -20,10 +27,10 @@ import { createInstance, createPGliteInstances, runMigrations } from './pglite-m
 import { findPort } from './port.js'
 import { installChangeTracking } from './replication/change-tracker.js'
 
+import type { HttpLogStore } from './admin/http-proxy.js'
+import type { LogStore } from './admin/log-store.js'
 import type { ZeroLiteConfig } from './config.js'
 import type { PGlite } from '@electric-sql/pglite'
-import type { LogStore } from './admin/log-store.js'
-import type { HttpLogStore } from './admin/http-proxy.js'
 
 export { getConfig, getConnectionString } from './config.js'
 export type { LogLevel, ZeroLiteConfig } from './config.js'
@@ -47,8 +54,12 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
 
   // when admin ui enabled, create log store and capture all log output
   const SOURCE_MAP: Record<string, string> = {
-    'orez': 'orez', 'pglite': 'pglite', 'pg-proxy': 'proxy',
-    'zero': 'zero', 'zero-cache': 'zero', 'orez/s3': 's3',
+    orez: 'orez',
+    pglite: 'pglite',
+    'pg-proxy': 'proxy',
+    zero: 'zero',
+    'zero-cache': 'zero',
+    'orez/s3': 's3',
   }
   let logStore: LogStore | null = null
   let removeLogListener: (() => void) | null = null
@@ -180,13 +191,17 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
         }
         const elapsed = now - cdbResets.lastReset
         if (elapsed < MIN_RESET_INTERVAL_MS) {
-          log.zero(`change db reset too soon (${Math.round(elapsed / 1000)}s ago), not retrying`)
+          log.zero(
+            `change db reset too soon (${Math.round(elapsed / 1000)}s ago), not retrying`
+          )
           return
         }
 
         cdbResets.count++
         cdbResets.lastReset = now
-        log.zero(`stale change db detected, resetting (${cdbResets.count}/${MAX_CDB_RESETS})`)
+        log.zero(
+          `stale change db detected, resetting (${cdbResets.count}/${MAX_CDB_RESETS})`
+        )
 
         try {
           await instances.cdb.close()
@@ -224,36 +239,54 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
 
   // admin action handlers
   const actions = {
-    restartZero: config.skipZeroCache ? undefined : async () => {
-      if (zeroCacheProcess && !zeroCacheProcess.killed) {
-        zeroCacheProcess.kill('SIGTERM')
-        await new Promise<void>((r) => {
-          const t = setTimeout(() => { zeroCacheProcess?.kill('SIGKILL'); r() }, 3000)
-          zeroCacheProcess!.on('exit', () => { clearTimeout(t); r() })
-        })
-      }
-      const zc = await startZeroCache(config, zeroInternalPort)
-      zeroCacheProcess = zc.child
-      await waitForZeroCache(config, undefined, zeroInternalPort)
-      log.zero(`restarted ${port(config.zeroPort, 'magenta')}`)
-    },
-    resetZero: config.skipZeroCache ? undefined : async () => {
-      if (zeroCacheProcess && !zeroCacheProcess.killed) {
-        zeroCacheProcess.kill('SIGTERM')
-        await new Promise<void>((r) => {
-          const t = setTimeout(() => { zeroCacheProcess?.kill('SIGKILL'); r() }, 3000)
-          zeroCacheProcess!.on('exit', () => { clearTimeout(t); r() })
-        })
-      }
-      const replicaPath = resolve(config.dataDir, 'zero-replica.db')
-      for (const suffix of ['', '-wal', '-shm', '-wal2']) {
-        try { if (existsSync(replicaPath + suffix)) unlinkSync(replicaPath + suffix) } catch {}
-      }
-      const zc = await startZeroCache(config, zeroInternalPort)
-      zeroCacheProcess = zc.child
-      await waitForZeroCache(config, undefined, zeroInternalPort)
-      log.zero(`reset and restarted ${port(config.zeroPort, 'magenta')}`)
-    },
+    restartZero: config.skipZeroCache
+      ? undefined
+      : async () => {
+          if (zeroCacheProcess && !zeroCacheProcess.killed) {
+            zeroCacheProcess.kill('SIGTERM')
+            await new Promise<void>((r) => {
+              const t = setTimeout(() => {
+                zeroCacheProcess?.kill('SIGKILL')
+                r()
+              }, 3000)
+              zeroCacheProcess!.on('exit', () => {
+                clearTimeout(t)
+                r()
+              })
+            })
+          }
+          const zc = await startZeroCache(config, zeroInternalPort)
+          zeroCacheProcess = zc.child
+          await waitForZeroCache(config, undefined, zeroInternalPort)
+          log.zero(`restarted ${port(config.zeroPort, 'magenta')}`)
+        },
+    resetZero: config.skipZeroCache
+      ? undefined
+      : async () => {
+          if (zeroCacheProcess && !zeroCacheProcess.killed) {
+            zeroCacheProcess.kill('SIGTERM')
+            await new Promise<void>((r) => {
+              const t = setTimeout(() => {
+                zeroCacheProcess?.kill('SIGKILL')
+                r()
+              }, 3000)
+              zeroCacheProcess!.on('exit', () => {
+                clearTimeout(t)
+                r()
+              })
+            })
+          }
+          const replicaPath = resolve(config.dataDir, 'zero-replica.db')
+          for (const suffix of ['', '-wal', '-shm', '-wal2']) {
+            try {
+              if (existsSync(replicaPath + suffix)) unlinkSync(replicaPath + suffix)
+            } catch {}
+          }
+          const zc = await startZeroCache(config, zeroInternalPort)
+          zeroCacheProcess = zc.child
+          await waitForZeroCache(config, undefined, zeroInternalPort)
+          log.zero(`reset and restarted ${port(config.zeroPort, 'magenta')}`)
+        },
   }
 
   const stop = async () => {
@@ -285,7 +318,18 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
     log.debug.orez('stopped')
   }
 
-  return { config, stop, db, instances, pgPort: config.pgPort, zeroPort: config.zeroPort, logStore, zeroEnv, actions, httpLogStore }
+  return {
+    config,
+    stop,
+    db,
+    instances,
+    pgPort: config.pgPort,
+    zeroPort: config.zeroPort,
+    logStore,
+    zeroEnv,
+    actions,
+    httpLogStore,
+  }
 }
 
 function cleanupStaleLockFiles(config: ZeroLiteConfig): void {
@@ -364,7 +408,10 @@ function writeSqliteShim(): string {
   return registerPath
 }
 
-async function startZeroCache(config: ZeroLiteConfig, portOverride?: number): Promise<{ child: ChildProcess; env: Record<string, string>; stderrBuf: string }> {
+async function startZeroCache(
+  config: ZeroLiteConfig,
+  portOverride?: number
+): Promise<{ child: ChildProcess; env: Record<string, string>; stderrBuf: string }> {
   // resolve @rocicorp/zero entry for finding zero-cache modules
   const zeroEntry = resolvePackage('@rocicorp/zero')
 
@@ -533,7 +580,7 @@ async function startZeroCache(config: ZeroLiteConfig, portOverride?: number): Pr
 async function waitForZeroCache(
   config: ZeroLiteConfig,
   timeoutMs = 120000,
-  portOverride?: number,
+  portOverride?: number
 ): Promise<void> {
   const start = Date.now()
   const url = `http://127.0.0.1:${portOverride || config.zeroPort}/`

package/src/pg-proxy.ts

@@ -694,7 +694,9 @@ export async function startPgProxy(
       // track active connections per database
       activeConns[dbName] = (activeConns[dbName] || 0) + 1
 
-      console.info(`[orez-proxy#${connId}] connect db=${dbName} repl=${params.replication || 'none'}`)
+      console.info(
+        `[orez-proxy#${connId}] connect db=${dbName} repl=${params.replication || 'none'}`
+      )
 
       const { db } = getDbContext(dbName)
       await db.waitReady

package/src/pglite-manager.ts

@@ -133,8 +133,15 @@ export async function runMigrations(db: PGlite, config: ZeroLiteConfig): Promise
       continue
     }
 
+    const filePath = join(migrationsDir, file)
+    if (!existsSync(filePath)) {
+      // .ts-only custom migrations are handled by the app's own migration runner
+      log.debug.orez(`skipping migration (no .sql file): ${name}`)
+      continue
+    }
+
     log.debug.orez(`applying migration: ${name}`)
-    const sql = readFileSync(join(migrationsDir, file), 'utf-8')
+    const sql = readFileSync(filePath, 'utf-8')
 
     // split by drizzle's statement-breakpoint marker
     const statements = sql

package/src/replication/change-tracker.ts

@@ -67,35 +67,6 @@ export async function installChangeTracking(db: PGlite): Promise<void> {
     $$ LANGUAGE plpgsql;
   `)
 
-  // auto-install change tracking on tables created after startup (e.g. via restore
-  // or wire protocol). uses a DDL event trigger that fires on CREATE TABLE.
-  await db.exec(`
-    CREATE OR REPLACE FUNCTION public._zero_auto_track() RETURNS event_trigger AS $$
-    DECLARE
-      obj record;
-    BEGIN
-      FOR obj IN SELECT * FROM pg_event_trigger_ddl_commands()
-                 WHERE command_tag = 'CREATE TABLE'
-      LOOP
-        IF obj.schema_name = 'public'
-           AND obj.object_identity NOT LIKE '%._zero_%'
-           AND obj.object_identity NOT LIKE '%.migrations'
-        THEN
-          EXECUTE format(
-            'CREATE TRIGGER _zero_change_trigger AFTER INSERT OR UPDATE OR DELETE ON %s FOR EACH ROW EXECUTE FUNCTION public._zero_track_change()',
-            obj.object_identity
-          );
-        END IF;
-      END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-
-    DROP EVENT TRIGGER IF EXISTS _zero_auto_track_trigger;
-    CREATE EVENT TRIGGER _zero_auto_track_trigger ON ddl_command_end
-      WHEN TAG IN ('CREATE TABLE')
-      EXECUTE FUNCTION public._zero_auto_track();
-  `)
-
   // install triggers on all public tables
   await installTriggersOnAllTables(db)
 }
@@ -239,10 +210,29 @@ export async function installTriggersOnShardTables(db: PGlite): Promise<void> {
 
   if (result.rows.length === 0) return
 
+  // only track `clients` — that's the table zero-cache expects in the
+  // replication stream (needed for .server promise resolution).  other shard
+  // tables like `replicas` are zero-cache internal state and streaming them
+  // back causes "Unknown table" crashes in zero-cache's change-processor.
   let count = 0
   for (const { nspname } of result.rows) {
+    // remove stale triggers from non-clients tables (from previous versions)
+    const stale = await db.query<{ event_object_table: string }>(
+      `SELECT DISTINCT event_object_table FROM information_schema.triggers
+       WHERE trigger_name = '_zero_change_trigger'
+         AND event_object_schema = $1
+         AND event_object_table != 'clients'`,
+      [nspname]
+    )
+    for (const { event_object_table } of stale.rows) {
+      const qs = quoteIdent(nspname)
+      const qt = quoteIdent(event_object_table)
+      await db.exec(`DROP TRIGGER IF EXISTS _zero_change_trigger ON ${qs}.${qt}`)
+      log.debug.pglite(`removed stale shard trigger from ${nspname}.${event_object_table}`)
+    }
+
     const tables = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+      `SELECT tablename FROM pg_tables WHERE schemaname = $1 AND tablename = 'clients'`,
       [nspname]
     )
 

package/src/replication/handler.ts

@@ -12,7 +12,6 @@ import {
   getCurrentWatermark,
   purgeConsumedChanges,
   installTriggersOnShardTables,
-  ensureChangeTrackingOnAllTables,
   type ChangeRecord,
 } from './change-tracker.js'
 import {
@@ -268,7 +267,9 @@ export async function handleStartReplication(
 ): Promise<void> {
   activeHandlerCount++
   const handlerId = activeHandlerCount
-  console.info(`[orez-repl#${handlerId}] START_REPLICATION (active handlers: ${activeHandlerCount})`)
+  console.info(
+    `[orez-repl#${handlerId}] START_REPLICATION (active handlers: ${activeHandlerCount})`
+  )
   log.debug.proxy('replication: entering streaming mode')
 
   // send CopyBothResponse to enter streaming mode
@@ -292,9 +293,6 @@ export async function handleStartReplication(
   // "already in transaction" errors when they interleave.
   await mutex.acquire()
   try {
-    // install change tracking triggers on any tables created after startup
-    await ensureChangeTrackingOnAllTables(db)
-
     // install change tracking triggers on shard schema tables (e.g. chat_0.clients)
     // these track zero-cache's lastMutationID for .server promise resolution
     await installTriggersOnShardTables(db)
@@ -353,7 +351,7 @@ export async function handleStartReplication(
     for (const schema of relevantSchemas) {
       if (schema === 'public') continue
       const shardTables = await db.query<{ tablename: string }>(
-        `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+        `SELECT tablename FROM pg_tables WHERE schemaname = $1 AND tablename = 'clients'`,
         [schema]
       )
       for (const { tablename } of shardTables.rows) {
@@ -463,7 +461,9 @@ export async function handleStartReplication(
     mutex.release()
   }
 
-  console.info(`[orez-repl#${handlerId}] setup complete, starting poll (lastWatermark=${lastWatermark})`)
+  console.info(
+    `[orez-repl#${handlerId}] setup complete, starting poll (lastWatermark=${lastWatermark})`
+  )
 
   // track which tables we've sent RELATION messages for
   const sentRelations = new Set<string>()
@@ -492,8 +492,29 @@ export async function handleStartReplication(
         }
 
         if (changes.length > 0) {
-          const tables = [...new Set(changes.map(c => c.table_name))].join(',')
-          console.info(`[orez-repl#${handlerId}] found ${changes.length} changes [${tables}] (wm ${lastWatermark}→${changes[changes.length - 1].watermark}, type=${typeof changes[0].watermark})`)
+          // filter out shard tables that zero-cache doesn't expect.
+          // only `clients` is needed (for .server promise resolution).
+          // other shard tables (replicas, mutations) crash zero-cache
+          // with "Unknown table" in change-processor.
+          const batchEnd = changes[changes.length - 1].watermark
+          changes = changes.filter((c) => {
+            const dot = c.table_name.indexOf('.')
+            if (dot === -1) return true
+            const schema = c.table_name.substring(0, dot)
+            if (schema === 'public') return true
+            const table = c.table_name.substring(dot + 1)
+            return table === 'clients'
+          })
+
+          if (changes.length === 0) {
+            lastWatermark = batchEnd
+            continue
+          }
+
+          const tables = [...new Set(changes.map((c) => c.table_name))].join(',')
+          console.info(
+            `[orez-repl#${handlerId}] found ${changes.length} changes [${tables}] (wm ${lastWatermark}→${changes[changes.length - 1].watermark}, type=${typeof changes[0].watermark})`
+          )
           await streamChanges(
             changes,
             writer,
@@ -503,7 +524,7 @@ export async function handleStartReplication(
             excludedColumns,
             columnTypeOids
           )
-          lastWatermark = changes[changes.length - 1].watermark
+          lastWatermark = batchEnd
 
           // purge consumed changes periodically to free wasm memory
           pollsSincePurge++
@@ -513,7 +534,9 @@ export async function handleStartReplication(
             try {
               const purged = await purgeConsumedChanges(db, lastWatermark)
               if (purged > 0) {
-                console.info(`[orez-repl#${handlerId}] purged ${purged} changes (wm<=${lastWatermark})`)
+                console.info(
+                  `[orez-repl#${handlerId}] purged ${purged} changes (wm<=${lastWatermark})`
+                )
               }
             } finally {
               mutex.release()
@@ -524,7 +547,9 @@ export async function handleStartReplication(
           const now = Date.now()
           if (now - lastIdleLog > 10000) {
             lastIdleLog = now
-            console.info(`[orez-repl#${handlerId}] idle (lastWatermark=${lastWatermark}, type=${typeof lastWatermark})`)
+            console.info(
+              `[orez-repl#${handlerId}] idle (lastWatermark=${lastWatermark}, type=${typeof lastWatermark})`
+            )
           }
         }
 
@@ -550,7 +575,9 @@ export async function handleStartReplication(
   log.debug.proxy('replication: starting poll loop')
   await poll()
   activeHandlerCount--
-  console.info(`[orez-repl#${handlerId}] poll loop exited (remaining handlers: ${activeHandlerCount})`)
+  console.info(
+    `[orez-repl#${handlerId}] poll loop exited (remaining handlers: ${activeHandlerCount})`
+  )
 }
 
 async function streamChanges(