orez 0.2.26 → 0.2.29

package/src/browser.ts

@@ -1,203 +0,0 @@
-/**
- * orez browser entry — aligned to orez-node architecture.
- *
- * mirrors index.ts startup sequence:
- *   1. create PGlite Web Workers (3 instances)
- *   2. install change tracking
- *   3. start pg-proxy-browser (wire protocol proxy)
- *   4. start zero-cache (SINGLE_PROCESS=1, connects to proxy)
- *
- * intended to run inside a Web Worker. PGlite instances run in
- * separate Web Workers (like orez-node's worker threads).
- */
-
-import { PGliteWebProxy } from './pglite-web-proxy.js'
-import { installChangeTracking } from './replication/change-tracker.js'
-import { resetReplicationState } from './replication/handler.js'
-
-import type { PGlite } from '@electric-sql/pglite'
-
-export interface OrezBrowserConfig {
-  /** app ID for zero-cache (default: 'zero') */
-  appId?: string
-
-  /** publication names for replication */
-  publications?: string[]
-
-  /** URL for PGlite web worker script */
-  pgliteWorkerUrl: string
-
-  /** URL for bedrock-sqlite WASM */
-  bedrockSqliteUrl?: string
-
-  /** init SQL to run on postgres instance after creation */
-  initSql?: string
-
-  /** log level */
-  logLevel?: string
-
-  /**
-   * intercept browser-mode orez admin routes before they reach zero-cache.
-   * default: true.
-   */
-  disableAdminApi?: boolean
-}
-
-export interface OrezBrowserInstance {
-  /** PGlite proxies (for direct queries from project-server) */
-  instances: {
-    postgres: PGliteWebProxy
-    cvr: PGliteWebProxy
-    cdb: PGliteWebProxy
-  }
-
-  /** signal the replication handler that changes are available */
-  signalReplication(): void
-
-  /** handle a WebSocket connection from a Zero client */
-  handleWebSocket(ws: any, url?: string, headers?: Record<string, string>): void
-
-  /** handle an HTTP request (push/pull) */
-  handleHttp(request: {
-    method: string
-    url: string
-    headers?: Record<string, string>
-    body?: string | null
-  }): Promise<{ status: number; headers: Record<string, string>; body: string }>
-
-  /** stop everything */
-  stop(): Promise<void>
-}
-
-export async function startOrezBrowser(
-  config: OrezBrowserConfig
-): Promise<OrezBrowserInstance> {
-  const appId = config.appId || 'zero'
-  const publications = config.publications?.join(',') || `orez_${appId}_public`
-
-  // step 1: create PGlite Web Workers (3 instances, like orez-node)
-  const pgPostgresWorker = new Worker(config.pgliteWorkerUrl, {
-    type: 'module',
-    name: 'pglite-postgres',
-  })
-  const pgCvrWorker = new Worker(config.pgliteWorkerUrl, {
-    type: 'module',
-    name: 'pglite-cvr',
-  })
-  const pgCdbWorker = new Worker(config.pgliteWorkerUrl, {
-    type: 'module',
-    name: 'pglite-cdb',
-  })
-
-  // init each PGlite worker
-  pgPostgresWorker.postMessage({
-    type: 'init',
-    dataDir: 'idb://orez-postgres',
-    name: 'postgres',
-  })
-  pgCvrWorker.postMessage({ type: 'init', dataDir: 'idb://orez-cvr', name: 'cvr' })
-  pgCdbWorker.postMessage({ type: 'init', dataDir: 'idb://orez-cdb', name: 'cdb' })
-
-  // create proxies (like orez-node's PGliteWorkerProxy)
-  const pgPostgres = new PGliteWebProxy(pgPostgresWorker, 'postgres')
-  const pgCvr = new PGliteWebProxy(pgCvrWorker, 'cvr')
-  const pgCdb = new PGliteWebProxy(pgCdbWorker, 'cdb')
-
-  await Promise.all([pgPostgres.waitReady, pgCvr.waitReady, pgCdb.waitReady])
-  console.debug('[orez-browser] all 3 PGlite workers ready')
-
-  // step 2: install change tracking (like orez-node)
-  await installChangeTracking(pgPostgres as unknown as PGlite)
-  console.debug('[orez-browser] change tracking installed')
-
-  // run user init SQL if provided
-  if (config.initSql) {
-    await pgPostgres.exec(config.initSql)
-    console.debug('[orez-browser] init SQL complete')
-  }
-
-  // create publication
-  try {
-    const pubs = await pgPostgres.query<{ count: string }>(
-      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-      [publications]
-    )
-    if (Number(pubs.rows[0]?.count) === 0) {
-      await pgPostgres.exec(`CREATE PUBLICATION "${publications}"`)
-    }
-  } catch {}
-
-  // step 3: start pg-proxy-browser
-  // the proxy handles wire protocol, replication, mutexes — like orez-node's pg-proxy.
-  // zero-cache's postgres shim routes queries through this proxy.
-  const { createBrowserProxy } = await import('./pg-proxy-browser.js')
-  const proxy = await createBrowserProxy(
-    {
-      postgres: pgPostgres as unknown as PGlite,
-      cvr: pgCvr as unknown as PGlite,
-      cdb: pgCdb as unknown as PGlite,
-      postgresReplicas: [],
-    },
-    { pgPassword: '', pgUser: 'user' }
-  )
-  console.debug('[orez-browser] pg-proxy-browser started')
-
-  // step 4: start zero-cache (SINGLE_PROCESS=1)
-  // zero-cache uses the real postgres package with a MessagePort socket
-  // that connects to pg-proxy-browser. identical to orez-node where
-  // zero-cache uses real postgres over TCP to pg-proxy.
-  //
-  // set up the proxy connect function for postgres-browser.ts shim
-  ;(globalThis as any).__orez_proxy_connect = (port: MessagePort) => {
-    proxy.handleConnection(port)
-  }
-  ;(globalThis as any).__orez_proxy_password = ''
-  ;(globalThis as any).__orez_proxy_user = 'user'
-
-  // PGlite global still needed for browser-embed's sqlite setup
-  ;(globalThis as any).__orez_pglite = pgPostgres
-
-  // start zero-cache via browser-embed's runWorker
-  const { startZeroCacheEmbedBrowser } = await import('./worker/browser-embed.js')
-  const zc = await startZeroCacheEmbedBrowser({
-    pglite: pgPostgres as unknown as PGlite,
-    appId,
-    publications: config.publications,
-    disableAdminApi: config.disableAdminApi ?? true,
-    env: {
-      ZERO_LOG_LEVEL: config.logLevel || 'info',
-    },
-  })
-  console.debug('[orez-browser] zero-cache started')
-
-  // step 5: expose API
-  const { signalReplicationChange } = await import('./replication/handler.js')
-
-  return {
-    instances: { postgres: pgPostgres, cvr: pgCvr, cdb: pgCdb },
-
-    signalReplication() {
-      signalReplicationChange()
-    },
-
-    handleWebSocket(ws: any, url = '/', headers?: Record<string, string>) {
-      zc.handleWebSocket(ws, url)
-    },
-
-    async handleHttp(request: {
-      method: string
-      url: string
-      headers?: Record<string, string>
-      body?: string | null
-    }) {
-      return zc.handleHttp(request)
-    },
-
-    async stop() {
-      await zc.stop()
-      proxy.close()
-      resetReplicationState()
-      await Promise.all([pgPostgres.close(), pgCvr.close(), pgCdb.close()])
-    },
-  }
-}

