orez 0.2.26 → 0.2.29

package/src/pglite-web-proxy.ts

@@ -1,221 +0,0 @@
-/**
- * PGlite Web Worker proxy — browser equivalent of pglite-ipc.ts.
- *
- * runs in the zero-cache worker, proxies calls to a Web Worker
- * running the actual PGlite instance. mirrors PGliteWorkerProxy
- * from pglite-ipc.ts but uses Web Worker postMessage instead of
- * node worker_threads.
- *
- * ArrayBuffers are transferred (not copied) for execProtocolRaw
- * to keep IPC overhead near-zero for wire protocol data.
- */
-
-import { signalReplicationChange } from './replication/handler.js'
-
-interface PendingRequest {
-  resolve: (value: any) => void
-  reject: (error: Error) => void
-}
-
-const WRITE_PREFIXES = ['insert', 'update', 'delete', 'copy', 'truncate']
-const SHARD_INTERNAL_TABLES = ['"replicas"', '"mutations"', '"replicationState"']
-
-function isReplicatedWrite(sql: string): boolean {
-  const q = sql.trimStart().toLowerCase()
-  if (!WRITE_PREFIXES.some((p) => q.startsWith(p))) return false
-  for (const t of SHARD_INTERNAL_TABLES) {
-    if (q.includes(t.toLowerCase())) return false
-  }
-  return true
-}
-
-export class PGliteWebProxy {
-  private worker: Worker
-  private pending = new Map<number, PendingRequest>()
-  private nextId = 1
-  private notificationCallbacks = new Map<string, Set<(payload: string) => void>>()
-  private failure: Error | null = null
-  readonly name: string
-
-  readonly waitReady: Promise<void>
-
-  // PGlite compat flags
-  closed = false
-  ready = false
-
-  constructor(worker: Worker, name: string) {
-    this.name = name
-    this.worker = worker
-
-    let onReady: () => void
-    this.waitReady = new Promise<void>((resolveReady, rejectReady) => {
-      onReady = () => {
-        this.ready = true
-        resolveReady()
-      }
-
-      const onMessage = (ev: MessageEvent) => {
-        const msg = ev.data
-        if (msg?.type === 'ready') {
-          this.worker.removeEventListener('message', onMessage)
-          this.installMessageHandler()
-          onReady()
-        } else if (msg?.type === 'error' && msg.id === 0) {
-          rejectReady(new Error(msg.message))
-        }
-      }
-
-      this.worker.addEventListener('message', onMessage)
-      this.worker.addEventListener('error', (ev) => {
-        const error = this.errorFromEvent(ev, 'worker failed during startup')
-        this.failPending(error)
-        rejectReady(error)
-      })
-      this.worker.addEventListener('messageerror', (ev) => {
-        const error = this.errorFromEvent(ev, 'worker message error during startup')
-        this.failPending(error)
-        rejectReady(error)
-      })
-    })
-  }
-
-  private installMessageHandler() {
-    this.worker.addEventListener('error', (ev) => {
-      this.failPending(this.errorFromEvent(ev, 'worker failed'))
-    })
-    this.worker.addEventListener('messageerror', (ev) => {
-      this.failPending(this.errorFromEvent(ev, 'worker message error'))
-    })
-
-    this.worker.addEventListener('message', (ev: MessageEvent) => {
-      const msg = ev.data
-      if (!msg || typeof msg !== 'object') return
-
-      if (msg.type === 'notification') {
-        const callbacks = this.notificationCallbacks.get(msg.channel)
-        if (callbacks) {
-          for (const cb of callbacks) {
-            try {
-              cb(msg.payload)
-            } catch {}
-          }
-        }
-        return
-      }
-
-      const req = this.pending.get(msg.id)
-      if (!req) return
-      this.pending.delete(msg.id)
-
-      if (msg.type === 'error') {
-        const err = new Error(msg.message) as Error & { code?: string }
-        if (msg.code) err.code = msg.code
-        req.reject(err)
-      } else {
-        req.resolve(msg)
-      }
-    })
-  }
-
-  private errorFromEvent(ev: Event, fallback: string): Error {
-    const maybeError = ev as ErrorEvent
-    if (maybeError.error instanceof Error) return maybeError.error
-    if (maybeError.message) return new Error(maybeError.message)
-    return new Error(fallback)
-  }
-
-  private failPending(error: Error) {
-    if (!this.failure) this.failure = error
-    this.closed = true
-    this.ready = false
-    for (const [, req] of this.pending) {
-      req.reject(error)
-    }
-    this.pending.clear()
-  }
-
-  private send(msg: Record<string, unknown>, transfer?: Transferable[]): Promise<any> {
-    if (this.failure) return Promise.reject(this.failure)
-    if (this.closed) return Promise.reject(new Error('worker is closed'))
-
-    const id = this.nextId++
-    msg.id = id
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject })
-      try {
-        if (transfer?.length) {
-          this.worker.postMessage(msg, transfer)
-        } else {
-          this.worker.postMessage(msg)
-        }
-      } catch (err) {
-        this.pending.delete(id)
-        reject(err instanceof Error ? err : new Error(String(err)))
-      }
-    })
-  }
-
-  async execProtocolRaw(
-    data: Uint8Array,
-    options?: { syncToFs?: boolean; throwOnError?: boolean }
-  ): Promise<Uint8Array> {
-    // copy to a transferable buffer then transfer
-    const buf = new ArrayBuffer(data.byteLength)
-    new Uint8Array(buf).set(data)
-    const result = await this.send({ type: 'execProtocolRaw', data: buf, options }, [buf])
-    return new Uint8Array(result.data)
-  }
-
-  async query<T = any>(
-    sql: string,
-    params?: any[]
-  ): Promise<{ rows: T[]; affectedRows?: number }> {
-    const result = await this.send({ type: 'query', sql, params })
-    // signal replication after writes on postgres instance (like orez-node's PGliteWorkerProxy)
-    if (this.name === 'postgres' && isReplicatedWrite(sql)) {
-      signalReplicationChange()
-    }
-    return { rows: result.rows ?? [], affectedRows: result.affectedRows }
-  }
-
-  async exec(sql: string): Promise<{ affectedRows?: number }[]> {
-    const result = await this.send({ type: 'exec', sql })
-    if (this.name === 'postgres' && isReplicatedWrite(sql)) {
-      signalReplicationChange()
-    }
-    return result.results ?? []
-  }
-
-  async listen(
-    channel: string,
-    callback: (payload: string) => void
-  ): Promise<() => Promise<void>> {
-    let callbacks = this.notificationCallbacks.get(channel)
-    if (!callbacks) {
-      callbacks = new Set()
-      this.notificationCallbacks.set(channel, callbacks)
-    }
-    callbacks.add(callback)
-
-    const result = await this.send({ type: 'listen', channel })
-    const listenId = result.id
-
-    return async () => {
-      callbacks!.delete(callback)
-      if (callbacks!.size === 0) {
-        this.notificationCallbacks.delete(channel)
-      }
-      await this.send({ type: 'unlisten', listenId }).catch(() => {})
-    }
-  }
-
-  async close(): Promise<void> {
-    try {
-      await this.send({ type: 'close' })
-    } catch {}
-    this.closed = true
-    this.ready = false
-    this.failPending(new Error('worker is closed'))
-    this.worker.terminate()
-  }
-}

