orez 0.0.18 → 0.0.20

package/src/pglite-manager.ts

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync, existsSync, mkdirSync } from 'node:fs'
+import { readFileSync, readdirSync, existsSync, mkdirSync, renameSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 
 import { PGlite } from '@electric-sql/pglite'
@@ -9,11 +9,22 @@ import { log } from './log.js'
 
 import type { ZeroLiteConfig } from './config.js'
 
-export async function createPGliteInstance(config: ZeroLiteConfig): Promise<PGlite> {
-  const dataPath = resolve(config.dataDir, 'pgdata')
+export interface PGliteInstances {
+  postgres: PGlite
+  cvr: PGlite
+  cdb: PGlite
+}
+
+// create a single pglite instance with given dataDir suffix
+async function createInstance(
+  config: ZeroLiteConfig,
+  name: string,
+  withExtensions: boolean
+): Promise<PGlite> {
+  const dataPath = resolve(config.dataDir, `pgdata-${name}`)
   mkdirSync(dataPath, { recursive: true })
 
-  log.debug.pglite(`creating instance at ${dataPath}`)
+  log.debug.pglite(`creating ${name} instance at ${dataPath}`)
   const {
     dataDir: _d,
     debug: _dbg,
@@ -24,34 +35,53 @@ export async function createPGliteInstance(config: ZeroLiteConfig): Promise<PGli
     debug: config.logLevel === 'debug' ? 1 : 0,
     relaxedDurability: true,
     ...userOpts,
-    extensions: userOpts.extensions || { vector, pg_trgm },
+    extensions: withExtensions ? (userOpts.extensions || { vector, pg_trgm }) : {},
   })
 
   await db.waitReady
-  log.debug.pglite('ready')
+  log.debug.pglite(`${name} ready`)
+  return db
+}
 
-  // ensure plpgsql is available (needed by migrations and trigger functions)
-  await db.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
+/**
+ * create separate pglite instances for each "database".
+ *
+ * this mirrors real postgresql where postgres, zero_cvr, and zero_cdb are
+ * independent databases with separate transaction contexts. each instance
+ * has its own session state, so transactions on one database can't be
+ * corrupted by queries on another.
+ */
+export async function createPGliteInstances(config: ZeroLiteConfig): Promise<PGliteInstances> {
+  // migrate from old single-instance layout (pgdata → pgdata-postgres)
+  const oldDataPath = resolve(config.dataDir, 'pgdata')
+  const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
+  if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
+    renameSync(oldDataPath, newDataPath)
+    log.debug.pglite('migrated pgdata → pgdata-postgres')
+  }
+
+  // create all 3 instances in parallel (only postgres needs app extensions)
+  const [postgres, cvr, cdb] = await Promise.all([
+    createInstance(config, 'postgres', true),
+    createInstance(config, 'cvr', false),
+    createInstance(config, 'cdb', false),
+  ])
 
-  // create schemas for multi-db simulation
-  await db.exec('CREATE SCHEMA IF NOT EXISTS zero_cvr')
-  await db.exec('CREATE SCHEMA IF NOT EXISTS zero_cdb')
+  // postgres-specific setup
+  await postgres.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
 
-  // create empty publication for zero-cache
-  // the app's migrations (via --on-db-ready) add specific tables to it,
-  // excluding private tables like user/session/account.
-  // DO NOT use FOR ALL TABLES - it auto-includes every future table.
+  // create empty publication for zero-cache on postgres instance
   const pubName = process.env.ZERO_APP_PUBLICATIONS || 'zero_pub'
-  const pubs = await db.query<{ count: string }>(
+  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 db.exec(`CREATE PUBLICATION ${quoted}`)
+    await postgres.exec(`CREATE PUBLICATION ${quoted}`)
   }
 
-  return db
+  return { postgres, cvr, cdb }
 }
 
 export async function runMigrations(db: PGlite, config: ZeroLiteConfig): Promise<void> {

package/src/replication/change-tracker.test.ts

@@ -33,7 +33,7 @@ describe('change-tracker', () => {
     const changes = await getChangesSince(db, 0)
     expect(changes).toHaveLength(1)
     expect(changes[0].op).toBe('INSERT')
-    expect(changes[0].table_name).toBe('items')
+    expect(changes[0].table_name).toBe('public.items')
     expect(changes[0].row_data).toMatchObject({ name: 'a', value: 1 })
     expect(changes[0].old_data).toBeNull()
   })
@@ -116,8 +116,8 @@ describe('change-tracker', () => {
 
     const changes = await getChangesSince(db, 0)
     const tables = new Set(changes.map((c) => c.table_name))
-    expect(tables).toContain('items')
-    expect(tables).toContain('other')
+    expect(tables).toContain('public.items')
+    expect(tables).toContain('public.other')
   })
 
   it('handles rapid inserts (50 rows)', async () => {
@@ -178,7 +178,7 @@ describe('change-tracker', () => {
     await db.exec(`INSERT INTO public."my""table" (val) VALUES ('works')`)
 
     const changes = await getChangesSince(db, 0)
-    const special = changes.filter((c) => c.table_name === 'my"table')
+    const special = changes.filter((c) => c.table_name === 'public.my"table')
     expect(special).toHaveLength(1)
     expect(special[0].op).toBe('INSERT')
     expect(special[0].row_data).toMatchObject({ val: 'works' })

package/src/replication/change-tracker.ts

@@ -45,18 +45,21 @@ export async function installChangeTracking(db: PGlite): Promise<void> {
   // create trigger function
   await db.exec(`
     CREATE OR REPLACE FUNCTION public._zero_track_change() RETURNS TRIGGER AS $$
+    DECLARE
+      qualified_name TEXT;
     BEGIN
+      qualified_name := TG_TABLE_SCHEMA || '.' || TG_TABLE_NAME;
       IF TG_OP = 'DELETE' THEN
         INSERT INTO public._zero_changes (table_name, op, old_data)
-        VALUES (TG_TABLE_NAME, 'DELETE', row_to_json(OLD)::jsonb);
+        VALUES (qualified_name, 'DELETE', row_to_json(OLD)::jsonb);
         RETURN OLD;
       ELSIF TG_OP = 'UPDATE' THEN
         INSERT INTO public._zero_changes (table_name, op, row_data, old_data)
-        VALUES (TG_TABLE_NAME, 'UPDATE', row_to_json(NEW)::jsonb, row_to_json(OLD)::jsonb);
+        VALUES (qualified_name, 'UPDATE', row_to_json(NEW)::jsonb, row_to_json(OLD)::jsonb);
         RETURN NEW;
       ELSIF TG_OP = 'INSERT' THEN
         INSERT INTO public._zero_changes (table_name, op, row_data)
-        VALUES (TG_TABLE_NAME, 'INSERT', row_to_json(NEW)::jsonb);
+        VALUES (qualified_name, 'INSERT', row_to_json(NEW)::jsonb);
         RETURN NEW;
       END IF;
       RETURN NULL;
@@ -137,6 +140,49 @@ async function installTriggersOnAllTables(db: PGlite): Promise<void> {
   log.debug.pglite(`installed change tracking triggers on ${count} tables`)
 }
 
+/**
+ * install change tracking triggers on tables in shard schemas.
+ * zero-cache creates shard schemas (e.g. chat_0) with clients/mutations
+ * tables that track mutation confirmations. these must be replicated
+ * for .server promises to resolve.
+ */
+export async function installTriggersOnShardTables(db: PGlite): Promise<void> {
+  const result = await db.query<{ nspname: string }>(
+    `SELECT nspname FROM pg_namespace
+     WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast', 'public')
+       AND nspname NOT LIKE 'pg_%'
+       AND nspname NOT LIKE 'zero_%'
+       AND nspname NOT LIKE '_zero_%'
+       AND nspname NOT LIKE '%/%'`
+  )
+
+  if (result.rows.length === 0) return
+
+  let count = 0
+  for (const { nspname } of result.rows) {
+    const tables = await db.query<{ tablename: string }>(
+      `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+      [nspname]
+    )
+
+    for (const { tablename } of tables.rows) {
+      const quotedSchema = quoteIdent(nspname)
+      const quotedTable = quoteIdent(tablename)
+      await db.exec(`
+        DROP TRIGGER IF EXISTS _zero_change_trigger ON ${quotedSchema}.${quotedTable};
+        CREATE TRIGGER _zero_change_trigger
+          AFTER INSERT OR UPDATE OR DELETE ON ${quotedSchema}.${quotedTable}
+          FOR EACH ROW EXECUTE FUNCTION public._zero_track_change();
+      `)
+      count++
+    }
+  }
+
+  if (count > 0) {
+    log.debug.pglite(`installed change tracking on ${count} shard tables`)
+  }
+}
+
 export async function getChangesSince(
   db: PGlite,
   watermark: number,

package/src/replication/handler.test.ts

@@ -7,6 +7,7 @@ import {
   handleStartReplication,
   type ReplicationWriter,
 } from './handler'
+import { Mutex } from '../mutex'
 
 // parse wire protocol RowDescription+DataRow response into columns/values
 function parseResponse(buf: Uint8Array): { columns: string[]; values: string[] } | null {
@@ -116,6 +117,7 @@ describe('handleReplicationQuery', () => {
 describe('handleStartReplication', () => {
   let db: PGlite
   let replicationPromise: Promise<void>
+  const testMutex = new Mutex()
 
   beforeEach(async () => {
     db = new PGlite()
@@ -160,7 +162,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 200))
@@ -175,7 +178,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 700))
@@ -190,7 +194,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))
@@ -220,7 +225,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))
@@ -246,7 +252,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))
@@ -271,7 +278,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))
@@ -291,7 +299,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))
@@ -313,7 +322,8 @@ describe('handleStartReplication', () => {
     replicationPromise = handleStartReplication(
       'START_REPLICATION SLOT "s" LOGICAL 0/0',
       writer,
-      db
+      db,
+      testMutex
     )
 
     await new Promise((r) => setTimeout(r, 100))

package/src/replication/handler.ts

@@ -7,9 +7,12 @@
  */
 
 import { log } from '../log.js'
+
+import type { Mutex } from '../mutex.js'
 import {
   getChangesSince,
   getCurrentWatermark,
+  installTriggersOnShardTables,
   type ChangeRecord,
 } from './change-tracker.js'
 import {
@@ -198,7 +201,9 @@ export async function handleReplicationQuery(
   }
 
   if (upper.startsWith('CREATE_REPLICATION_SLOT')) {
-    const match = trimmed.match(/CREATE_REPLICATION_SLOT\s+(?:"([^"]+)"|'([^']+)'|(\S+))/i)
+    const match = trimmed.match(
+      /CREATE_REPLICATION_SLOT\s+(?:"([^"]+)"|'([^']+)'|(\S+))/i
+    )
     const slotName = match?.[1] || match?.[2] || match?.[3] || 'zero_slot'
     const lsn = lsnToString(nextLsn())
     const snapshotName = `00000003-00000001-1`
@@ -238,6 +243,12 @@ export async function handleReplicationQuery(
     return buildCommandComplete('ALTER ROLE')
   }
 
+  // SET TRANSACTION - pglite rejects this if any query ran first (e.g. SET search_path).
+  // return synthetic response since pglite is single-connection and doesn't need isolation levels.
+  if (upper.startsWith('SET TRANSACTION') || upper.startsWith('SET SESSION')) {
+    return buildCommandComplete('SET')
+  }
+
   return null
 }
 
@@ -248,7 +259,8 @@ export async function handleReplicationQuery(
 export async function handleStartReplication(
   query: string,
   writer: ReplicationWriter,
-  db: PGlite
+  db: PGlite,
+  mutex: Mutex
 ): Promise<void> {
   log.debug.proxy('replication: entering streaming mode')
 
@@ -262,8 +274,23 @@ export async function handleStartReplication(
 
   let lastWatermark = 0
 
-  // set up LISTEN for real-time change notifications
-  await db.exec(`
+  // declared outside mutex block so they're accessible in the poll loop
+  const tableKeyColumns = new Map<string, Set<string>>()
+  const excludedColumns = new Map<string, Set<string>>()
+  const booleanColumns = new Map<string, Set<string>>()
+
+  // acquire mutex for all setup queries to avoid conflicting with proxy connections.
+  // the change-streamer's initial copy also queries PGlite via the proxy, and
+  // direct db.query()/db.exec() calls here bypass the proxy's mutex, causing
+  // "already in transaction" errors when they interleave.
+  await mutex.acquire()
+  try {
+    // 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)
+
+    // set up LISTEN for real-time change notifications
+    await db.exec(`
     CREATE OR REPLACE FUNCTION public._zero_notify_change() RETURNS TRIGGER AS $$
     BEGIN
       PERFORM pg_notify('_zero_changes', TG_TABLE_NAME);
@@ -272,77 +299,135 @@ export async function handleStartReplication(
     $$ LANGUAGE plpgsql;
   `)
 
-  // install notify trigger on tracked tables (use configured publication if available)
-  const pubName = process.env.ZERO_APP_PUBLICATIONS
-  let tables: { tablename: string }[]
-  if (pubName) {
-    const result = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_publication_tables
+    // install notify trigger on tracked tables (use configured publication if available)
+    const pubName = process.env.ZERO_APP_PUBLICATIONS
+    let tables: { tablename: string }[]
+    if (pubName) {
+      const result = await db.query<{ tablename: string }>(
+        `SELECT tablename FROM pg_publication_tables
        WHERE pubname = $1 AND schemaname = 'public' AND tablename NOT LIKE '_zero_%'`,
-      [pubName]
-    )
-    tables = result.rows
-  } else {
-    const result = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_tables
+        [pubName]
+      )
+      tables = result.rows
+    } else {
+      const result = await db.query<{ tablename: string }>(
+        `SELECT tablename FROM pg_tables
        WHERE schemaname = 'public'
          AND tablename NOT IN ('migrations', '_zero_changes')
          AND tablename NOT LIKE '_zero_%'`
-    )
-    tables = result.rows
-  }
+      )
+      tables = result.rows
+    }
 
-  for (const { tablename } of tables) {
-    const quoted = '"' + tablename.replace(/"/g, '""') + '"'
-    await db.exec(`
+    for (const { tablename } of tables) {
+      const quoted = '"' + tablename.replace(/"/g, '""') + '"'
+      await db.exec(`
       DROP TRIGGER IF EXISTS _zero_notify_trigger ON public.${quoted};
       CREATE TRIGGER _zero_notify_trigger
         AFTER INSERT OR UPDATE OR DELETE ON public.${quoted}
         FOR EACH STATEMENT EXECUTE FUNCTION public._zero_notify_change();
     `)
-  }
+    }
 
-  // build primary key lookup for all public tables
-  const tableKeyColumns = new Map<string, Set<string>>()
-  const pkResult = await db.query<{ table_name: string; column_name: string }>(
-    `SELECT tc.table_name, kcu.column_name
-     FROM information_schema.table_constraints tc
-     JOIN information_schema.key_column_usage kcu
-       ON tc.constraint_name = kcu.constraint_name
-       AND tc.table_schema = kcu.table_schema
-     WHERE tc.constraint_type = 'PRIMARY KEY'
-       AND tc.table_schema = 'public'`
-  )
-  for (const { table_name, column_name } of pkResult.rows) {
-    let keys = tableKeyColumns.get(table_name)
-    if (!keys) {
-      keys = new Set()
-      tableKeyColumns.set(table_name, keys)
+    // discover shard schemas (e.g. chat_0) and install NOTIFY triggers
+    const shardSchemas = await db.query<{ nspname: string }>(
+      `SELECT nspname FROM pg_namespace
+     WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast', 'public')
+       AND nspname NOT LIKE 'pg_%'
+       AND nspname NOT LIKE 'zero_%'
+       AND nspname NOT LIKE '_zero_%'
+       AND nspname NOT LIKE '%/%'`
+    )
+    const relevantSchemas = ['public', ...shardSchemas.rows.map((r) => r.nspname)]
+
+    for (const schema of relevantSchemas) {
+      if (schema === 'public') continue
+      const shardTables = await db.query<{ tablename: string }>(
+        `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+        [schema]
+      )
+      for (const { tablename } of shardTables.rows) {
+        const quotedSchema = '"' + schema.replace(/"/g, '""') + '"'
+        const quotedTable = '"' + tablename.replace(/"/g, '""') + '"'
+        await db.exec(`
+        DROP TRIGGER IF EXISTS _zero_notify_trigger ON ${quotedSchema}.${quotedTable};
+        CREATE TRIGGER _zero_notify_trigger
+          AFTER INSERT OR UPDATE OR DELETE ON ${quotedSchema}.${quotedTable}
+          FOR EACH STATEMENT EXECUTE FUNCTION public._zero_notify_change();
+      `)
+      }
+      if (shardTables.rows.length > 0) {
+        log.debug.proxy(
+          `installed notify triggers on ${shardTables.rows.length} tables in schema "${schema}"`
+        )
+      }
     }
-    keys.add(column_name)
-  }
-  log.debug.proxy(`loaded primary keys for ${tableKeyColumns.size} tables`)
 
-  // build excluded columns lookup (types zero-cache can't handle)
-  const excludedColumns = new Map<string, Set<string>>()
-  const UNSUPPORTED_TYPES = new Set(['tsvector', 'tsquery', 'USER-DEFINED'])
-  const colResult = await db.query<{ table_name: string; column_name: string; data_type: string }>(
-    `SELECT table_name, column_name, data_type
-     FROM information_schema.columns
-     WHERE table_schema = 'public'`
-  )
-  for (const { table_name, column_name, data_type } of colResult.rows) {
-    if (UNSUPPORTED_TYPES.has(data_type)) {
-      let cols = excludedColumns.get(table_name)
-      if (!cols) {
-        cols = new Set()
-        excludedColumns.set(table_name, cols)
+    // build primary key lookup for all relevant schemas
+    for (const schema of relevantSchemas) {
+      const pkResult = await db.query<{ table_name: string; column_name: string }>(
+        `SELECT tc.table_name, kcu.column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+         AND tc.table_schema = kcu.table_schema
+       WHERE tc.constraint_type = 'PRIMARY KEY'
+         AND tc.table_schema = $1`,
+        [schema]
+      )
+      for (const { table_name, column_name } of pkResult.rows) {
+        const key = `${schema}.${table_name}`
+        let keys = tableKeyColumns.get(key)
+        if (!keys) {
+          keys = new Set()
+          tableKeyColumns.set(key, keys)
+        }
+        keys.add(column_name)
       }
-      cols.add(column_name)
     }
-  }
-  if (excludedColumns.size > 0) {
-    log.debug.proxy(`excluding unsupported columns: ${[...excludedColumns.entries()].map(([t, c]) => `${t}(${[...c].join(',')})`).join(', ')}`)
+    log.debug.proxy(`loaded primary keys for ${tableKeyColumns.size} tables`)
+
+    // build excluded columns lookup (types zero-cache can't handle)
+    // also track boolean columns so we can send correct typeOid (16) in RELATION messages.
+    const UNSUPPORTED_TYPES = new Set(['tsvector', 'tsquery', 'USER-DEFINED'])
+    for (const schema of relevantSchemas) {
+      const colResult = await db.query<{
+        table_name: string
+        column_name: string
+        data_type: string
+      }>(
+        `SELECT table_name, column_name, data_type
+       FROM information_schema.columns
+       WHERE table_schema = $1`,
+        [schema]
+      )
+      for (const { table_name, column_name, data_type } of colResult.rows) {
+        const key = `${schema}.${table_name}`
+        if (UNSUPPORTED_TYPES.has(data_type)) {
+          let cols = excludedColumns.get(key)
+          if (!cols) {
+            cols = new Set()
+            excludedColumns.set(key, cols)
+          }
+          cols.add(column_name)
+        }
+        if (data_type === 'boolean') {
+          let cols = booleanColumns.get(key)
+          if (!cols) {
+            cols = new Set()
+            booleanColumns.set(key, cols)
+          }
+          cols.add(column_name)
+        }
+      }
+    }
+    if (excludedColumns.size > 0) {
+      log.debug.proxy(
+        `excluding unsupported columns: ${[...excludedColumns.entries()].map(([t, c]) => `${t}(${[...c].join(',')})`).join(', ')}`
+      )
+    }
+  } finally {
+    mutex.release()
   }
 
   // track which tables we've sent RELATION messages for
@@ -356,10 +441,25 @@ export async function handleStartReplication(
   const poll = async () => {
     while (running) {
       try {
-        const changes = await getChangesSince(db, lastWatermark, 100)
+        // acquire mutex to avoid conflicting with proxy connections
+        await mutex.acquire()
+        let changes: Awaited<ReturnType<typeof getChangesSince>>
+        try {
+          changes = await getChangesSince(db, lastWatermark, 100)
+        } finally {
+          mutex.release()
+        }
 
         if (changes.length > 0) {
-          await streamChanges(changes, writer, sentRelations, txCounter++, tableKeyColumns, excludedColumns)
+          await streamChanges(
+            changes,
+            writer,
+            sentRelations,
+            txCounter++,
+            tableKeyColumns,
+            excludedColumns,
+            booleanColumns
+          )
           lastWatermark = changes[changes.length - 1].watermark
         }
 
@@ -391,7 +491,8 @@ async function streamChanges(
   sentRelations: Set<string>,
   txId: number,
   tableKeyColumns: Map<string, Set<string>>,
-  excludedColumns: Map<string, Set<string>>
+  excludedColumns: Map<string, Set<string>>,
+  booleanColumns: Map<string, Set<string>>
 ): Promise<void> {
   const ts = nowMicros()
   const lsn = nextLsn()
@@ -401,8 +502,15 @@ async function streamChanges(
   writer.write(wrapCopyData(beginMsg))
 
   for (const change of changes) {
-    const tableOid = getTableOid(change.table_name)
-    const excluded = excludedColumns.get(change.table_name)
+    // parse schema-qualified name (schema.table or bare table)
+    const dot = change.table_name.indexOf('.')
+    const schema = dot !== -1 ? change.table_name.substring(0, dot) : 'public'
+    const tableName =
+      dot !== -1 ? change.table_name.substring(dot + 1) : change.table_name
+    const qualifiedKey = `${schema}.${tableName}`
+
+    const tableOid = getTableOid(qualifiedKey)
+    const excluded = excludedColumns.get(qualifiedKey)
 
     // filter out unsupported columns from row data
     let rowData = change.row_data
@@ -423,17 +531,19 @@ async function streamChanges(
     const row = rowData || oldData
     if (!row) continue
 
-    const keySet = tableKeyColumns.get(change.table_name)
+    const keySet = tableKeyColumns.get(qualifiedKey)
+    const boolSet = booleanColumns.get(qualifiedKey)
     const columns = inferColumns(row).map((col) => ({
       ...col,
+      typeOid: boolSet?.has(col.name) ? 16 : col.typeOid,
       isKey: keySet?.has(col.name) ?? false,
     }))
 
     // send RELATION if not yet sent
-    if (!sentRelations.has(change.table_name)) {
-      const relMsg = encodeRelation(tableOid, 'public', change.table_name, 0x64, columns)
+    if (!sentRelations.has(qualifiedKey)) {
+      const relMsg = encodeRelation(tableOid, schema, tableName, 0x64, columns)
       writer.write(wrapCopyData(wrapXLogData(lsn, lsn, ts, relMsg)))
-      sentRelations.add(change.table_name)
+      sentRelations.add(qualifiedKey)
     }
 
     // send the change

package/src/replication/pgoutput-encoder.ts

@@ -147,7 +147,15 @@ function encodeTupleData(
       values.push(null)
       totalSize += 1 // 'n' byte
     } else {
-      const strVal = typeof val === 'object' ? JSON.stringify(val) : String(val)
+      // convert to postgresql text format
+      let strVal: string
+      if (typeof val === 'boolean') {
+        strVal = val ? 't' : 'f'
+      } else if (typeof val === 'object') {
+        strVal = JSON.stringify(val)
+      } else {
+        strVal = String(val)
+      }
       const bytes = encodeString(strVal)
       values.push(bytes)
       totalSize += 1 + 4 + bytes.length // 't' + len + data