package/src/cf-do/.wrangler/cache/cf.json

@@ -1 +0,0 @@
-{"httpProtocol":"HTTP/1.1","clientAcceptEncoding":"gzip, deflate, br","requestPriority":"","edgeRequestKeepAliveStatus":1,"requestHeaderNames":{},"clientTcpRtt":74,"clientQuicRtt":0,"colo":"LAX","asn":21928,"asOrganization":"T-Mobile USA, Inc.","country":"US","isEUCountry":false,"city":"Honolulu","continent":"NA","region":"Hawaii","regionCode":"HI","timezone":"Pacific/Honolulu","longitude":"-157.85833","latitude":"21.30694","postalCode":"96802","metroCode":"744","tlsVersion":"TLSv1.3","tlsCipher":"AEAD-AES256-GCM-SHA384","tlsClientRandom":"8lAacoE+Gg3H5AKn8BQNpAGr3fgr0OV1txs9E+GEKXk=","tlsClientCiphersSha1":"JZtiTn8H/ntxORk+XXvU2EvNoz8=","tlsClientExtensionsSha1":"Y7DIC8A6G0/aXviZ8ie/xDbJb7g=","tlsClientExtensionsSha1Le":"6e+q3vPm88rSgMTN/h7WTTxQ2wQ=","tlsExportedAuthenticator":{"clientHandshake":"88b6a0bf9d7b4c6bc26b9f11255fe3f55b2bae485c86026892687913505e6a337a54221c8ec52b88741035fde8e80b91","serverHandshake":"a611a55711347da40c0167874992b47d75a4de9ed1c0bc731dd1f80051efde3b73a8baff4e484f30b284d662cd503dcb","clientFinished":"81b77db43ca14e8934ebd5f4c6d3656a1ccc726f04a10164cf7d599128d7dfbd3fa15f932068a583f288a0327d69a5f5","serverFinished":"68efa1737e629e56c92cbb680f96730052e8269e6248b62dd26a62d3ea7be55991e9f0ea85e6bebf95dbc6adbb41334e"},"tlsClientHelloLength":"386","tlsClientAuth":{"certPresented":"0","certVerified":"NONE","certRevoked":"0","certIssuerDN":"","certSubjectDN":"","certIssuerDNRFC2253":"","certSubjectDNRFC2253":"","certIssuerDNLegacy":"","certSubjectDNLegacy":"","certSerial":"","certIssuerSerial":"","certSKI":"","certIssuerSKI":"","certFingerprintSHA1":"","certFingerprintSHA256":"","certNotBefore":"","certNotAfter":"","certRFC9440":"","certRFC9440TooLarge":false,"certChainRFC9440":"","certChainRFC9440TooLarge":false},"verifiedBotCategory":"","edgeL4":{"deliveryRate":52536},"botManagement":{"corporateProxy":false,"verifiedBot":false,"jsDetection":{"passed":false},"staticResource":false,"detectionIds":{},"score":99}}

