orez 0.2.27 → 0.2.30

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

@@ -1,310 +0,0 @@
-/**
- * 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)
-    } 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.test.ts

@@ -1,364 +0,0 @@
-import { PGlite } from '@electric-sql/pglite'
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-
-import { createPostgresShim, PostgresError } from './postgres.js'
-
-describe('postgres shim', () => {
-  let pglite: PGlite
-  let sql: ReturnType<typeof createPostgresShim>
-
-  beforeEach(async () => {
-    pglite = new PGlite()
-    await pglite.waitReady
-    sql = createPostgresShim(pglite)
-
-    // set up test table
-    await sql.unsafe(`
-      CREATE TABLE test_users (
-        id SERIAL PRIMARY KEY,
-        name TEXT NOT NULL,
-        email TEXT,
-        active BOOLEAN DEFAULT true,
-        metadata JSONB,
-        score NUMERIC
-      )
-    `)
-  })
-
-  afterEach(async () => {
-    await pglite.close()
-  })
-
-  // -- tagged template queries --
-
-  describe('tagged template queries', () => {
-    it('basic select', async () => {
-      await sql.unsafe(
-        `INSERT INTO test_users (name, email) VALUES ('alice', 'alice@test.com')`
-      )
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'alice'}`
-      expect(rows).toHaveLength(1)
-      expect(rows[0].name).toBe('alice')
-      expect(rows[0].email).toBe('alice@test.com')
-    })
-
-    it('multiple parameters', async () => {
-      await sql.unsafe(
-        `INSERT INTO test_users (name, email) VALUES ('bob', 'bob@test.com')`
-      )
-      await sql.unsafe(
-        `INSERT INTO test_users (name, email) VALUES ('carol', 'carol@test.com')`
-      )
-      const rows =
-        await sql`SELECT * FROM test_users WHERE name = ${'bob'} OR email = ${'carol@test.com'}`
-      expect(rows).toHaveLength(2)
-    })
-
-    it('empty result set', async () => {
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'nobody'}`
-      expect(rows).toHaveLength(0)
-      expect(rows.length).toBe(0)
-    })
-
-    it('null parameter', async () => {
-      await sql`INSERT INTO test_users (name, email) VALUES (${'dave'}, ${null})`
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'dave'}`
-      expect(rows).toHaveLength(1)
-      expect(rows[0].email).toBeNull()
-    })
-
-    it('boolean parameter', async () => {
-      await sql`INSERT INTO test_users (name, active) VALUES (${'eve'}, ${false})`
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'eve'}`
-      expect(rows[0].active).toBe(false)
-    })
-
-    it('json parameter', async () => {
-      const meta = { role: 'admin', tags: ['a', 'b'] }
-      await sql`INSERT INTO test_users (name, metadata) VALUES (${'frank'}, ${meta})`
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'frank'}`
-      expect(rows[0].metadata).toEqual(meta)
-    })
-
-    it('bigint parameter', async () => {
-      // bigint gets serialized to string, numeric column can hold it
-      const big = BigInt('99999999999999999')
-      await sql`INSERT INTO test_users (name, score) VALUES (${'grace'}, ${big})`
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'grace'}`
-      expect(rows[0].score).toBe('99999999999999999')
-    })
-  })
-
-  // -- result format --
-
-  describe('result format', () => {
-    it('array-like with indexed access', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('a'), ('b'), ('c')`)
-      const rows = await sql`SELECT name FROM test_users ORDER BY name`
-      expect(rows.length).toBe(3)
-      expect(rows[0].name).toBe('a')
-      expect(rows[1].name).toBe('b')
-      expect(rows[2].name).toBe('c')
-    })
-
-    it('iterable', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('x'), ('y')`)
-      const rows = await sql`SELECT name FROM test_users ORDER BY name`
-      const names: string[] = []
-      for (const row of rows) {
-        names.push(row.name)
-      }
-      expect(names).toEqual(['x', 'y'])
-    })
-
-    it('destructurable', async () => {
-      await sql.unsafe(
-        `INSERT INTO test_users (name, email) VALUES ('zara', 'z@test.com')`
-      )
-      const [{ name, email }] =
-        await sql`SELECT name, email FROM test_users WHERE name = ${'zara'}`
-      expect(name).toBe('zara')
-      expect(email).toBe('z@test.com')
-    })
-
-    it('has count metadata', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('a'), ('b')`)
-      const rows = await sql`SELECT * FROM test_users`
-      expect(rows.count).toBeGreaterThanOrEqual(2)
-    })
-
-    it('has command metadata', async () => {
-      const rows = await sql`SELECT 1 as val`
-      expect(rows.command).toBe('SELECT')
-    })
-
-    it('has columns metadata', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('test')`)
-      const rows = await sql`SELECT name, email FROM test_users`
-      expect(rows.columns).toHaveLength(2)
-      expect(rows.columns[0].name).toBe('name')
-      expect(rows.columns[1].name).toBe('email')
-    })
-  })
-
-  // -- unsafe queries --
-
-  describe('unsafe queries', () => {
-    it('DDL without params', async () => {
-      await sql.unsafe(`CREATE TABLE unsafe_test (id INT)`)
-      const rows =
-        await sql`SELECT table_name FROM information_schema.tables WHERE table_name = 'unsafe_test'`
-      expect(rows).toHaveLength(1)
-    })
-
-    it('query with params', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('unsafe_user')`)
-      const rows = await sql.unsafe('SELECT * FROM test_users WHERE name = $1', [
-        'unsafe_user',
-      ])
-      expect(rows).toHaveLength(1)
-      expect(rows[0].name).toBe('unsafe_user')
-    })
-
-    it('multi-statement', async () => {
-      // pglite.query handles single statements; multi-statement DDL
-      // typically uses exec. unsafe forwards to query which handles most cases.
-      const result = await sql.unsafe(`SELECT 1 as a`)
-      expect(result[0].a).toBe(1)
-    })
-  })
-
-  // -- transactions --
-
-  describe('transactions', () => {
-    it('commit on success', async () => {
-      await sql.begin(async (tx) => {
-        await tx`INSERT INTO test_users (name) VALUES (${'tx_user'})`
-      })
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'tx_user'}`
-      expect(rows).toHaveLength(1)
-    })
-
-    it('rollback on error', async () => {
-      await expect(
-        sql.begin(async (tx) => {
-          await tx`INSERT INTO test_users (name) VALUES (${'rollback_user'})`
-          throw new Error('intentional rollback')
-        })
-      ).rejects.toThrow('intentional rollback')
-
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'rollback_user'}`
-      expect(rows).toHaveLength(0)
-    })
-
-    it('with isolation level string (ignored but accepted)', async () => {
-      await sql.begin('serializable', async (tx) => {
-        await tx`INSERT INTO test_users (name) VALUES (${'iso_user'})`
-      })
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'iso_user'}`
-      expect(rows).toHaveLength(1)
-    })
-
-    it('tx.unsafe works', async () => {
-      await sql.begin(async (tx) => {
-        await tx.unsafe(`INSERT INTO test_users (name) VALUES ('tx_unsafe')`)
-      })
-      const rows = await sql`SELECT * FROM test_users WHERE name = ${'tx_unsafe'}`
-      expect(rows).toHaveLength(1)
-    })
-
-    it('nested queries in transaction', async () => {
-      const result = await sql.begin(async (tx) => {
-        await tx`INSERT INTO test_users (name) VALUES (${'nested_a'})`
-        await tx`INSERT INTO test_users (name) VALUES (${'nested_b'})`
-        return tx`SELECT name FROM test_users WHERE name LIKE 'nested_%' ORDER BY name`
-      })
-      expect(result).toHaveLength(2)
-      expect(result[0].name).toBe('nested_a')
-      expect(result[1].name).toBe('nested_b')
-    })
-  })
-
-  // -- PostgresError --
-
-  describe('PostgresError', () => {
-    it('has correct .code property', () => {
-      const err = new PostgresError({ message: 'duplicate key', code: '23505' })
-      expect(err.code).toBe('23505')
-      expect(err.message).toBe('duplicate key')
-      expect(err.name).toBe('PostgresError')
-      expect(err).toBeInstanceOf(Error)
-      expect(err).toBeInstanceOf(PostgresError)
-    })
-
-    it('has all standard fields', () => {
-      const err = new PostgresError({
-        message: 'test',
-        code: '42P01',
-        severity: 'ERROR',
-        detail: 'some detail',
-        hint: 'some hint',
-        schema_name: 'public',
-        table_name: 'users',
-      })
-      expect(err.severity).toBe('ERROR')
-      expect(err.detail).toBe('some detail')
-      expect(err.hint).toBe('some hint')
-      expect(err.schema_name).toBe('public')
-      expect(err.table_name).toBe('users')
-    })
-  })
-
-  // -- identifier escaping --
-
-  describe('identifier escaping', () => {
-    it('sql(string) returns escaped identifier usable in templates', async () => {
-      const tableName = 'test_users'
-      const colName = 'name'
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('ident_test')`)
-      const rows =
-        await sql`SELECT ${sql(colName)} FROM ${sql(tableName)} WHERE name = ${'ident_test'}`
-      expect(rows).toHaveLength(1)
-      expect(rows[0].name).toBe('ident_test')
-    })
-
-    it('escapes quotes in identifiers', () => {
-      const ident = sql('my"table')
-      expect(ident.value).toBe('"my""table"')
-    })
-
-    it('escapes dots as schema separators', () => {
-      const ident = sql('public.users')
-      expect(ident.value).toBe('"public"."users"')
-    })
-  })
-
-  // -- options and metadata --
-
-  describe('options and metadata', () => {
-    it('sql.options has expected shape', () => {
-      expect(sql.options).toBeDefined()
-      expect(sql.options.host).toEqual(['localhost'])
-      expect(sql.options.port).toEqual([5432])
-      expect(sql.options.database).toBe('pglite')
-      expect(sql.options.max).toBe(1)
-      expect(typeof sql.options.fetch_types).toBe('boolean')
-    })
-
-    it('sql.PostgresError is the error class', () => {
-      expect(sql.PostgresError).toBe(PostgresError)
-    })
-
-    it('sql.end() resolves without error', async () => {
-      await expect(sql.end()).resolves.toBeUndefined()
-    })
-  })
-
-  // -- simple() modifier --
-
-  describe('query modifiers', () => {
-    it('.simple() returns the same pending query', async () => {
-      await sql.unsafe(`INSERT INTO test_users (name) VALUES ('simple_test')`)
-      const rows =
-        await sql`SELECT * FROM test_users WHERE name = ${'simple_test'}`.simple()
-      expect(rows).toHaveLength(1)
-    })
-  })
-
-  // -- error propagation --
-
-  describe('error propagation', () => {
-    it('propagates SQL errors from tagged template', async () => {
-      await expect(sql`SELECT * FROM nonexistent_table`).rejects.toThrow()
-    })
-
-    it('propagates SQL errors from unsafe', async () => {
-      await expect(sql.unsafe('SELECT * FROM nonexistent_table')).rejects.toThrow()
-    })
-  })
-
-  // -- multi-statement queries --
-
-  describe('multi-statement DDL', () => {
-    it('handles multi-statement via unsafe()', async () => {
-      await sql.unsafe(`
-        CREATE SCHEMA IF NOT EXISTS test_schema;
-        CREATE TABLE IF NOT EXISTS test_schema.items (
-          id TEXT PRIMARY KEY,
-          value TEXT
-        )
-      `)
-      // verify schema and table were created
-      const result =
-        await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'test_schema'`
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    it('handles multi-statement via tagged template', async () => {
-      await sql`
-        CREATE SCHEMA IF NOT EXISTS test_schema2;
-        CREATE TABLE IF NOT EXISTS test_schema2.things (
-          id TEXT PRIMARY KEY,
-          name TEXT
-        )
-      `
-      const result =
-        await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'test_schema2'`
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    it('handles multi-statement with quoted identifiers containing special chars', async () => {
-      await sql.unsafe(`
-        CREATE SCHEMA IF NOT EXISTS "zero_0/cvr";
-        CREATE TABLE IF NOT EXISTS "zero_0/cvr"."clients" (
-          "clientGroupID" TEXT NOT NULL,
-          "clientID" TEXT NOT NULL,
-          PRIMARY KEY ("clientGroupID", "clientID")
-        )
-      `)
-      const result =
-        await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'zero_0/cvr'`
-      expect(result.length).toBeGreaterThan(0)
-    })
-  })
-})