orez 0.2.26 → 0.2.29

package/src/pglite-ipc.test.ts

@@ -1,116 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-
-import { PGliteWorkerProxy } from './pglite-ipc.js'
-
-describe('PGliteWorkerProxy', () => {
-  let proxy: PGliteWorkerProxy
-
-  beforeAll(async () => {
-    proxy = new PGliteWorkerProxy({
-      dataDir: 'memory://',
-      name: 'test',
-      withExtensions: false,
-      debug: 0,
-      pgliteOptions: {},
-    })
-    await proxy.waitReady
-  }, 30_000)
-
-  afterAll(async () => {
-    await proxy.close()
-  })
-
-  test('exec creates table', async () => {
-    await proxy.exec(`
-      CREATE TABLE test_items (
-        id SERIAL PRIMARY KEY,
-        name TEXT NOT NULL
-      )
-    `)
-  })
-
-  test('query returns rows', async () => {
-    await proxy.exec(`INSERT INTO test_items (name) VALUES ('hello')`)
-    await proxy.exec(`INSERT INTO test_items (name) VALUES ('world')`)
-
-    const result = await proxy.query<{ id: number; name: string }>(
-      'SELECT * FROM test_items ORDER BY id'
-    )
-    expect(result.rows).toHaveLength(2)
-    expect(result.rows[0].name).toBe('hello')
-    expect(result.rows[1].name).toBe('world')
-  })
-
-  test('query with params', async () => {
-    const result = await proxy.query<{ name: string }>(
-      'SELECT name FROM test_items WHERE name = $1',
-      ['world']
-    )
-    expect(result.rows).toHaveLength(1)
-    expect(result.rows[0].name).toBe('world')
-  })
-
-  test('exec returns affectedRows', async () => {
-    const result = await proxy.exec(`DELETE FROM test_items WHERE name = 'hello'`)
-    expect(result[0].affectedRows).toBe(1)
-  })
-
-  test('execProtocolRaw handles wire protocol', async () => {
-    // simple query message: SELECT 1 as num
-    const query = 'SELECT 1 as num\0'
-    const encoder = new TextEncoder()
-    const queryBytes = encoder.encode(query)
-    const buf = new Uint8Array(5 + queryBytes.length)
-    buf[0] = 0x51 // 'Q' simple query
-    new DataView(buf.buffer).setInt32(1, 4 + queryBytes.length)
-    buf.set(queryBytes, 5)
-
-    const result = await proxy.execProtocolRaw(buf)
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(result.length).toBeGreaterThan(0)
-    // should contain a ReadyForQuery message (0x5a)
-    let hasRfq = false
-    for (let i = 0; i < result.length; i++) {
-      if (result[i] === 0x5a) {
-        hasRfq = true
-        break
-      }
-    }
-    expect(hasRfq).toBe(true)
-  })
-
-  test('listen receives notifications', async () => {
-    const received: string[] = []
-    const unsub = await proxy.listen('test_channel', (payload) => {
-      received.push(payload)
-    })
-
-    await proxy.exec(`NOTIFY test_channel, 'hello'`)
-    // give notification time to propagate
-    await new Promise((r) => setTimeout(r, 100))
-
-    expect(received).toContain('hello')
-    await unsub()
-  })
-
-  test('error propagation with SQL code', async () => {
-    await expect(proxy.exec('SELECT * FROM nonexistent_table')).rejects.toThrow()
-  })
-
-  test('rejects requests after worker exits', async () => {
-    const local = new PGliteWorkerProxy({
-      dataDir: 'memory://',
-      name: 'exit-test',
-      withExtensions: false,
-      debug: 0,
-      pgliteOptions: {},
-    })
-    await local.waitReady
-
-    await (local as any).worker.terminate()
-
-    await expect(local.query('SELECT 1')).rejects.toThrow(
-      /worker exited|worker is closed/
-    )
-  })
-})

package/src/pglite-ipc.ts

