orez 0.0.63 → 0.0.64

package/src/index.ts

@@ -11,9 +11,14 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import { createRequire } from 'node:module'
 import { resolve } from 'node:path'
 
+import {
+  createHttpLogStore,
+  startHttpProxy,
+  type HttpLogStore,
+} from './admin/http-proxy.js'
 import { createLogStore, type LogStore } from './admin/log-store.js'
 import { getConfig, getConnectionString } from './config.js'
-import { log, port, setLogLevel } from './log.js'
+import { log, port, setLogLevel, setLogStore } from './log.js'
 import { startPgProxy } from './pg-proxy.js'
 import { createPGliteInstances, runMigrations } from './pglite-manager.js'
 import { findPort } from './port.js'
@@ -97,6 +102,13 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
   const logStore: LogStore | undefined =
     adminPort > 0 ? createLogStore(config.dataDir) : undefined
 
+  // wire up logStore so all log.* calls flow to admin dashboard
+  setLogStore(logStore)
+
+  // create http log store for HTTP tab
+  const httpLog: HttpLogStore | undefined =
+    adminPort > 0 ? createHttpLogStore() : undefined
+
   log.debug.orez(`data dir: ${resolve(config.dataDir)}`)
 
   mkdirSync(config.dataDir, { recursive: true })
@@ -148,14 +160,35 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
   // clean up stale sqlite replica from previous runs
   cleanupStaleReplica(config)
 
+  // when admin is enabled, zero-cache runs on internal port with http proxy in front
+  let zeroInternalPort = config.zeroPort
+  let httpProxyServer: import('node:http').Server | null = null
+  if (httpLog && !config.skipZeroCache) {
+    zeroInternalPort = await findPort(config.zeroPort + 1000)
+    log.debug.orez(`http proxy: public ${config.zeroPort} → internal ${zeroInternalPort}`)
+  }
+
   // start zero-cache
   let zeroCacheProcess: ChildProcess | null = null
   let zeroEnv: Record<string, string> = {}
   if (!config.skipZeroCache) {
-    const result = await startZeroCache(config, logStore)
+    // use internal port when http proxy is enabled
+    const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
+    const result = await startZeroCache(zeroConfig, logStore)
     zeroCacheProcess = result.process
     zeroEnv = result.env
-    await waitForZeroCache(config)
+    await waitForZeroCache(zeroConfig)
+
+    // start http proxy in front of zero-cache when admin is enabled
+    if (httpLog) {
+      httpProxyServer = await startHttpProxy({
+        listenPort: config.zeroPort,
+        targetPort: zeroInternalPort,
+        httpLog,
+      })
+      log.debug.orez(`http proxy listening on ${config.zeroPort}`)
+    }
+
     log.zero(`ready ${port(config.zeroPort, 'magenta')}`)
   } else {
     log.orez('skip zero-cache')
@@ -169,50 +202,82 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
     })
   }
 
-  // flag to ignore connection errors during reset
-  let resettingZeroState = false
+  const killZeroCache = async () => {
+    if (zeroCacheProcess && !zeroCacheProcess.killed) {
+      zeroCacheProcess.kill('SIGTERM')
+      await new Promise<void>((r) => {
+        const timeout = setTimeout(() => {
+          if (zeroCacheProcess && !zeroCacheProcess.killed) {
+            zeroCacheProcess.kill('SIGKILL')
+          }
+          r()
+        }, 3000)
+        zeroCacheProcess!.on('exit', () => {
+          clearTimeout(timeout)
+          r()
+        })
+      })
+    }
+  }
 
