orez 0.2.27 → 0.2.29

package/src/cf-do/wrangler.toml

@@ -1,11 +0,0 @@
-name = "zero-do"
-main = "worker.ts"
-compatibility_date = "2025-04-01"
-
-[[durable_objects.bindings]]
-name = "ZERO_DO"
-class_name = "ZeroDO"
-
-[[migrations]]
-tag = "v1"
-new_sqlite_classes = ["ZeroDO"]

package/src/cf-pglite/README.md

@@ -1,19 +0,0 @@
-# CF-Compatible PGlite Build
-
-PGlite compiled without `-sMAIN_MODULE=2` and `-sALLOW_TABLE_GROWTH`
-for Cloudflare Workers compatibility.
-
-Key differences from standard PGlite:
-
-- No dynamic linking (extensions must be statically linked)
-- No `addFunction`/`removeFunction` (no runtime WASM compilation)
-- `ENVIRONMENT=web,worker` only (no node — avoids require("fs"))
-- No side modules (no dlopen/dlsym)
-
-Files:
-
-- `pglite.wasm` — CF-compatible postgres WASM binary
-- `pglite.data` — filesystem bundle (postgres data directory)
-- `pglite.js` — Emscripten JS glue
-
-Build: `cd postgres-pglite && docker run ... ./build-pglite-cf.sh`

package/src/change-tracking.ts

@@ -1,25 +0,0 @@
-/**
- * orez/change-tracking — standalone entrypoint for installing and reading
- * the `_orez` change tracking schema against a postgres-compatible database.
- *
- * this module intentionally has no transitive dependency on pglite-manager
- * or any other server-only orez module. it talks to the database through
- * the minimal `ChangeTrackingDb` structural interface (`exec` + `query`),
- * so it can be imported anywhere a sql executor exists — embedded PGlite,
- * a worker proxy, tests, or an external host.
- *
- * usage:
- *   import { installChangeTracking } from 'orez/change-tracking'
- *   await installChangeTracking(db)
- */
-
-export {
-  installChangeTracking,
-  installTriggersOnShardTables,
-  resetShardSchemaCache,
-  getChangesSince,
-  getCurrentWatermark,
-  purgeConsumedChanges,
-} from './replication/change-tracker.js'
-
-export type { ChangeRecord, ChangeTrackingDb } from './replication/change-tracker.js'

package/src/child-process.test.ts

@@ -1,147 +0,0 @@
-import { spawn, type ChildProcess } from 'node:child_process'
-
-import { afterEach, describe, expect, it } from 'vitest'
-
-import {
-  isChildProcessRunning,
-  isPidRunning,
-  killProcessTree,
-  waitForChildProcessExit,
-} from './child-process.js'
-
-const spawned = new Set<ChildProcess>()
-
-function track(child: ChildProcess): ChildProcess {
-  spawned.add(child)
-  child.once('close', () => spawned.delete(child))
-  return child
-}
-
-function pidExists(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (err: any) {
-    if (err?.code === 'ESRCH') return false
-    throw err
-  }
-}
-
-async function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean> {
-  const start = Date.now()
-  while (Date.now() - start < timeoutMs) {
-    if (!pidExists(pid)) return true
-    await new Promise((resolve) => setTimeout(resolve, 25))
-  }
-  return !pidExists(pid)
-}
-
-afterEach(async () => {
-  for (const child of spawned) {
-    if (!isChildProcessRunning(child)) continue
-    if (child.pid) killProcessTree(child.pid, 'SIGKILL')
-    else child.kill('SIGKILL')
-    await waitForChildProcessExit(child, 1000)
-  }
-  spawned.clear()
-})
-
-describe('child process helpers', () => {
-  it('tracks whether a pid is still alive', async () => {
-    const child = track(
-      spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], {
-        stdio: 'ignore',
-      })
-    )
-
-    expect(isPidRunning(child.pid)).toBe(true)
-
-    child.kill('SIGKILL')
-    await expect(waitForChildProcessExit(child, 2000)).resolves.toBe(true)
-    expect(isPidRunning(child.pid)).toBe(false)
-  })
-
-  it('does not confuse "signal sent" with "process exited"', async () => {
-    const child = track(
-      spawn(
-        process.execPath,
-        [
-          '-e',
-          "process.on('SIGTERM', () => {}); console.log('ready'); setInterval(() => {}, 1000)",
-        ],
-        { stdio: ['ignore', 'pipe', 'ignore'] }
-      )
-    )
-
-    await new Promise<void>((resolve, reject) => {
-      let output = ''
-
-      const onData = (chunk: Buffer) => {
-        output += chunk.toString()
-        if (!output.includes('ready')) return
-        child.stdout?.off('data', onData)
-        resolve()
-      }
-
-      child.stdout?.on('data', onData)
-      child.once('error', reject)
-      child.once('close', () =>
-        reject(new Error('child exited before signaling readiness'))
-      )
-    })
-
-    child.kill('SIGTERM')
-
-    expect(child.killed).toBe(true)
-    expect(isChildProcessRunning(child)).toBe(true)
-    await expect(waitForChildProcessExit(child, 100)).resolves.toBe(false)
-
-    child.kill('SIGKILL')
-    await expect(waitForChildProcessExit(child, 2000)).resolves.toBe(true)
-    expect(isChildProcessRunning(child)).toBe(false)
-  })
-
-  it('kills a parent process and its descendants', async () => {
-    const parent = track(
-      spawn(
-        process.execPath,
-        [
-          '-e',
-          [
-            "const { spawn } = require('node:child_process')",
-            "const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' })",
-            'console.log(child.pid)',
-            'setInterval(() => {}, 1000)',
-          ].join('; '),
-        ],
-        { stdio: ['ignore', 'pipe', 'ignore'] }
-      )
-    )
-
-    const childPid = await new Promise<number>((resolve, reject) => {
-      let output = ''
-
-      const onData = (chunk: Buffer) => {
-        output += chunk.toString()
-        if (!output.includes('\n')) return
-
-        const value = Number.parseInt(output.split(/\r?\n/, 1)[0]!.trim(), 10)
-        if (Number.isInteger(value) && value > 0) {
-          parent.stdout?.off('data', onData)
-          resolve(value)
-        }
-      }
-
-      parent.stdout?.on('data', onData)
-      parent.once('error', reject)
-      parent.once('close', () =>
-        reject(new Error('parent exited before reporting child pid'))
-      )
-    })
-
-    killProcessTree(parent.pid!, 'SIGKILL')
-
-    await expect(waitForChildProcessExit(parent, 2000)).resolves.toBe(true)
-    await expect(waitForPidExit(childPid, 2000)).resolves.toBe(true)
-  })
-})