package/src/cf-do/ARCHITECTURE.md

@@ -1,83 +0,0 @@
-# orez/cf-do architecture - READ FIRST
-
-## The fundamental constraint
-
-**Cloudflare Durable Objects have a 128 MB memory budget per instance.**
-
-PGlite + WASM Postgres + extension binaries pushes real deployments over that
-budget. That is the dead end. zero-cache is still essential: it owns the sync
-protocol, IVM/CVR machinery, replication handling, and client semantics.
-
-The orez Cloudflare path is therefore:
-
-- **yes** real `@rocicorp/zero` zero-cache
-- **yes** Durable Object SQLite as the durable storage engine
-- **yes** orez `DoBackend` serving Postgres-protocol semantics to zero-cache
-- **no** PGlite
-- **no** `pglite.wasm`, `pglite.data`, extension `.so` files, or WASM Postgres
-
-## Production shape
-
-```
-┌────────────────────────────────────────────────────────────────┐
-│ Worker                                                         │
-│                                                                │
-│ /sync/v* and /api/zero/* ─────► ZERO_CACHE_DO singleton        │
-│ everything else ──────────────► ASSETS                         │
-└────────────────────────────────────────────────────────────────┘
-
-┌────────────────────────────────────────────────────────────────┐
-│ ZERO_CACHE_DO Durable Object                                   │
-│                                                                │
-│ startZeroCacheEmbedCF() runs real zero-cache in-process        │
-│   │                                                            │
-│   ├─ zero-cache replica/CVR/CDB SQLite                         │
-│   │    @rocicorp/zero-sqlite3 -> orez worker SQLite shim       │
-│   │    backed by ctx.storage.sql                               │
-│   │                                                            │
-│   └─ zero-cache upstream Postgres connections                  │
-│        postgres -> orez postgres browser shim                  │
-│        DoBackend -> ZERO_SQL_DO /exec and /batch               │
-└────────────────────────────────────────────────────────────────┘
-
-┌────────────────────────────────────────────────────────────────┐
-│ ZERO_SQL_DO Durable Object                                     │
-│                                                                │
-│ ZeroDO raw SQL endpoints                                       │
-│   /exec, /batch, /changes, /notify, /__orez/*                  │
-│   ctx.storage.sql                                              │
-│   _orez.changes populated by SQL tracking triggers             │
-└────────────────────────────────────────────────────────────────┘
-```
-
-All app traffic for a deployed project must use singleton DO IDs for both
-`ZERO_CACHE_DO` and `ZERO_SQL_DO`; otherwise browser sessions will not share the
-same zero-cache process and durable SQLite state.
-
-## Important files
-
-- `src/worker/zero-cache-embed-cf.ts` - starts real zero-cache inside a Durable
-  Object and wires its storage/network dependencies to CF-safe shims.
-- `src/worker/cf-patches.ts` - patches zero-cache internals so its worker
-  graph and writer run in the Workers runtime.
-- `src/pg-proxy-do-backend.ts` - translates Postgres protocol operations from
-  zero-cache into DO SQL endpoint requests.
-- `src/cf-do/worker.ts` - `ZeroDO`, the generic DO SQL backend. It also still
-  contains a bespoke Zero sync protocol handler used for development and
-  protocol experiments, but the production Soot deploy path uses real
-  zero-cache through `startZeroCacheEmbedCF()`.
-- `src/do-sql-tracking.ts` and `src/replication/*` - change tracking and
-  logical replication support over `_orez.changes`.
-
-## What not to do
-
-- Do not import `@electric-sql/pglite` into the Cloudflare DO deploy path.
-- Do not bundle PGlite WASM/data/extensions into the deploy template.
-- Do not replace zero-cache with the bespoke handler for production sync.
-- Do not add a second fallback path that silently switches between PGlite,
-  bespoke sync, and zero-cache. There should be one production path:
-  zero-cache -> orez Postgres protocol -> DO SQLite.
-
-If a future change needs more Postgres behavior, implement it in
-`DoBackend`/the SQL translator or the DO SQL backend. Do not put PGlite back in
-the request path.