@@ -1,266 +0,0 @@
-/**
- * PGlite worker proxy — runs in the main thread, proxies calls to a
- * worker thread running the actual PGlite instance.
- *
- * implements the PGlite interface surface used throughout orez:
- * execProtocolRaw, query, exec, listen, close.
- *
- * ArrayBuffers are transferred (not copied) for execProtocolRaw to
- * keep IPC overhead near-zero for wire protocol data.
- */
-
-import { existsSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { Worker } from 'node:worker_threads'
-
-import { log } from './log.js'
-import { signalReplicationChange } from './replication/handler.js'
-
-import type { WorkerInitConfig } from './pglite-worker-thread.js'
-
-interface PendingRequest {
-  resolve: (value: any) => void
-  reject: (error: Error) => void
-}
-
-const WRITE_PREFIXES = ['insert', 'update', 'delete', 'copy', 'truncate']
-// shard-internal tables that the replication handler filters out.
-// signaling for these just causes spurious wakeups + mutex contention.
-// pre-lowercased so we don't call toLowerCase() per iteration
-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
-  // skip shard-internal writes (zero-cache manages these, not replicated)
-  for (const t of SHARD_INTERNAL_TABLES) {
-    if (q.includes(t)) return false
-  }
-  return true
-}
-
-// resolve worker file path — .ts in dev/test (vitest), .js when compiled
-function resolveWorkerPath(): string {
-  const dir = import.meta.dirname
-  const tsPath = resolve(dir, 'pglite-worker-thread.ts')
-  if (existsSync(tsPath)) return tsPath
-  return resolve(dir, 'pglite-worker-thread.js')
-}
-
-export class PGliteWorkerProxy {
-  private worker: Worker
-  private pending = new Map<number, PendingRequest>()
-  private nextId = 1
-  private notificationCallbacks = new Map<string, Set<(payload: string) => void>>()
-  private closed = false
-  private failure: Error | null = null
-  readonly name: string
-
-  /** resolves when the worker's PGlite instance is ready */
-  readonly waitReady: Promise<void>
-
-  constructor(config: WorkerInitConfig) {
-    this.name = config.name
-    const workerPath = resolveWorkerPath()
-
-    this.worker = new Worker(workerPath, {
-      workerData: config,
-      name: `pglite-${config.name}`,
-    })
-
-    // set up waitReady promise, then install message handler once ready
-    let onReady: () => void
-    this.waitReady = new Promise<void>((resolveReady, rejectReady) => {
-      onReady = () => {
-        log.debug.pglite(`worker ${config.name} ready`)
-        resolveReady()
-      }
-
-      const onMessage = (msg: { type: string; id?: number; message?: string }) => {
-        if (msg.type === 'ready') {
-          this.worker.off('message', onMessage)
-          this.installMessageHandler()
-          onReady()
-        } else if (msg.type === 'error' && msg.id === 0) {
-          rejectReady(new Error(msg.message))
-        }
-      }
-
-      this.worker.on('message', onMessage)
-      this.worker.once('error', rejectReady)
-    })
-
-    // handle unexpected worker crashes
-    this.worker.on('error', (err) => {
-      const failure = new Error(`worker crashed: ${err.message}`)
-      log.pglite(`worker ${config.name} error: ${err.message}`)
-      this.failPending(failure)
-    })
-
-    this.worker.on('exit', (code) => {
-      if (this.closed) return
-      if (code !== 0) {
-        const failure = new Error(`worker exited with code ${code}`)
-        log.pglite(`worker ${config.name} exited with code ${code}`)
-        this.failPending(failure)
-        return
-      }
-      this.failPending(new Error('worker exited unexpectedly'))
-    })
-  }
-
-  private failPending(error: Error) {
-    if (!this.failure) this.failure = error
-    for (const [, req] of this.pending) {
-      req.reject(error)
-    }
-    this.pending.clear()
-  }
-
-  private installMessageHandler() {
-    this.worker.on(
-      'message',
-      (msg: { type: string; id?: number; [key: string]: any }) => {
-        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 send(msg: Record<string, unknown>, transfer?: ArrayBuffer[]): 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 (avoids copying in the worker)
-    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)
-  }
-
-  /**
-   * execute multiple wire protocol messages in a single IPC round-trip.
-   * each message is executed sequentially in the worker, and all results
-   * are concatenated and returned. eliminates N-1 postMessage round-trips
-   * for extended protocol pipelines (Parse→Bind→Execute→Sync).
-   */
-  async execProtocolRawBatch(
-    messages: Uint8Array[],
-    options?: { syncToFs?: boolean; throwOnError?: boolean }
-  ): Promise<Uint8Array> {
-    const buffers: ArrayBuffer[] = []
-    for (const msg of messages) {
-      const buf = new ArrayBuffer(msg.byteLength)
-      new Uint8Array(buf).set(msg)
-      buffers.push(buf)
-    }
-    const result = await this.send(
-      { type: 'execProtocolRawBatch', buffers, options },
-      buffers
-    )
-    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 })
-    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(() => {})
-    }
-  }
-
-  /**
-   * dump the PGlite data directory as a tar blob.
-   * used to create read replicas from an existing instance.
-   */
-  async dumpDataDir(): Promise<ArrayBuffer> {
-    const result = await this.send({ type: 'dumpDataDir' })
-    return result.data as ArrayBuffer
-  }
-
-  async close(): Promise<void> {
-    try {
-      await this.send({ type: 'close' })
-    } catch {
-      // worker may already be gone
-    }
-    this.closed = true
-    this.failPending(new Error('worker is closed'))
-    await this.worker.terminate()
-  }
-}