orez 0.1.43 → 0.1.44

package/src/worker/shims/postgres-socket.ts

@@ -0,0 +1,310 @@
+/**
+ * MessagePort-backed socket for the postgres npm package.
+ *
+ * the postgres package (porsager/postgres) accepts a custom socket factory
+ * via options.socket. this provides a net.Socket-compatible object backed
+ * by a MessagePort that connects to pg-proxy-browser.
+ *
+ * usage:
+ *   import postgres from 'postgres'
+ *   import { createSocketFactory } from 'orez/worker/shims/postgres-socket'
+ *
+ *   const sql = postgres({
+ *     socket: createSocketFactory(proxyPort),
+ *     // ... other options
+ *   })
+ *
+ * this replaces the postgres.ts shim entirely — the real postgres package
+ * speaks wire protocol to pg-proxy-browser, just like orez-node speaks
+ * wire protocol to pg-proxy over TCP.
+ */
+
+import { Buffer } from 'buffer'
+import { EventEmitter } from 'events'
+
+/**
+ * create a socket factory for the postgres npm package.
+ * each call to the factory creates a new MessageChannel,
+ * gives one port to the proxy via connectFn, and returns
+ * a Socket-like object backed by the other port.
+ */
+export function createSocketFactory(connectFn: (port: MessagePort) => void) {
+  return () => new MessagePortSocket(connectFn)
+}
+
+/**
+ * net.Socket-compatible object backed by MessagePort.
+ * implements the full interface that the postgres package uses,
+ * plus reasonable net.Socket spec compliance for other consumers.
+ */
+class MessagePortSocket extends EventEmitter {
+  private port: MessagePort | null = null
+  private channel: MessageChannel | null = null
+  private _destroyed = false
+  private _ended = false
+  private _readyState: 'opening' | 'open' | 'closed' = 'opening'
+
+  // pause/resume buffering for COPY protocol backpressure
+  private _paused = false
+  private _pauseBuffer: Buffer[] = []
+
+  // timeout tracking
+  private _timeoutMs = 0
+  private _timeoutTimer: ReturnType<typeof setTimeout> | null = null
+
+  // net.Socket compat properties
+  writable = true
+  readable = true
+  bytesRead = 0
+  bytesWritten = 0
+
+  // postgres may write these on native sockets (skipped for custom, but allow assignment)
+  ssl?: boolean
+  host?: string
+  // port is already used by MessagePort field, use _pgPort for postgres assignment
+  // actually postgres only writes these for non-custom sockets, so we just need
+  // the property to be settable without error
+
+  constructor(private connectFn: (port: MessagePort) => void) {
+    super()
+    this.channel = new MessageChannel()
+    this.port = this.channel.port1
+
+    // give server port to pg-proxy-browser
+    this.connectFn(this.channel.port2)
+
+    // forward incoming data from proxy — wrap as Buffer (postgres needs readUInt32BE etc.)
+    this.port.onmessage = (ev: MessageEvent) => {
+      if (this._destroyed) return
+
+      let buf: Buffer | null = null
+      if (ev.data instanceof ArrayBuffer) {
+        buf = Buffer.from(new Uint8Array(ev.data))
+      } else if (ev.data instanceof Uint8Array) {
+        buf = Buffer.from(ev.data)
+      }
+
+      if (!buf) return
+
+      this.bytesRead += buf.length
+      this._resetTimeout()
+
+      if (this._paused) {
+        this._pauseBuffer.push(buf)
+        return
+      }
+
+      this.emit('data', buf)
+    }
+
+    this.port.start()
+
+    // transition to open and fire connect event async
+    // for custom sockets postgres calls connected() directly (skips socket.on('connect')),
+    // but we emit for generic socket compat
+    queueMicrotask(() => {
+      if (!this._destroyed) {
+        this._readyState = 'open'
+        this.emit('connect')
+        this.emit('ready')
+      }
+    })
+  }
+
+  get destroyed() {
+    return this._destroyed
+  }
+
+  get readyState(): string {
+    return this._readyState
+  }
+
+  get connecting() {
+    return this._readyState === 'opening'
+  }
+
+  get pending() {
+    return this._readyState === 'opening'
+  }
+
+  // postgres calls socket.write(chunk, fn) — returns boolean for backpressure
+  write(
+    data: Uint8Array | Buffer | string,
+    encoding?: any,
+    callback?: Function
+  ): boolean {
+    if (this._destroyed || !this.port) {
+      if (typeof encoding === 'function') encoding()
+      else if (typeof callback === 'function') callback()
+      return false
+    }
+
+    const bytes: Uint8Array =
+      typeof data === 'string'
+        ? Buffer.from(data)
+        : data instanceof Uint8Array
+          ? data
+          : Buffer.from(data)
+
+    // copy before transfer — postgres may reference the buffer after write
+    const copy = new Uint8Array(bytes.length)
+    copy.set(bytes)
+
+    try {
+      this.port.postMessage(copy.buffer, [copy.buffer])
+    } catch (err) {
+      queueMicrotask(() => this.emit('error', err))
+      if (typeof encoding === 'function') encoding()
+      else if (typeof callback === 'function') callback()
+      return false
+    }
+
+    this.bytesWritten += bytes.length
+    this._resetTimeout()
+
+    if (typeof encoding === 'function') encoding()
+    else if (typeof callback === 'function') callback()
+
+    return true
+  }
+
+  // postgres calls socket.end(terminateMsg) in terminate() then
+  // registers socket.once('close', resolve). defer destroy so the
+  // 'close' listener is registered before the event fires.
+  end(data?: any, encoding?: any, callback?: Function) {
+    if (typeof data === 'function') {
+      callback = data
+      data = undefined
+      encoding = undefined
+    } else if (typeof encoding === 'function') {
+      callback = encoding
+      encoding = undefined
+    }
+
+    if (data != null) this.write(data, encoding)
+    this._ended = true
+
+    // defer destroy to next microtask — terminate() calls socket.end(X_msg)
+    // then line 408 of connection.js does socket.once('close', resolve).
+    // synchronous destroy would fire 'close' before that listener exists.
+    queueMicrotask(() => this.destroy())
+
+    if (typeof callback === 'function') callback()
+  }
+
+  destroy(err?: Error) {
+    if (this._destroyed) return this
+    this._destroyed = true
+    this._readyState = 'closed'
+    this.writable = false
+    this.readable = false
+
+    // clear timeout
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer)
+      this._timeoutTimer = null
+    }
+
+    // clear pause buffer
+    this._pauseBuffer.length = 0
+
+    if (this.port) {
+      // delay port.close() to allow pending messages (like Terminate/X)
+      // to be delivered. closing immediately after postMessage loses
+      // the message, preventing the proxy from releasing its mutex.
+      const p = this.port
+      this.port = null
+      setTimeout(() => p.close(), 50)
+    }
+
+    if (err) {
+      this.emit('error', err)
+    }
+    this.emit('end')
+    this.emit('close', !!err)
+    return this
+  }
+
+  // flow control — MessagePort doesn't natively support pause/resume,
+  // so we buffer incoming messages when paused and flush on resume.
+  // the postgres COPY protocol relies on this (CopyData calls socket.pause()
+  // when stream.push() returns false).
+  pause() {
+    this._paused = true
+    return this
+  }
+
+  resume() {
+    this._paused = false
+    // flush buffered messages — exit if data handler re-pauses
+    while (this._pauseBuffer.length && !this._paused) {
+      this.emit('data', this._pauseBuffer.shift()!)
+    }
+    return this
+  }
+
+  // timeout — emit 'timeout' after ms of inactivity (no reads or writes).
+  // postgres calls socket.setKeepAlive conditionally but doesn't use
+  // setTimeout on custom sockets. still useful for detecting hung connections.
+  setTimeout(ms: number, cb?: Function) {
+    this._timeoutMs = ms
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer)
+      this._timeoutTimer = null
+    }
+    if (cb) this.once('timeout', cb as (...args: any[]) => void)
+    if (ms > 0) this._resetTimeout()
+    return this
+  }
+
+  private _resetTimeout() {
+    if (this._timeoutTimer) clearTimeout(this._timeoutTimer)
+    if (this._timeoutMs > 0 && !this._destroyed) {
+      this._timeoutTimer = globalThis.setTimeout(
+        () => this.emit('timeout'),
+        this._timeoutMs
+      )
+    }
+  }
+
+  // no-ops — these configure TCP-level behavior that doesn't apply to MessagePort
+  setKeepAlive() {
+    return this
+  }
+  setNoDelay() {
+    return this
+  }
+  ref() {
+    return this
+  }
+  unref() {
+    return this
+  }
+  cork() {}
+  uncork() {}
+
+  // postgres skips connect() for custom sockets, but defensive for generic use
+  connect() {
+    return this
+  }
+
+  // net.Socket address info stubs
+  address() {
+    return { address: '127.0.0.1', family: 'IPv4', port: 0 }
+  }
+  get remoteAddress() {
+    return '127.0.0.1'
+  }
+  get remotePort() {
+    return 0
+  }
+  get remoteFamily() {
+    return 'IPv4'
+  }
+  get localAddress() {
+    return '127.0.0.1'
+  }
+  get localPort() {
+    return 0
+  }
+}