-  // handle SIGUSR1 to reset zero state (sent by pg_restore)
-  if (!config.skipZeroCache) {
-    process.on('SIGUSR1', async () => {
-      resettingZeroState = true
-      try {
-        log.orez('received SIGUSR1, resetting zero state...')
+  // simple restart without any state cleanup
+  const restartZeroCache = async () => {
+    await killZeroCache()
+    // use internal port when http proxy is enabled
+    const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
+    const result = await startZeroCache(zeroConfig, logStore)
+    zeroCacheProcess = result.process
+    zeroEnv = result.env
+    await waitForZeroCache(zeroConfig)
+  }
 
-        // stop zero-cache first so it stops making connections
-        log.orez('stopping zero-cache...')
-        await killZeroCache()
-        log.orez('zero-cache stopped')
+  // unified reset function for zero state
+  // modes:
+  //   'cache-only' - deletes replica file only (fast, for minor sync issues)
+  //   'full' - deletes CVR/CDB + replica and recreates instances (for schema changes)
+  let resetInProgress = false
+  const resetFile = resolve(config.dataDir, 'orez.resetting')
+  const resetZeroState = async (mode: 'cache-only' | 'full'): Promise<void> => {
+    if (resetInProgress) {
+      log.orez('reset already in progress, skipping')
+      return
+    }
+    resetInProgress = true
+    // write marker file so pg_restore can wait for reset to complete
+    writeFileSync(resetFile, String(Date.now()))
 
-        // give connections time to drain
+    try {
+      log.orez(`resetting zero state (${mode})...`)
+
+      // stop zero-cache first
+      log.orez('stopping zero-cache...')
+      await killZeroCache()
+      log.orez('zero-cache stopped')
+
+      if (mode === 'full') {
+        // give connections time to drain before closing instances
         await new Promise((r) => setTimeout(r, 500))
 
         // close CVR/CDB instances
         log.orez('closing CVR/CDB...')
-        try {
-          await instances.cvr.close()
-        } catch (e: any) {
+        await instances.cvr.close().catch((e: any) => {
           log.debug.orez(`cvr close error (expected): ${e?.message || e}`)
-        }
-        try {
-          await instances.cdb.close()
-        } catch (e: any) {
+        })
+        await instances.cdb.close().catch((e: any) => {
           log.debug.orez(`cdb close error (expected): ${e?.message || e}`)
-        }
+        })
         log.orez('CVR/CDB closed')
 
-        // delete zero state files
-        log.orez('deleting zero state files...')
+        // delete CVR/CDB data directories
+        log.orez('deleting CVR/CDB data...')
         const { rmSync } = await import('node:fs')
         for (const dir of ['pgdata-cvr', 'pgdata-cdb']) {
           try {
             rmSync(resolve(config.dataDir, dir), { recursive: true, force: true })
           } catch {}
         }
-        cleanupStaleReplica(config)
-        log.orez('zero state files deleted')
 
-        // recreate CVR/CDB with fresh instances
+        // recreate CVR/CDB instances
         log.orez('recreating CVR/CDB...')
         const { PGlite } = await import('@electric-sql/pglite')
         mkdirSync(resolve(config.dataDir, 'pgdata-cvr'), { recursive: true })
@@ -228,78 +293,67 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
         await instances.cvr.waitReady
         await instances.cdb.waitReady
         log.orez('CVR/CDB recreated')
+      }
 
-        // restart zero-cache
-        log.orez('starting zero-cache...')
-        const result = await startZeroCache(config, logStore)
-        zeroCacheProcess = result.process
-        zeroEnv = result.env
-
-        // listen for early exit
-        zeroCacheProcess.once('exit', (code) => {
-          if (code !== 0) {
-            log.orez(`zero-cache exited early with code ${code}`)
-          }
+      // always clean up replica file
+      cleanupStaleReplica(config)
+      log.orez('replica cleaned up')
+
+      // re-run on-db-ready hook after full reset (re-runs migrations, syncs publication)
+      if (mode === 'full' && config.onDbReady) {
+        log.orez('re-running on-db-ready...')
+        const upstreamUrl = getConnectionString(config, 'postgres')
+        const cvrUrl = getConnectionString(config, 'zero_cvr')
+        const cdbUrl = getConnectionString(config, 'zero_cdb')
+        await runHook(config.onDbReady, 'on-db-ready', {
+          ZERO_UPSTREAM_DB: upstreamUrl,
+          ZERO_CVR_DB: cvrUrl,
+          ZERO_CHANGE_DB: cdbUrl,
+          DATABASE_URL: upstreamUrl,
+          OREZ_PG_PORT: String(config.pgPort),
         })
 
-        await waitForZeroCache(config)
-        log.orez('zero state reset complete')
-        log.zero(`ready ${port(config.zeroPort, 'magenta')}`)
-      } catch (err: any) {
-        log.orez(`SIGUSR1 reset failed: ${err?.message || err}`)
-        console.error(err)
-      } finally {
-        resettingZeroState = false
+        // re-install change tracking on any tables created/modified by on-db-ready
+        log.debug.orez('re-installing change tracking after on-db-ready')
+        await installChangeTracking(db)
       }
-    })
-  }
 
-  // ignore network errors during zero state reset
-  process.on('uncaughtException', (err: any) => {
-    if (resettingZeroState) {
-      const code = err?.code
-      if (
-        code === 'ECONNRESET' ||
-        code === 'EPIPE' ||
-        code === 'ENOTCONN' ||
-        code === 'ERR_STREAM_DESTROYED'
-      ) {
-        log.debug.orez(`ignoring ${code} during reset`)
-        return
-      }
-    }
-    throw err
-  })
-
-  const killZeroCache = async () => {
-    if (zeroCacheProcess && !zeroCacheProcess.killed) {
-      zeroCacheProcess.kill('SIGTERM')
-      await new Promise<void>((r) => {
-        const timeout = setTimeout(() => {
-          if (zeroCacheProcess && !zeroCacheProcess.killed) {
-            zeroCacheProcess.kill('SIGKILL')
-          }
-          r()
-        }, 3000)
-        zeroCacheProcess!.on('exit', () => {
-          clearTimeout(timeout)
-          r()
-        })
-      })
+      // restart zero-cache
+      log.orez('starting zero-cache...')
+      // use internal port when http proxy is enabled
+      const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
+      const result = await startZeroCache(zeroConfig, logStore)
+      zeroCacheProcess = result.process
+      zeroEnv = result.env
+
+      await waitForZeroCache(zeroConfig)
+      log.orez(`zero state reset complete (${mode})`)
+      log.zero(`ready ${port(config.zeroPort, 'magenta')}`)
+    } catch (err: any) {
+      log.orez(`reset failed: ${err?.message || err}`)
+      throw err
+    } finally {
+      resetInProgress = false
+      // remove marker file so pg_restore knows we're done
+      try {
+        unlinkSync(resetFile)
+      } catch {}
     }
   }
 
-  const restartZeroCache = async (cleanup = false) => {
-    await killZeroCache()
-    if (cleanup) cleanupStaleReplica(config)
-    const result = await startZeroCache(config, logStore)
-    zeroCacheProcess = result.process
-    zeroEnv = result.env
-    await waitForZeroCache(config)
+  // handle SIGUSR1 to reset zero state (sent by pg_restore)
+  if (!config.skipZeroCache) {
+    process.on('SIGUSR1', () => {
+      log.orez('received SIGUSR1')
+      resetZeroState('full').catch((err) => {
+        log.orez(`SIGUSR1 reset failed: ${err?.message || err}`)
+      })
+    })
   }
 
   const stop = async () => {
     log.debug.orez('shutting down')
+    httpProxyServer?.close()
     await killZeroCache()
     pgServer.close()
     await Promise.all([
@@ -321,9 +375,13 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
     pgPort: config.pgPort,
     zeroPort: config.zeroPort,
     logStore,
+    httpLog,
     zeroEnv,
-    restartZero: config.skipZeroCache ? undefined : () => restartZeroCache(false),
-    resetZero: config.skipZeroCache ? undefined : () => restartZeroCache(true),
+    restartZero: config.skipZeroCache ? undefined : restartZeroCache,
+    // cache-only reset: just replica file (fast, for minor sync issues)
+    resetZero: config.skipZeroCache ? undefined : () => resetZeroState('cache-only'),
+    // full reset: CVR/CDB + replica (for schema changes, used by pg_restore via SIGUSR1)
+    resetZeroFull: config.skipZeroCache ? undefined : () => resetZeroState('full'),
   }
 }
 

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

@@ -0,0 +1,284 @@
+/**
+ * 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 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 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
+
+    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
+      )
+    `)
+
+    const downstream = new Queue<unknown>()
+    const ws = connectAndSubscribe(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>
+): WebSocket {
+  const ws = new WebSocket(
+    `ws://localhost:${port}/sync/v4/connect` +
+      `?clientGroupID=restore-reset-cg-${Date.now()}&clientID=restore-reset-client&wsid=ws1&schemaVersion=1&baseCookie=&ts=${Date.now()}&lmid=0`
+  )
+
+  ws.on('message', (data) => {
+    downstream.enqueue(JSON.parse(data.toString()))
+  })
+
+  ws.on('open', () => {
+    ws.send(
+      JSON.stringify([
+        'initConnection',
+        {
+          desiredQueriesPatch: [{ op: 'put', hash: 'q1', ast: query }],
+        },
+      ])
+    )
+  })
+
+  return ws
+}
+
+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/log.ts

@@ -1,3 +1,4 @@
+import type { LogStore } from './admin/log-store.js'
 import type { LogLevel } from './config.js'
 
 const RESET = '\x1b[0m'
@@ -20,11 +21,17 @@ const LEVEL_PRIORITY: Record<LogLevel, number> = {
 }
 
 let currentLevel: LogLevel = 'warn'
+let logStore: LogStore | undefined
 
 export function setLogLevel(level: LogLevel) {
   currentLevel = level
 }
 
+/** hook up logStore for admin dashboard observability */
+export function setLogStore(store: LogStore | undefined) {
+  logStore = store
+}
+
 function prefix(label: string, color: string): string {
   return `${BOLD}${color}[${label}]${RESET}`
 }
@@ -39,12 +46,30 @@ export function url(u: string): string {
   return `${COLORS.yellow}${u}${RESET}`
 }
 
+// map logger labels to logStore source names
+const LABEL_TO_SOURCE: Record<string, string> = {
+  orez: 'orez',
+  'orez:pg': 'orez',
+  pglite: 'pglite',
+  'pg-proxy': 'proxy',
+  'orez:zero': 'zero',
+  'orez:s3': 's3',
+}
+
 function makeLogger(label: string, color: string, level: LogLevel = 'info') {
   const p = prefix(label, color)
+  const source = LABEL_TO_SOURCE[label] || 'orez'
+  // zero logs are handled specially in startZeroCache with better level detection
+  const skipLogStore = source === 'zero'
   return (...args: unknown[]) => {
     if (LEVEL_PRIORITY[level] <= LEVEL_PRIORITY[currentLevel]) {
       console.info(p, ...args)
     }
+    // always push to logStore if available (admin captures all levels)
+    if (logStore && !skipLogStore) {
+      const msg = args.map((a) => (typeof a === 'string' ? a : String(a))).join(' ')
+      logStore.push(source, level, msg)
+    }
   }
 }
 

package/src/pglite-manager.ts

@@ -150,15 +150,17 @@ export async function createPGliteInstances(
   // postgres-specific setup
   await postgres.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
 
-  // create empty publication for zero-cache on postgres instance
-  const pubName = process.env.ZERO_APP_PUBLICATIONS || 'zero_pub'
-  const pubs = await postgres.query<{ count: string }>(
-    `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-    [pubName]
-  )
-  if (Number(pubs.rows[0].count) === 0) {
-    const quoted = '"' + pubName.replace(/"/g, '""') + '"'
-    await postgres.exec(`CREATE PUBLICATION ${quoted}`)
+  // create publication only when explicitly configured
+  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
+  if (pubName) {
+    const pubs = await postgres.query<{ count: string }>(
+      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
+      [pubName]
+    )
+    if (Number(pubs.rows[0].count) === 0) {
+      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
+      await postgres.exec(`CREATE PUBLICATION ${quoted}`)
+    }
   }
 
   return { postgres, cvr, cdb }