package/src/child-process.ts

@@ -1,90 +0,0 @@
-import { spawnSync, type ChildProcess } from 'node:child_process'
-
-export function isPidRunning(pid: number | null | undefined): pid is number {
-  if (!Number.isInteger(pid) || (pid as number) <= 0) return false
-
-  try {
-    process.kill(pid as number, 0)
-    return true
-  } catch (err: any) {
-    if (err?.code === 'ESRCH') return false
-    if (err?.code === 'EPERM') return true
-    throw err
-  }
-}
-
-export function isChildProcessRunning(
-  child: ChildProcess | null | undefined
-): child is ChildProcess {
-  if (!child) return false
-  return child.exitCode === null && child.signalCode === null
-}
-
-export async function waitForChildProcessExit(
-  child: ChildProcess,
-  timeoutMs: number
-): Promise<boolean> {
-  if (!isChildProcessRunning(child)) return true
-
-  return await new Promise<boolean>((resolve) => {
-    let settled = false
-
-    const finish = (exited: boolean) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      child.off('exit', onExit)
-      child.off('close', onClose)
-      resolve(exited || !isChildProcessRunning(child))
-    }
-
-    const onExit = () => finish(true)
-    const onClose = () => finish(true)
-
-    const timer = setTimeout(() => finish(false), timeoutMs)
-
-    child.once('exit', onExit)
-    child.once('close', onClose)
-  })
-}
-
-function listChildPids(pid: number): number[] {
-  if (process.platform === 'win32') return []
-
-  const result = spawnSync('pgrep', ['-P', String(pid)], {
-    encoding: 'utf8',
-    env: process.env,
-  })
-
-  if (result.status !== 0 || !result.stdout) return []
-
-  return result.stdout
-    .split(/\s+/)
-    .map((value) => Number(value.trim()))
-    .filter((value) => Number.isInteger(value) && value > 0)
-}
-
-export function killProcessTree(pid: number, signal: NodeJS.Signals | number): void {
-  const seen = new Set<number>()
-  const stack = [pid]
-  const order: number[] = []
-
-  while (stack.length > 0) {
-    const current = stack.pop()!
-    if (seen.has(current)) continue
-    seen.add(current)
-    order.push(current)
-
-    for (const childPid of listChildPids(current)) {
-      if (!seen.has(childPid)) stack.push(childPid)
-    }
-  }
-
-  for (const current of order.reverse()) {
-    try {
-      process.kill(current, signal)
-    } catch (err: any) {
-      if (err?.code !== 'ESRCH') throw err
-    }
-  }
-}

