orez 0.2.27 → 0.2.30

package/src/worker/shims/ws.ts

@@ -1,467 +0,0 @@
-// NOTE THIS IS NOT OREZ NODE THIS IS NOT A GOOD REFERENCE BECAUSE ITS OUR EARLY GUESS AT WHAT COULD WORK
-// DO NOT STUDY THIS, THE OTHER STUFF IN SRC IS WHERE YOU EANT TO LOOK
-
-/**
- * ws (websocket) shim for cloudflare workers.
- *
- * wraps CF Workers WebSocket (from WebSocketPair) to implement the
- * ws npm package API that zero-cache uses. enables bundler aliasing
- * so zero-cache's WebSocket handling works with CF durable WebSockets.
- *
- * usage with bundler alias:
- *   alias: { 'ws': './src/worker/shims/ws.js' }
- */
-
-import EventEmitter from 'node:events'
-import { Duplex } from 'node:stream'
-
-// -- readyState constants --
-const CONNECTING = 0
-const OPEN = 1
-const CLOSING = 2
-const CLOSED = 3
-
-// -- CF WebSocket interface (minimal) --
-interface CFWebSocket {
-  send(data: string | ArrayBuffer | ArrayBufferView): void
-  close(code?: number, reason?: string): void
-  addEventListener(type: string, handler: (event: any) => void): void
-  removeEventListener(type: string, handler: (event: any) => void): void
-  readyState: number
-  accept?(): void
-}
-
-function debugWS(event: Record<string, unknown>): void {
-  try {
-    const log = (globalThis as any).__orez_ws_debug_log
-    if (typeof log === 'function') log(event)
-  } catch {
-    // debug logging must never affect websocket behavior
-  }
-}
-
-function summarizeWSData(data: unknown): Record<string, unknown> {
-  if (typeof data === 'string') {
-    return {
-      dataType: 'string',
-      bytes: data.length,
-      text: data.length > 300 ? `${data.slice(0, 300)}...` : data,
-    }
-  }
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
-    return { dataType: 'buffer', bytes: data.byteLength }
-  }
-  if (data instanceof ArrayBuffer) {
-    return { dataType: 'arraybuffer', bytes: data.byteLength }
-  }
-  if (ArrayBuffer.isView(data)) {
-    return { dataType: data.constructor.name, bytes: data.byteLength }
-  }
-  return { dataType: typeof data }
-}
-
-// -- WebSocket shim --
-// wraps a CF WebSocket to match the ws package WebSocket API
-
-class WebSocket extends EventEmitter {
-  static readonly CONNECTING = CONNECTING
-  static readonly OPEN = OPEN
-  static readonly CLOSING = CLOSING
-  static readonly CLOSED = CLOSED
-
-  readonly CONNECTING = CONNECTING
-  readonly OPEN = OPEN
-  readonly CLOSING = CLOSING
-  readonly CLOSED = CLOSED
-
-  #ws!: CFWebSocket
-  #url: string
-  #listeners = new Map<string, (event: any) => void>()
-
-  constructor(urlOrSocket: string | CFWebSocket, _protocols?: unknown, _opts?: unknown) {
-    super()
-
-    if (typeof urlOrSocket === 'string') {
-      this.#url = urlOrSocket
-      // check for in-process connections (fastify shim uses port 0 or 1)
-      const parsedUrl = new URL(urlOrSocket, 'http://localhost')
-      const isInProcess =
-        parsedUrl.port === '0' ||
-        parsedUrl.port === '1' ||
-        parsedUrl.hostname === 'localhost'
-
-      if (isInProcess) {
-        // in-process: connect via fastify server's handoff mechanism
-        // 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
-          const clientSide = this
-          const serverWs: any = {
-            readyState: 1,
-            _listeners: {} as Record<string, Function[]>,
-            send: (data: string | ArrayBuffer) => {
-              // deliver to client side
-              // wrap in event object — zero-cache handleMessage reads event.data
-              queueMicrotask(() => clientSide.emit('message', { data }))
-            },
-            close: (code?: number, reason?: string) => {
-              serverWs.readyState = 3
-              queueMicrotask(() => clientSide.emit('close', code || 1000, reason || ''))
-            },
-            ping: () => {
-              // ping from server → deliver 'ping' event to client
-              // (expectPingsForLiveness listens for 'ping', not 'pong')
-              queueMicrotask(() => clientSide.emit('ping'))
-            },
-            addEventListener: (type: string, handler: Function) => {
-              if (!serverWs._listeners[type]) serverWs._listeners[type] = []
-              serverWs._listeners[type].push(handler)
-            },
-            removeEventListener: (type: string, handler: Function) => {
-              const arr = serverWs._listeners[type]
-              if (arr) {
-                const idx = arr.indexOf(handler)
-                if (idx >= 0) arr.splice(idx, 1)
-              }
-            },
-          }
-
-          // 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) => {
-              const handlers = serverWs._listeners['message'] || []
-              for (const h of handlers) h({ data })
-            },
-            close: (code?: number, reason?: string) => {
-              const handlers = serverWs._listeners['close'] || []
-              for (const h of handlers) h({ code, reason })
-            },
-            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
-
-          // 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(() => {
-            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 {
-          // no fastify instance — emit close immediately
-          queueMicrotask(() => this.emit('close', 1006, 'no fastify server'))
-        }
-      } else if (typeof globalThis.WebSocket === 'function') {
-        // real outbound WebSocket for external connections
-        const nativeWs = new globalThis.WebSocket(urlOrSocket) as any
-        this.#ws = {
-          accept: () => {},
-          send: (data: string | ArrayBuffer) => nativeWs.send(data),
-          close: (code?: number, reason?: string) => nativeWs.close(code, reason),
-          addEventListener: (type: string, handler: (event: any) => void) =>
-            nativeWs.addEventListener(type, handler),
-          removeEventListener: (type: string, handler: (event: any) => void) =>
-            nativeWs.removeEventListener(type, handler),
-          get readyState() {
-            return nativeWs.readyState
-          },
-        } as CFWebSocket
-        nativeWs.addEventListener('open', () => this.emit('open'))
-        nativeWs.addEventListener('message', (ev: MessageEvent) =>
-          this.emit('message', ev.data)
-        )
-        nativeWs.addEventListener('close', (ev: CloseEvent) =>
-          this.emit('close', ev.code, ev.reason)
-        )
-        nativeWs.addEventListener('error', (ev: Event) =>
-          this.emit('error', new Error('WebSocket error'))
-        )
-      } else {
-        throw new Error(
-          'ws shim: outbound WebSocket connections not yet supported. ' +
-            'use the CF Workers fetch API for outbound WebSocket.'
-        )
-      }
-    } else {
-      this.#ws = urlOrSocket
-      this.#url = ''
-      debugWS({ event: 'wrap-cf-socket', readyState: this.#ws.readyState })
-      this.#setupListeners()
-    }
-  }
-
-  get url(): string {
-    return this.#url
-  }
-
-  get readyState(): number {
-    return this.#ws.readyState
-  }
-
-  send(
-    data: string | Buffer | ArrayBuffer | ArrayBufferView,
-    cb?: (err?: Error) => void
-  ): void {
-    try {
-      debugWS({ event: 'send', url: this.#url, ...summarizeWSData(data) })
-      if (typeof data === 'string') {
-        this.#ws.send(data)
-      } else if (Buffer.isBuffer(data)) {
-        this.#ws.send(new Uint8Array(data.buffer, data.byteOffset, data.byteLength))
-      } else if (data instanceof ArrayBuffer) {
-        this.#ws.send(data)
-      } else if (ArrayBuffer.isView(data)) {
-        this.#ws.send(new Uint8Array(data.buffer, data.byteOffset, data.byteLength))
-      } else {
-        this.#ws.send(String(data))
-      }
-      cb?.()
-    } catch (err) {
-      cb?.(err as Error)
-    }
-  }
-
-  close(code?: number, reason?: string): void {
-    try {
-      this.#ws.close(code, reason)
-    } catch {
-      // socket may already be closed
-    }
-  }
-
-  terminate(): void {
-    // real ws.terminate() destroys the socket without a close frame.
-    // CF Workers don't expose raw socket destroy, so close with 1000.
-    this.close(1000)
-  }
-
-  ping(_data?: unknown, _mask?: boolean, _cb?: () => void): void {
-    // forward ping to underlying socket if it supports it (in-process pairs)
-    if (typeof (this.#ws as any).ping === 'function') {
-      ;(this.#ws as any).ping()
-    }
-    // also emit pong locally (CF WebSockets handle ping/pong at platform level)
-    this.emit('pong')
-  }
-
-  // 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 {
-    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 {
-    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 {
-    // match ws npm package event signatures:
-    //   message: (data: Buffer|string, isBinary: boolean)
-    //   close: (code: number, reason: string)
-    //   error: (err: Error)
-    const onMessage = (event: any) => {
-      const data = event.data
-      debugWS({ event: 'message', url: this.#url, ...summarizeWSData(data) })
-      this.emit('message', data, typeof data !== 'string')
-    }
-    const onClose = (event: any) => {
-      debugWS({
-        event: 'close',
-        url: this.#url,
-        code: event.code ?? 1000,
-        reason: event.reason ?? '',
-      })
-      this.emit('close', event.code ?? 1000, event.reason ?? '')
-    }
-    const onError = (event: any) => {
-      debugWS({
-        event: 'error',
-        url: this.#url,
-        message: event?.message ?? event?.error?.message ?? 'WebSocket error',
-      })
-      this.emit('error', event.error ?? new Error(event.message ?? 'WebSocket error'))
-    }
-    const onOpen = () => {
-      debugWS({ event: 'open', url: this.#url })
-      this.emit('open')
-    }
-
-    this.#ws.addEventListener('message', onMessage)
-    this.#ws.addEventListener('close', onClose)
-    this.#ws.addEventListener('error', onError)
-    this.#ws.addEventListener('open', onOpen)
-
-    this.#listeners.set('message', onMessage)
-    this.#listeners.set('close', onClose)
-    this.#listeners.set('error', onError)
-    this.#listeners.set('open', onOpen)
-  }
-}
-
-// -- WebSocketServer shim --
-// zero-cache uses WebSocketServer with { noServer: true } for handleUpgrade
-
-class WebSocketServer extends EventEmitter {
-  constructor(_opts?: { noServer?: boolean }) {
-    super()
-  }
-
-  close(cb?: (err?: Error) => void): void {
-    // no-op — browser embed has no real server to close
-    cb?.()
-  }
-
-  /**
-   * handle a WebSocket upgrade. on CF Workers the upgrade is already done
-   * (WebSocketPair), so this just wraps the CF WebSocket in our shim.
-   *
-   * @param message - the HTTP request (IncomingMessage-like object)
-   * @param socket - the underlying socket (CF WebSocket on CF Workers)
-   * @param head - upgrade head buffer
-   * @param callback - receives the wrapped WebSocket
-   */
-  handleUpgrade(
-    _message: unknown,
-    socket: CFWebSocket | unknown,
-    _head: unknown,
-    callback: (ws: WebSocket) => void
-  ): void {
-    // wrap the CF WebSocket in our shim
-    debugWS({ event: 'handle-upgrade' })
-    const ws = new WebSocket(socket as CFWebSocket)
-    callback(ws)
-  }
-}
-
-// -- createWebSocketStream --
-// creates a Node.js Duplex stream from a WebSocket.
-// used by zero-cache's Connection class for streaming messages.
-
-function createWebSocketStream(
-  ws: WebSocket,
-  _opts?: { decodeStrings?: boolean }
-): Duplex {
-  const duplex = new Duplex({
-    objectMode: false,
-    decodeStrings: false,
-
-    read() {
-      // data is pushed from ws message events
-    },
-
-    write(
-      chunk: Buffer | string,
-      _encoding: string,
-      callback: (err?: Error | null) => void
-    ) {
-      try {
-        ws.send(typeof chunk === 'string' ? chunk : chunk.toString(), callback)
-      } catch (err) {
-        callback(err as Error)
-      }
-    },
-
-    destroy(err: Error | null, callback: (err?: Error | null) => void) {
-      ws.close()
-      callback(err)
-    },
-  })
-
-  // pipe ws messages into the readable side
-  ws.on('message', (event: any) => {
-    const data = event?.data ?? event
-    if (typeof data === 'string') {
-      duplex.push(data)
-    } else if (data instanceof ArrayBuffer) {
-      duplex.push(Buffer.from(data))
-    } else if (ArrayBuffer.isView(data)) {
-      duplex.push(Buffer.from(data.buffer, data.byteOffset, data.byteLength))
-    } else {
-      duplex.push(String(data))
-    }
-  })
-
-  ws.on('close', () => {
-    duplex.push(null) // signal end of readable
-    duplex.destroy()
-  })
-
-  ws.on('error', (event: any) => {
-    const err = event?.error ?? new Error(event?.message ?? 'WebSocket error')
-    duplex.destroy(err)
-  })
-
-  return duplex
-}
-
-export default WebSocket
-export { WebSocket, WebSocketServer, createWebSocketStream }

package/src/worker/shims/zero-process-env.ts

@@ -1,11 +0,0 @@
-const globalProcess = ((globalThis as any).process ??= {})
-
-globalProcess.env ??= {}
-globalProcess.pid ??= 1
-globalProcess.argv ??= []
-globalProcess.kill ??= () => true
-
-globalProcess.env.SINGLE_PROCESS = '1'
-globalProcess.env.NODE_ENV ??= 'development'
-
-export {}

package/src/worker/types.ts

@@ -1,75 +0,0 @@
-/**
- * orez/worker types.
- *
- * interfaces for the embeddable orez worker that runs PGlite + change
- * tracking without Node.js dependencies. designed for CF Workers/DO
- * but usable in any JS runtime (browser, vitest, bun, deno).
- */
-
-import type { Mutex } from '../mutex.js'
-import type { ChangeRecord } from '../replication/change-tracker.js'
-import type { ReplicationWriter } from '../replication/handler.js'
-import type { PGlite, PGliteOptions, Results } from '@electric-sql/pglite'
-
-/** options for creating an orez worker */
-export interface OrezWorkerOptions {
-  /**
-   * pre-created PGlite instance. when provided, orez wraps it
-   * without managing its lifecycle (caller is responsible for closing).
-   */
-  pglite?: PGlite
-
-  /**
-   * PGlite constructor options. used when `pglite` is not provided.
-   * in CF Workers, pass wasmModule/fsBundle/loadDataDir here.
-   */
-  pgliteOptions?: PGliteOptions
-
-  /** publication names to track. defaults to all public tables. */
-  publications?: string[]
-
-  /** log level (default: 'warn') */
-  logLevel?: 'error' | 'warn' | 'info' | 'debug'
-}
-
-/** the orez worker instance */
-export interface OrezWorker {
-  /** the underlying PGlite instance */
-  readonly db: PGlite
-
-  /** mutex for serializing PGlite access */
-  readonly mutex: Mutex
-
-  /** run a parameterized query */
-  query<T extends Record<string, unknown> = Record<string, unknown>>(
-    sql: string,
-    params?: unknown[]
-  ): Promise<Results<T>>
-
-  /** execute raw SQL (DDL, multi-statement) */
-  exec(sql: string): Promise<void>
-
-  /** install/reinstall change tracking triggers on all published tables */
-  installChangeTracking(): Promise<void>
-
-  /** get changes since a watermark */
-  getChangesSince(watermark: number, limit?: number): Promise<ChangeRecord[]>
-
-  /** get current watermark value */
-  getCurrentWatermark(): Promise<number>
-
-  /** purge consumed changes up to watermark */
-  purgeChanges(watermark: number): Promise<number>
-
-  /**
-   * start streaming replication to a writer.
-   * runs until the writer is closed or the worker is shut down.
-   */
-  startReplication(writer: ReplicationWriter): Promise<void>
-
-  /** whether this worker owns the PGlite instance (manages its lifecycle) */
-  readonly ownsInstance: boolean
-
-  /** close the worker. if ownsInstance, also closes PGlite. */
-  close(): Promise<void>
-}