package/src/worker/shims/postgres.ts

@@ -701,15 +701,22 @@ async function executeQuery(
     if (intercepted) return intercepted
   }
 
-  // strip FK constraints from CREATE TABLE in browser mode.
-  // without a wrapping transaction, DEFERRABLE can't defer across separate
-  // INSERT statements — zero-cache inserts desires before queries exist.
-  // single-connection browser dev preview doesn't need FK enforcement.
-  if (/FOREIGN\s+KEY/i.test(text) && /CREATE\s+TABLE/i.test(text)) {
-    text = text.replace(
-      /,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi,
-      ''
-    )
+  // strip FK constraints — PGlite doesn't support cross-schema FKs,
+  // and browser single-process mode doesn't need FK enforcement.
+  // covers CREATE TABLE inline FKs and ALTER TABLE ADD CONSTRAINT FKs.
+  if (/FOREIGN\s+KEY/i.test(text)) {
+    if (/CREATE\s+TABLE/i.test(text)) {
+      text = text.replace(
+        /,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi,
+        ''
+      )
+    }
+    if (/ALTER\s+TABLE/i.test(text) && /ADD\s+CONSTRAINT/i.test(text)) {
+      text = text.replace(
+        /ALTER\s+TABLE\s+[^\s]+\s+ADD\s+CONSTRAINT\s+[^\s]+\s*\n?\s*FOREIGN\s+KEY\s*\([^)]*\)\s*\n?\s*REFERENCES\s+[^;]+/gi,
+        'SELECT 1'
+      )
+    }
   }
 
   const isMulti = hasMultipleStatements(text)