package/src/pglite-web-worker.ts

@@ -1,152 +0,0 @@
-/**
- * PGlite Web Worker — browser equivalent of pglite-worker-thread.ts.
- *
- * runs a single PGlite instance in a Web Worker. receives commands via
- * postMessage, executes on PGlite, sends results back. ArrayBuffers
- * are transferred (not copied) for execProtocolRaw.
- *
- * message protocol (same as pglite-worker-thread.ts):
- *   init: { type: 'init', dataDir, name, withExtensions, pgliteOptions }
- *   → { type: 'ready' }
- *
- *   execProtocolRaw: { type: 'execProtocolRaw', id, data: ArrayBuffer, options }
- *   → { type: 'result', id, data: ArrayBuffer }
- *
- *   query: { type: 'query', id, sql, params }
- *   → { type: 'result', id, rows, affectedRows }
- *
- *   exec: { type: 'exec', id, sql }
- *   → { type: 'result', id, results: [{ affectedRows }] }
- *
- *   listen/unlisten/close: same as pglite-worker-thread.ts
- */
-
-// NOTE: this file is meant to be bundled with PGlite as external
-// the consumer provides PGlite via importScripts or ESM import
-
-declare const self: any
-
-const listeners = new Map<number, () => Promise<void>>()
-let db: any // PGlite instance — type depends on how it's loaded
-
-self.onmessage = async (ev: MessageEvent) => {
-  const msg = ev.data
-  if (!msg || typeof msg !== 'object') return
-  const { type, id } = msg
-
-  try {
-    switch (type) {
-      case 'init': {
-        // dynamically import PGlite (external, provided by consumer's bundler)
-        const { PGlite } = await import('@electric-sql/pglite')
-        db = new PGlite({
-          dataDir: msg.dataDir || 'idb://orez-pglite',
-          relaxedDurability: true,
-          initialMemory: 32 * 1024 * 1024,
-          startParams: [
-            '--single',
-            '-F',
-            '-O',
-            '-j',
-            '-c',
-            'search_path=public',
-            '-c',
-            'exit_on_error=false',
-            '-c',
-            'log_checkpoints=false',
-            '-c',
-            'shared_buffers=4MB',
-            '-c',
-            'wal_buffers=1MB',
-          ],
-          ...(msg.pgliteOptions || {}),
-          // extensions loaded by consumer if needed
-        })
-        await db.waitReady
-
-        // tune postgres internals — modest values for embedded use
-        await db.exec(`
-          SET work_mem = '4MB';
-          SET maintenance_work_mem = '16MB';
-          SET effective_cache_size = '64MB';
-          SET random_page_cost = 1.1;
-          SET jit = off;
-        `)
-
-        self.postMessage({ type: 'ready' })
-        break
-      }
-
-      case 'execProtocolRaw': {
-        const input = new Uint8Array(msg.data as ArrayBuffer)
-        const result = await db.execProtocolRaw(input, msg.options)
-        const buf = new ArrayBuffer(result.byteLength)
-        new Uint8Array(buf).set(result)
-        self.postMessage({ type: 'result', id, data: buf }, [buf])
-        break
-      }
-
-      case 'query': {
-        const result = await db.query(msg.sql, msg.params)
-        self.postMessage({
-          type: 'result',
-          id,
-          rows: result.rows,
-          affectedRows: result.affectedRows,
-        })
-        break
-      }
-
-      case 'exec': {
-        const result = await db.exec(msg.sql)
-        const results = result.map((r: any) => ({ affectedRows: r.affectedRows ?? 0 }))
-        self.postMessage({ type: 'result', id, results })
-        break
-      }
-
-      case 'listen': {
-        const unsub = await db.listen(msg.channel, (payload: string) => {
-          self.postMessage({ type: 'notification', channel: msg.channel, payload })
-        })
-        listeners.set(id, unsub)
-        self.postMessage({ type: 'result', id })
-        break
-      }
-
-      case 'unlisten': {
-        const unsub = listeners.get(msg.listenId)
-        if (unsub) {
-          await unsub()
-          listeners.delete(msg.listenId)
-        }
-        self.postMessage({ type: 'result', id })
-        break
-      }
-
-      case 'close': {
-        for (const unsub of listeners.values()) {
-          await unsub().catch(() => {})
-        }
-        listeners.clear()
-        await db.close()
-        self.postMessage({ type: 'result', id })
-        break
-      }
-
-      default:
-        self.postMessage({
-          type: 'error',
-          id,
-          message: `unknown message type: ${type}`,
-        })
-    }
-  } catch (err: unknown) {
-    const error = err as { message?: string; code?: string }
-    self.postMessage({
-      type: 'error',
-      id,
-      message: error?.message || String(err),
-      code: error?.code,
-    })
-  }
-}