package/src/cf-do/watermark.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { DurableWatermarkState } from './watermark.js'
-
-class FakeResult {
-  constructor(private readonly rows: Array<Record<string, unknown>> = []) {}
-
-  one() {
-    return this.rows[0]
-  }
-
-  toArray() {
-    return this.rows
-  }
-}
-
-class FakeSql {
-  changes: Array<{ watermark: number }> = []
-  state = 0
-  sequence = { name: '_orez___zero_watermark', last_value: 1, is_called: 0 }
-
-  exec(sql: string, ...params: unknown[]) {
-    if (sql.startsWith('CREATE TABLE IF NOT EXISTS')) return new FakeResult()
-
-    if (sql.startsWith('SELECT last_value FROM "_zero_change_state"')) {
-      return new FakeResult([{ last_value: this.state }])
-    }
-
-    if (sql.startsWith('INSERT OR IGNORE INTO "_zero_change_state"')) {
-      return new FakeResult()
-    }
-
-    if (sql.startsWith('UPDATE "_zero_change_state" SET last_value = ?')) {
-      this.state = Number(params[0])
-      return new FakeResult()
-    }
-
-    if (
-      sql.startsWith('SELECT COALESCE(MAX(watermark), 0) AS watermark FROM _zero_changes')
-    ) {
-      const watermark = Math.max(0, ...this.changes.map((change) => change.watermark))
-      return new FakeResult([{ watermark }])
-    }
-
-    if (sql.includes('sqlite_master') && sql.includes('%zero_watermark%')) {
-      return new FakeResult([{ name: this.sequence.name }])
-    }
-
-    if (sql.startsWith('SELECT last_value, is_called FROM "_orez___zero_watermark"')) {
-      return new FakeResult([
-        {
-          last_value: this.sequence.last_value,
-          is_called: this.sequence.is_called,
-        },
-      ])
-    }
-
-    if (sql.startsWith('INSERT OR IGNORE INTO "_orez___zero_watermark"')) {
-      return new FakeResult()
-    }
-
-    if (sql.startsWith('UPDATE "_orez___zero_watermark" SET last_value = ?')) {
-      this.sequence.last_value = Number(params[0])
-      this.sequence.is_called = 1
-      return new FakeResult()
-    }
-
-    throw new Error(`unexpected fake sql: ${sql}`)
-  }
-}
-
-describe('DurableWatermarkState', () => {
-  it('does not reuse watermarks after consumed changes are purged', () => {
-    const sql = new FakeSql()
-    const watermarks = new DurableWatermarkState(sql)
-
-    expect(watermarks.current()).toBe(0)
-
-    const first = watermarks.next()
-    sql.changes.push({ watermark: first })
-    watermarks.mark(first)
-    expect(first).toBe(1)
-
-    sql.changes = []
-
-    const second = watermarks.next()
-    sql.changes.push({ watermark: second })
-    watermarks.mark(second)
-
-    expect(second).toBe(2)
-    expect(sql.sequence).toMatchObject({ last_value: 2, is_called: 1 })
-  })
-
-  it('synchronizes from existing change rows and sequence state', () => {
-    const sql = new FakeSql()
-    sql.changes.push({ watermark: 7 })
-    const watermarks = new DurableWatermarkState(sql)
-
-    expect(watermarks.current()).toBe(7)
-    expect(sql.state).toBe(7)
-    expect(sql.sequence).toMatchObject({ last_value: 7, is_called: 1 })
-  })
-})

package/src/cf-do/watermark.ts