@@ -1147,12 +1154,20 @@ export function createPostgresShim(pglite: PGlite, opts?: PostgresShimOptions) {
       return createCopyPendingQuery(queryString, pglite)
     }
 
-    // strip FK constraints from CREATE TABLE (see executeQuery for why)
-    if (/FOREIGN\s+KEY/i.test(queryString) && /CREATE\s+TABLE/i.test(queryString)) {
-      queryString = queryString.replace(
-        /,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi,
-        ''
-      )
+    // strip FK constraints (see executeQuery for why)
+    if (/FOREIGN\s+KEY/i.test(queryString)) {
+      if (/CREATE\s+TABLE/i.test(queryString)) {
+        queryString = queryString.replace(
+          /,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi,
+          ''
+        )
+      }
+      if (/ALTER\s+TABLE/i.test(queryString) && /ADD\s+CONSTRAINT/i.test(queryString)) {
+        queryString = queryString.replace(
+          /ALTER\s+TABLE\s+[^\s]+\s+ADD\s+CONSTRAINT\s+[^\s]+\s*\n?\s*FOREIGN\s+KEY\s*\([^)]*\)\s*\n?\s*REFERENCES\s+[^;]+/gi,
+          'SELECT 1'
+        )
+      }
     }
 
     const serializedParams = (params ?? []).map(serializeParam)

package/src/worker/shims/stream-browser.ts

@@ -0,0 +1,15 @@
+/**
+ * stream shim — re-exports readable-stream with missing Node.js stream functions.
+ *
+ * readable-stream/stream-browserify don't include getDefaultHighWaterMark
+ * which zero-cache uses (added in Node.js 18+).
+ */
+
+// @ts-expect-error — readable-stream is CJS
+export * from 'readable-stream'
+// @ts-expect-error — readable-stream is CJS
+export { default } from 'readable-stream'
+
+export function getDefaultHighWaterMark(objectMode: boolean): number {
+  return objectMode ? 16 : 16 * 1024
+}

package/src/worker/shims/ws-browser.ts