package/src/pglite-worker-thread.ts

@@ -1,253 +0,0 @@
-/**
- * worker thread that runs a single PGlite instance.
- *
- * receives commands via parentPort messages, executes them on the PGlite
- * instance, and sends results back. ArrayBuffers are transferred (not copied)
- * for execProtocolRaw to minimize overhead.
- */
-
-import { parentPort, workerData } from 'node:worker_threads'
-
-import { PGlite } from '@electric-sql/pglite'
-import { btree_gin } from '@electric-sql/pglite/contrib/btree_gin'
-import { btree_gist } from '@electric-sql/pglite/contrib/btree_gist'
-import { citext } from '@electric-sql/pglite/contrib/citext'
-import { cube } from '@electric-sql/pglite/contrib/cube'
-import { earthdistance } from '@electric-sql/pglite/contrib/earthdistance'
-import { fuzzystrmatch } from '@electric-sql/pglite/contrib/fuzzystrmatch'
-import { hstore } from '@electric-sql/pglite/contrib/hstore'
-import { ltree } from '@electric-sql/pglite/contrib/ltree'
-import { pg_trgm } from '@electric-sql/pglite/contrib/pg_trgm'
-import { pgcrypto } from '@electric-sql/pglite/contrib/pgcrypto'
-import { uuid_ossp } from '@electric-sql/pglite/contrib/uuid_ossp'
-import { vector } from '@electric-sql/pglite/vector'
-
-export interface WorkerInitConfig {
-  dataDir: string
-  name: string
-  withExtensions: boolean
-  debug: number
-  pgliteOptions?: Record<string, unknown>
-  /** tar dump from another instance's dumpDataDir() — used for read replicas */
-  loadDataDir?: ArrayBuffer
-}
-
-const port = parentPort!
-const config = workerData as WorkerInitConfig
-
-// active listen subscriptions
-const listeners = new Map<number, () => Promise<void>>()
-
-let db: PGlite
-
-const PGLITE_BASE_FLAGS = [
-  '--single',
-  '-F',
-  '-O',
-  '-j',
-  '-c',
-  'search_path=public',
-  '-c',
-  'exit_on_error=false',
-  '-c',
-  'log_checkpoints=false',
-]
-
-const ZERO_START_PARAMS = [
-  ...PGLITE_BASE_FLAGS,
-  '-c',
-  'shared_buffers=128kB',
-  '-c',
-  'wal_buffers=64kB',
-  '-c',
-  'work_mem=64kB',
-  '-c',
-  'maintenance_work_mem=1MB',
-  '-c',
-  'temp_buffers=800kB',
-]
-
-async function init() {
-  const { dataDir: _userDataDir, debug: _dbg, ...userOpts } = config.pgliteOptions || {}
-  const isMain = config.withExtensions
-
-  db = new PGlite({
-    dataDir: config.dataDir,
-    debug: config.debug,
-    relaxedDurability: true,
-    ...(config.loadDataDir ? { loadDataDir: new Blob([config.loadDataDir]) } : {}),
-    initialMemory: isMain ? 32 * 1024 * 1024 : 16 * 1024 * 1024,
-    ...(isMain ? {} : { startParams: ZERO_START_PARAMS }),
-    ...(isMain
-      ? {
-          startParams: [
-            ...PGLITE_BASE_FLAGS,
-            '-c',
-            'shared_buffers=4MB',
-            '-c',
-            'wal_buffers=1MB',
-          ],
-          ...userOpts,
-          extensions: userOpts.extensions || {
-            vector,
-            pg_trgm,
-            pgcrypto,
-            uuid_ossp,
-            citext,
-            hstore,
-            ltree,
-            fuzzystrmatch,
-            btree_gin,
-            btree_gist,
-            cube,
-            earthdistance,
-          },
-        }
-      : { extensions: {} }),
-  } as any)
-
-  await db.waitReady
-
-  if (isMain) {
-    await db.exec(`
-      SET work_mem = '4MB';
-      SET maintenance_work_mem = '16MB';
-      SET effective_cache_size = '64MB';
-      SET random_page_cost = 1.1;
-      SET jit = off;
-    `)
-  } else {
-    await db.exec(`SET jit = off;`)
-  }
-
-  port.postMessage({ type: 'ready' })
-}
-
-port.on('message', async (msg: { type: string; id: number; [key: string]: unknown }) => {
-  const { type, id } = msg
-
-  try {
-    switch (type) {
-      case 'execProtocolRaw': {
-        const input = new Uint8Array(msg.data as ArrayBuffer)
-        const result = await db.execProtocolRaw(input, msg.options as any)
-        // copy result to a transferable buffer (pglite may reuse wasm memory)
-        const buf = new ArrayBuffer(result.byteLength)
-        new Uint8Array(buf).set(result)
-        port.postMessage({ type: 'result', id, data: buf }, [buf])
-        break
-      }
-
-      case 'execProtocolRawBatch': {
-        // execute multiple wire protocol messages serially, return concatenated result.
-        // eliminates N-1 IPC round-trips for extended protocol pipelines.
-        const buffers = msg.buffers as ArrayBuffer[]
-        const opts = msg.options as any
-        const resultParts: Uint8Array[] = []
-        let totalLen = 0
-        for (const ab of buffers) {
-          const input = new Uint8Array(ab)
-          const result = await db.execProtocolRaw(input, opts)
-          // copy each result (pglite reuses wasm memory between calls)
-          const copy = new Uint8Array(result.byteLength)
-          copy.set(result)
-          resultParts.push(copy)
-          totalLen += copy.byteLength
-        }
-        // concatenate all results into one transferable buffer
-        const combined = new ArrayBuffer(totalLen)
-        const view = new Uint8Array(combined)
-        let offset = 0
-        for (const part of resultParts) {
-          view.set(part, offset)
-          offset += part.byteLength
-        }
-        port.postMessage({ type: 'result', id, data: combined }, [combined])
-        break
-      }
-
-      case 'query': {
-        const result = await db.query(msg.sql as string, msg.params as any[])
-        port.postMessage({
-          type: 'result',
-          id,
-          rows: result.rows,
-          affectedRows: result.affectedRows,
-        })
-        break
-      }
-
-      case 'exec': {
-        const result = await db.exec(msg.sql as string)
-        // serialize exec results (array of { affectedRows })
-        const results = result.map((r) => ({ affectedRows: r.affectedRows ?? 0 }))
-        port.postMessage({ type: 'result', id, results })
-        break
-      }
-
-      case 'listen': {
-        const channel = msg.channel as string
-        const unsub = await db.listen(channel, (payload) => {
-          port.postMessage({ type: 'notification', channel, payload })
-        })
-        listeners.set(id, unsub)
-        port.postMessage({ type: 'result', id })
-        break
-      }
-
-      case 'unlisten': {
-        const listenId = msg.listenId as number
-        const unsub = listeners.get(listenId)
-        if (unsub) {
-          await unsub()
-          listeners.delete(listenId)
-        }
-        port.postMessage({ type: 'result', id })
-        break
-      }
-
-      case 'dumpDataDir': {
-        const dump = await db.dumpDataDir('none')
-        // convert Blob/File to ArrayBuffer for transfer
-        const arrayBuf = await (dump as Blob).arrayBuffer()
-        port.postMessage({ type: 'result', id, data: arrayBuf }, [arrayBuf])
-        break
-      }
-
-      case 'close': {
-        for (const unsub of listeners.values()) {
-          await unsub().catch(() => {})
-        }
-        listeners.clear()
-        await db.close()
-        port.postMessage({ type: 'result', id })
-        break
-      }
-
-      default:
-        port.postMessage({
-          type: 'error',
-          id,
-          message: `unknown message type: ${type}`,
-        })
-    }
-  } catch (err: unknown) {
-    const error = err as { message?: string; code?: string }
-    port.postMessage({
-      type: 'error',
-      id,
-      message: error?.message || String(err),
-      code: error?.code,
-    })
-  }
-})
-
-init().catch((err: unknown) => {
-  const error = err as { message?: string }
-  port.postMessage({
-    type: 'error',
-    id: 0,
-    message: `worker init failed: ${error?.message || String(err)}`,
-  })
-  process.exit(1)
-})

package/src/port.ts

@@ -1,25 +0,0 @@
-import { createServer } from 'node:net'
-
-export function findPort(preferred: number, maxAttempts = 20): Promise<number> {
-  return new Promise((resolve, reject) => {
-    let attempt = 0
-
-    function tryPort(port: number) {
-      const server = createServer()
-      server.unref()
-      server.on('error', (err: NodeJS.ErrnoException) => {
-        if (err.code === 'EADDRINUSE' && attempt < maxAttempts) {
-          attempt++
-          tryPort(port + 1)
-        } else {
-          reject(err)
-        }
-      })
-      server.listen(port, '127.0.0.1', () => {
-        server.close(() => resolve(port))
-      })
-    }
-
-    tryPort(preferred)
-  })
-}

package/src/process-title.ts

@@ -1,9 +0,0 @@
-export function orezTitle(label = 'orez'): string {
-  const cwd = process.cwd()
-  const home = process.env.HOME || ''
-  const dir =
-    home && cwd.startsWith(home + '/')
-      ? '~' + cwd.slice(home.length)
-      : cwd.split('/').pop()!
-  return `${label} (${dir})`
-}