package/src/cli-entry.ts

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-
-// by default runs cli.js in-process. when --bump-heap (or OREZ_BUMP_HEAP=1)
-// is set, re-execs with --max-old-space-size at ~50% of system memory —
-// needed for pglite wasm workloads. default off since memory usage was reduced.
-
-import { spawn } from 'node:child_process'
-import { totalmem } from 'node:os'
-import { resolve, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { orezTitle } from './process-title.js'
-
-const currentOpts = process.env.NODE_OPTIONS || ''
-const bumpHeapRequested =
-  process.argv.includes('--bump-heap') ||
-  process.env.OREZ_BUMP_HEAP === '1' ||
-  process.env.OREZ_BUMP_HEAP === 'true'
-
-const willRespawn =
-  bumpHeapRequested &&
-  !currentOpts.includes('--max-old-space-size') &&
-  !process.env.__OREZ_SPAWNED
-
-// label the wrapper distinctly so it's not confused with the real orez process
-process.title = willRespawn ? orezTitle('orez [wrapper]') : orezTitle()
-
-if (willRespawn) {
-  const memMB = Math.round(totalmem() / 1024 / 1024)
-  const heapMB = Math.max(4096, Math.round(memMB * 0.5))
-  const cliPath = resolve(dirname(fileURLToPath(import.meta.url)), 'cli.js')
-
-  // enable --experimental-strip-types so orez.config.ts works on Node 22.6+
-  // (Node 23.6+ has it by default; harmless if already enabled)
-  let nodeOpts = `--max-old-space-size=${heapMB} ${currentOpts}`.trim()
-  if (!nodeOpts.includes('--experimental-strip-types')) {
-    const [major, minor] = process.versions.node.split('.').map(Number)
-    if (major > 22 || (major === 22 && minor >= 6)) {
-      nodeOpts = `--experimental-strip-types ${nodeOpts}`
-    }
-  }
-
-  // strip --bump-heap from argv so cli.ts doesn't see it as an unknown flag
-  const childArgs = process.argv.slice(2).filter((a) => a !== '--bump-heap')
-
-  const child = spawn(process.execPath, [cliPath, ...childArgs], {
-    env: {
-      ...process.env,
-      NODE_OPTIONS: nodeOpts,
-      __OREZ_SPAWNED: '1',
-    },
-    stdio: 'inherit',
-  })
-
-  // forward signals to child
-  for (const sig of ['SIGINT', 'SIGTERM'] as const) {
-    process.on(sig, () => child.kill(sig))
-  }
-
-  child.on('exit', (code, signal) => {
-    if (signal) process.kill(process.pid, signal)
-    else process.exit(code ?? 1)
-  })
-} else {
-  // run cli directly — no heap bump, no wrapper process
-  // strip --bump-heap in case it was passed but we're already the spawned child
-  if (process.argv.includes('--bump-heap')) {
-    process.argv = process.argv.filter((a) => a !== '--bump-heap')
-  }
-  const [{ runMain }, { main }] = await Promise.all([import('citty'), import('./cli.js')])
-  runMain(main)
-}

package/src/cli.test.ts

@@ -1,40 +0,0 @@
-import { spawn } from 'node:child_process'
-import { resolve } from 'node:path'
-
-import { describe, it, expect } from 'vitest'
-
-function runCli(
-  args: string[]
-): Promise<{ stdout: string; stderr: string; code: number }> {
-  return new Promise((res) => {
-    // cli-entry.js is the actual entry (cli.js only exports `main`; runMain
-    // is invoked from cli-entry).
-    const child = spawn('bun', [resolve('dist/cli-entry.js'), ...args], {
-      timeout: 10_000,
-      env: { ...process.env, NODE_ENV: 'test' },
-    })
-    let stdout = ''
-    let stderr = ''
-    child.stdout?.on('data', (d: Buffer) => (stdout += d.toString()))
-    child.stderr?.on('data', (d: Buffer) => (stderr += d.toString()))
-    child.on('close', (code) => res({ stdout, stderr, code: code ?? 1 }))
-  })
-}
-
-describe('cli', () => {
-  it('shows help with --help', async () => {
-    const { stdout, stderr } = await runCli(['--help'])
-    const output = stdout + stderr
-    expect(output).toContain('orez')
-    expect(output).toContain('--pg-port')
-    expect(output).toContain('--zero-port')
-    expect(output).toContain('--skip-zero-cache')
-  })
-
-  it('s3 subcommand shows help', async () => {
-    const { stdout, stderr } = await runCli(['s3', '--help'])
-    const output = stdout + stderr
-    expect(output).toContain('--port')
-    expect(output).toContain('--data-dir')
-  })
-})