@@ -47,37 +47,56 @@ interface WsCompatible {
  * listener — which would silently drop messages.
  */
 export function messagePortToWs(port: MessagePort): WsCompatible {
-  const listeners = new Map<string, Set<(event: any) => void>>()
+  // separate listener sets for on() vs addEventListener() to match real ws behavior.
+  // in the ws package, on() is EventEmitter-style and addEventListener() is DOM-style.
+  // createWebSocketStream uses ws.on('message') exclusively for inbound data.
+  // streamOut uses ws.addEventListener('message') for ack handling.
+  // if they share the same set, ack messages reach both handlers and
+  // handleMessage tries to parse acks as protocol messages, closing the connection.
+  const onListeners = new Map<string, Set<(event: any) => void>>()
+  const domListeners = new Map<string, Set<(event: any) => void>>()
   let closed = false
 
-  // buffer messages until a 'message' listener is registered
+  // buffer messages until a 'message' listener is registered (either kind)
   const pendingMessages: any[] = []
 
-  function addListener(type: string, handler: (event: any) => void) {
-    if (!listeners.has(type)) listeners.set(type, new Set())
-    listeners.get(type)!.add(handler)
+  function addOnListener(type: string, handler: (event: any) => void) {
+    if (!onListeners.has(type)) onListeners.set(type, new Set())
+    onListeners.get(type)!.add(handler)
+    if (type === 'message' && pendingMessages.length > 0) {
+      const queued = pendingMessages.splice(0)
+      for (const event of queued) handler(event)
+    }
+  }
+
+  function removeOnListener(type: string, handler: (event: any) => void) {
+    onListeners.get(type)?.delete(handler)
+  }
 
-    // flush buffered messages when first 'message' listener is added
+  function addDomListener(type: string, handler: (event: any) => void) {
+    if (!domListeners.has(type)) domListeners.set(type, new Set())
+    domListeners.get(type)!.add(handler)
     if (type === 'message' && pendingMessages.length > 0) {
       const queued = pendingMessages.splice(0)
       for (const event of queued) handler(event)
     }
   }
 
-  function removeListener(type: string, handler: (event: any) => void) {
-    listeners.get(type)?.delete(handler)
+  function removeDomListener(type: string, handler: (event: any) => void) {
+    domListeners.get(type)?.delete(handler)
   }
 
   function emit(type: string, event: any) {
-    const handlers = listeners.get(type)
-    if (!handlers || handlers.size === 0) {
-      // no listeners yet — buffer message events
-      if (type === 'message') {
-        pendingMessages.push(event)
-      }
+    const onHandlers = onListeners.get(type)
+    const domHandlers = domListeners.get(type)
+    const hasAny =
+      (onHandlers && onHandlers.size > 0) || (domHandlers && domHandlers.size > 0)
+    if (!hasAny) {
+      if (type === 'message') pendingMessages.push(event)
       return
     }
-    for (const h of handlers) h(event)
+    if (onHandlers) for (const h of onHandlers) h(event)
+    if (domHandlers) for (const h of domHandlers) h(event)
   }
 
   // forward port messages → ws 'message' events
@@ -102,7 +121,6 @@ export function messagePortToWs(port: MessagePort): WsCompatible {
 
     send(data: string | ArrayBuffer | ArrayBufferView) {
       if (closed) return
-      // MessagePort uses postMessage (structured clone)
       port.postMessage(data)
     },
 
@@ -113,10 +131,10 @@ export function messagePortToWs(port: MessagePort): WsCompatible {
       emit('close', { code: code ?? 1000, reason: '', wasClean: true })
     },
 
-    addEventListener: addListener,
-    removeEventListener: removeListener,
-    on: addListener,
-    off: removeListener,
+    addEventListener: addDomListener,
+    removeEventListener: removeDomListener,
+    on: addOnListener,
+    off: removeOnListener,
   }
 }
 

package/src/worker/shims/ws.ts

@@ -63,8 +63,10 @@ class WebSocket extends EventEmitter {
 
       if (isInProcess) {
         // in-process: connect via fastify server's handoff mechanism
-        const fastifyInstance = (globalThis as any).__orez_fastify_instance
-        if (fastifyInstance?.server) {
+        // try all registered fastify instances via tryHandoff, stop at first match
+        const instances: any[] = (globalThis as any).__orez_fastify_instances || []
+        const fallbackInstance = (globalThis as any).__orez_fastify_instance
+        if (instances.length > 0 || fallbackInstance?.server) {
           // create paired message channels for bidirectional communication
           // the client-side WS (this) and serverWs are cross-linked so
           // ping/pong, messages, and close propagate between them
@@ -74,7 +76,8 @@ class WebSocket extends EventEmitter {
             _listeners: {} as Record<string, Function[]>,
             send: (data: string | ArrayBuffer) => {
               // deliver to client side
-              queueMicrotask(() => clientSide.emit('message', data))
+              // wrap in event object — zero-cache handleMessage reads event.data
+              queueMicrotask(() => clientSide.emit('message', { data }))
             },
             close: (code?: number, reason?: string) => {
               serverWs.readyState = 3
@@ -98,10 +101,13 @@ class WebSocket extends EventEmitter {
             },
           }
 
+          // client-side internal ws — forwards send() to server,
+          // receives messages from server via addEventListener.
+          // addEventListener MUST work because WebSocket#setupListeners registers here.
+          const clientWsListeners: Record<string, Function[]> = {}
           this.#ws = {
             accept: () => {},
             send: (data: string | ArrayBuffer) => {
-              // deliver to server side
               const handlers = serverWs._listeners['message'] || []
               for (const h of handlers) h({ data })
             },
@@ -109,27 +115,49 @@ class WebSocket extends EventEmitter {
               const handlers = serverWs._listeners['close'] || []
               for (const h of handlers) h({ code, reason })
             },
-            addEventListener: () => {},
-            removeEventListener: () => {},
+            addEventListener: (type: string, handler: Function) => {
+              if (!clientWsListeners[type]) clientWsListeners[type] = []
+              clientWsListeners[type].push(handler)
+            },
+            removeEventListener: (type: string, handler: Function) => {
+              const arr = clientWsListeners[type]
+              if (arr) {
+                const idx = arr.indexOf(handler)
+                if (idx >= 0) arr.splice(idx, 1)
+              }
+            },
             get readyState() {
               return 1
             },
           } as CFWebSocket
 
-          // emit handoff to fastify server
+          // wire server → client: when server sends data, deliver to client's
+          // addEventListener handlers AND emit on the WebSocket instance
+          const origServerSend = serverWs.send
+          serverWs.send = (data: string | ArrayBuffer) => {
+            const handlers = clientWsListeners['message'] || []
+            for (const h of handlers) h({ data })
+            queueMicrotask(() => clientSide.emit('message', { data }))
+          }
+
+          // try handoff against all fastify instances, stop at first match
           const path = parsedUrl.pathname + parsedUrl.search
+          const handoffMsg = {
+            message: { url: path, headers: {}, method: 'GET' },
+            head: new Uint8Array(0),
+          }
           queueMicrotask(() => {
-            fastifyInstance.server.emit(
-              'message',
-              [
-                'handoff',
-                {
-                  message: { url: path, headers: {}, method: 'GET' },
-                  head: new Uint8Array(0),
-                },
-              ],
-              serverWs
-            )
+            let handled = false
+            for (const inst of instances) {
+              if (inst?.tryHandoff?.(handoffMsg, serverWs)) {
+                handled = true
+                break
+              }
+            }
+            // fallback: if no instance handled it and we have a fallback, emit directly
+            if (!handled && fallbackInstance?.server) {
+              fallbackInstance.server.emit('message', ['handoff', handoffMsg], serverWs)
+            }
             this.emit('open')
           })
         } else {
@@ -228,13 +256,40 @@ class WebSocket extends EventEmitter {
   }
 
   // standard EventTarget-style addEventListener (used by Connection)
+  // for 'message' events, wrap the handler so EventEmitter-style (data, isBinary)
+  // args get converted to DOM-style { data } events. streamOut uses
+  // addEventListener('message', ({data}) => ...) which needs DOM-style events.
+  #adapterMap = new WeakMap<Function, Function>()
+
   addEventListener(type: string, handler: (event: any) => void): void {
-    // wrap to emit EventEmitter-style
-    this.on(type, handler)
+    if (type === 'message') {
+      const wrapper = (data: any, isBinary?: boolean) => {
+        // if already a DOM-style event object with .data, pass through
+        if (data && typeof data === 'object' && 'data' in data) {
+          handler(data)
+        } else {
+          handler({ data, isBinary })
+        }
+      }
+      this.#adapterMap.set(handler, wrapper)
+      this.on(type, wrapper)
+    } else {
+      this.on(type, handler)
+    }
   }
 
   removeEventListener(type: string, handler: (event: any) => void): void {
-    this.off(type, handler)
+    if (type === 'message') {
+      const wrapper = this.#adapterMap.get(handler)
+      if (wrapper) {
+        this.off(type, wrapper as any)
+        this.#adapterMap.delete(handler)
+      } else {
+        this.off(type, handler)
+      }
+    } else {
+      this.off(type, handler)
+    }
   }
 
   #setupListeners(): void {