orez 0.2.27 → 0.2.29

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()
-  }
-}