@@ -1,118 +0,0 @@
-export interface DurableSqlResult {
-  one(): Record<string, unknown> | undefined
-  toArray(): Array<Record<string, unknown>>
-}
-
-export interface DurableSqlStorage {
-  exec(sql: string, ...params: unknown[]): DurableSqlResult
-}
-
-const WATERMARK_STATE_TABLE = '_zero_change_state'
-
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`
-}
-
-function finitePositiveNumber(value: unknown): number {
-  const number = Number(value ?? 0)
-  return Number.isFinite(number) && number > 0 ? number : 0
-}
-
-export class DurableWatermarkState {
-  constructor(private readonly sql: DurableSqlStorage) {}
-
-  ensureTables(): void {
-    this.sql.exec(
-      "CREATE TABLE IF NOT EXISTS _zero_changes (watermark INTEGER PRIMARY KEY AUTOINCREMENT, table_name TEXT NOT NULL, op TEXT NOT NULL CHECK (op IN ('INSERT', 'UPDATE', 'DELETE')), row_data TEXT, old_data TEXT, created_at INTEGER NOT NULL DEFAULT (unixepoch()))"
-    )
-    this.sql.exec(
-      `CREATE TABLE IF NOT EXISTS ${quoteIdent(WATERMARK_STATE_TABLE)} (id INTEGER PRIMARY KEY CHECK (id = 1), last_value INTEGER NOT NULL DEFAULT 0)`
-    )
-    this.setWatermarkState(this.watermarkState())
-  }
-
-  next(): number {
-    return this.current() + 1
-  }
-
-  mark(watermark: number): void {
-    this.setWatermarkState(watermark)
-    this.updateWatermarkSequences(watermark)
-  }
-
-  current(): number {
-    this.ensureTables()
-    const state = this.watermarkState()
-    const row = this.sql
-      .exec('SELECT COALESCE(MAX(watermark), 0) AS watermark FROM _zero_changes')
-      .one() as { watermark?: unknown } | undefined
-    const tableWatermark = finitePositiveNumber(row?.watermark)
-    const sequenceWatermark = this.watermarkSequenceValue()
-    const watermark = Math.max(state, tableWatermark, sequenceWatermark)
-    if (watermark > state) this.setWatermarkState(watermark)
-    if (watermark > sequenceWatermark) this.updateWatermarkSequences(watermark)
-    return watermark
-  }
-
-  private watermarkState(): number {
-    try {
-      const table = quoteIdent(WATERMARK_STATE_TABLE)
-      const row = this.sql.exec(`SELECT last_value FROM ${table} WHERE id = 1`).one() as
-        | { last_value?: unknown }
-        | undefined
-      return finitePositiveNumber(row?.last_value)
-    } catch {
-      return 0
-    }
-  }
-
-  private setWatermarkState(watermark: number): void {
-    const table = quoteIdent(WATERMARK_STATE_TABLE)
-    this.sql.exec(`INSERT OR IGNORE INTO ${table} (id, last_value) VALUES (1, 0)`)
-    this.sql.exec(`UPDATE ${table} SET last_value = ? WHERE id = 1`, watermark)
-  }
-
-  private watermarkSequenceValue(): number {
-    let watermark = 0
-    for (const name of this.watermarkSequenceTables()) {
-      try {
-        const row = this.sql
-          .exec(`SELECT last_value, is_called FROM ${quoteIdent(name)} WHERE dummy = 1`)
-          .one() as { last_value?: unknown; is_called?: unknown } | undefined
-        if (!row || !row.is_called) continue
-        watermark = Math.max(watermark, finitePositiveNumber(row.last_value))
-      } catch {
-        /* not an orez sequence table */
-      }
-    }
-    return watermark
-  }
-
-  private watermarkSequenceTables(): string[] {
-    return this.sql
-      .exec(
-        "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%zero_watermark%'"
-      )
-      .toArray()
-      .map((row) => String(row.name || ''))
-      .filter(Boolean)
-  }
-
-  private updateWatermarkSequences(watermark: number): void {
-    for (const name of this.watermarkSequenceTables()) {
-      const table = quoteIdent(name)
-      try {
-        this.sql.exec(
-          `INSERT OR IGNORE INTO ${table} (dummy, last_value, is_called) VALUES (1, ?, 1)`,
-          watermark
-        )
-        this.sql.exec(
-          `UPDATE ${table} SET last_value = ?, is_called = 1 WHERE dummy = 1`,
-          watermark
-        )
-      } catch {
-        /* not an orez sequence table */
-      }
-    }
-  }
-}