orez 0.2.27 → 0.2.30

package/src/admin/admin-data.test.ts

@@ -1,348 +0,0 @@
-/**
- * integration tests for the admin data explorer endpoints.
- *
- * spins up pglite instances + admin server directly (no zero-cache)
- * and exercises the /api/db/* and /api/sqlite/* endpoints.
- */
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { PGlite } from '@electric-sql/pglite'
-import { afterAll, beforeAll, describe, expect, test } from 'vitest'
-
-import { startAdminServer } from './server.js'
-
-import type { ZeroLiteConfig } from '../config.js'
-import type { LogStore } from './log-store.js'
-import type { Server } from 'node:http'
-
-const TEST_PORT = 16400 + Math.floor(Math.random() * 500)
-const DATA_DIR = `.orez-admin-data-test-${Date.now()}`
-
-function stubLogStore(): LogStore {
-  const entries: any[] = []
-  return {
-    push() {},
-    query() {
-      return { entries, cursor: 0 }
-    },
-    getAll() {
-      return entries
-    },
-    clear() {
-      entries.length = 0
-    },
-  }
-}
-
-function stubConfig(): ZeroLiteConfig {
-  return {
-    dataDir: resolve(DATA_DIR),
-    pgPort: 0,
-    zeroPort: 0,
-    adminPort: TEST_PORT,
-    pgUser: 'test',
-    pgPassword: 'test',
-    migrationsDir: '',
-    seedFile: '',
-    skipZeroCache: true,
-    disableWasmSqlite: false,
-    forceWasmSqlite: false,
-    useWorkerThreads: false,
-    singleDb: false,
-    readReplicas: 0,
-    logLevel: 'info',
-    pgliteOptions: {},
-    checkpointIntervalMs: 0,
-    maxLogFileSize: 0,
-    disableDiskLogs: true,
-  }
-}
-
-describe('admin data explorer', { timeout: 60_000 }, () => {
-  let server: Server
-  let postgres: PGlite
-  let cvr: PGlite
-  let cdb: PGlite
-  const base = `http://127.0.0.1:${TEST_PORT}`
-
-  beforeAll(async () => {
-    mkdirSync(DATA_DIR, { recursive: true })
-
-    postgres = new PGlite()
-    cvr = new PGlite()
-    cdb = new PGlite()
-    await Promise.all([postgres.waitReady, cvr.waitReady, cdb.waitReady])
-
-    // create test tables
-    await postgres.exec(`
-      CREATE TABLE public.users (
-        id serial PRIMARY KEY,
-        name text NOT NULL,
-        email text,
-        active boolean DEFAULT true
-      );
-      INSERT INTO public.users (name, email) VALUES
-        ('alice', 'alice@test.com'),
-        ('bob', 'bob@test.com'),
-        ('charlie', 'charlie@test.com');
-    `)
-
-    await postgres.exec(`
-      CREATE TABLE public.posts (
-        id serial PRIMARY KEY,
-        user_id int REFERENCES users(id),
-        title text NOT NULL,
-        body text
-      );
-      INSERT INTO public.posts (user_id, title, body) VALUES
-        (1, 'hello world', 'first post'),
-        (1, 'second post', 'more content'),
-        (2, 'bob writes', NULL);
-    `)
-
-    server = await startAdminServer({
-      port: TEST_PORT,
-      logStore: stubLogStore(),
-      config: stubConfig(),
-      zeroEnv: {},
-      startTime: Date.now(),
-      db: { postgres, cvr, cdb, postgresReplicas: [] } as any,
-    })
-  })
-
-  afterAll(async () => {
-    server?.close()
-    await Promise.all([postgres?.close(), cvr?.close(), cdb?.close()])
-    rmSync(DATA_DIR, { recursive: true, force: true })
-  })
-
-  // --- html ---
-
-  test('GET / serves html', async () => {
-    const res = await fetch(`${base}/`)
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-type')).toContain('text/html')
-    const html = await res.text()
-    expect(html).toContain('oreZ admin')
-    expect(html).toContain('data-db="sqlite"')
-  })
-
-  test('GET /data serves html', async () => {
-    const res = await fetch(`${base}/data`)
-    expect(res.status).toBe(200)
-    const html = await res.text()
-    expect(html).toContain('sql-editor')
-  })
-
-  // --- /api/db/tables ---
-
-  test('lists postgres tables', async () => {
-    const res = await fetch(`${base}/api/db/tables?db=postgres`)
-    expect(res.status).toBe(200)
-    const data = await res.json()
-    expect(data.tables).toBeDefined()
-    const names = data.tables.map((t: any) => t.table_name)
-    expect(names).toContain('users')
-    expect(names).toContain('posts')
-  })
-
-  test('lists cvr tables (empty)', async () => {
-    const res = await fetch(`${base}/api/db/tables?db=cvr`)
-    expect(res.status).toBe(200)
-    const data = await res.json()
-    expect(data.tables).toBeDefined()
-    expect(data.tables.length).toBe(0)
-  })
-
-  test('rejects unknown db name', async () => {
-    const res = await fetch(`${base}/api/db/tables?db=nope`)
-    expect(res.status).toBe(400)
-    const data = await res.json()
-    expect(data.error).toContain('unknown db')
-  })
-
-  // --- /api/db/table-data ---
-
-  test('browses table data', async () => {
-    const res = await fetch(`${base}/api/db/table-data?db=postgres&table=users`)
-    expect(res.status).toBe(200)
-    const data = await res.json()
-    expect(data.columns).toBeDefined()
-    expect(data.columns.length).toBeGreaterThanOrEqual(4)
-    expect(data.rows.length).toBe(3)
-    expect(data.total).toBe(3)
-    // check column metadata
-    const colNames = data.columns.map((c: any) => c.name)
-    expect(colNames).toContain('id')
-    expect(colNames).toContain('name')
-    expect(colNames).toContain('email')
-  })
-
-  test('table-data supports search', async () => {
-    const res = await fetch(
-      `${base}/api/db/table-data?db=postgres&table=users&search=alice`
-    )
-    const data = await res.json()
-    expect(data.rows.length).toBe(1)
-    expect(data.rows[0].name).toBe('alice')
-    expect(data.total).toBe(1)
-  })
-
-  test('table-data supports pagination', async () => {
-    const res = await fetch(
-      `${base}/api/db/table-data?db=postgres&table=users&limit=2&offset=0`
-    )
-    const data = await res.json()
-    expect(data.rows.length).toBe(2)
-    expect(data.total).toBe(3)
-
-    const page2 = await fetch(
-      `${base}/api/db/table-data?db=postgres&table=users&limit=2&offset=2`
-    )
-    const data2 = await page2.json()
-    expect(data2.rows.length).toBe(1)
-  })
-
-  test('table-data with schema-qualified name', async () => {
-    const res = await fetch(`${base}/api/db/table-data?db=postgres&table=public.posts`)
-    const data = await res.json()
-    expect(data.rows.length).toBe(3)
-    // check NULL values come through
-    const bobPost = data.rows.find((r: any) => r.title === 'bob writes')
-    expect(bobPost).toBeDefined()
-    expect(bobPost.body).toBeNull()
-  })
-
-  test('table-data missing table param', async () => {
-    const res = await fetch(`${base}/api/db/table-data?db=postgres`)
-    expect(res.status).toBe(400)
-    const data = await res.json()
-    expect(data.error).toContain('missing table')
-  })
-
-  // --- /api/db/query ---
-
-  test('runs arbitrary SQL', async () => {
-    const res = await fetch(`${base}/api/db/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        db: 'postgres',
-        sql: 'SELECT name, email FROM users ORDER BY name',
-      }),
-    })
-    expect(res.status).toBe(200)
-    const data = await res.json()
-    expect(data.fields).toEqual(['name', 'email'])
-    expect(data.rowCount).toBe(3)
-    expect(data.rows[0].name).toBe('alice')
-    expect(data.durationMs).toBeGreaterThanOrEqual(0)
-  })
-
-  test('returns error for bad SQL', async () => {
-    const res = await fetch(`${base}/api/db/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ db: 'postgres', sql: 'SELECT * FROM nonexistent' }),
-    })
-    expect(res.status).toBe(400)
-    const data = await res.json()
-    expect(data.error).toBeTruthy()
-  })
-
-  test('query with joins', async () => {
-    const res = await fetch(`${base}/api/db/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        db: 'postgres',
-        sql: `SELECT u.name, p.title FROM users u JOIN posts p ON p.user_id = u.id ORDER BY p.id`,
-      }),
-    })
-    const data = await res.json()
-    expect(data.rowCount).toBe(3)
-    expect(data.fields).toEqual(['name', 'title'])
-  })
-
-  test('query missing sql', async () => {
-    const res = await fetch(`${base}/api/db/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ db: 'postgres' }),
-    })
-    expect(res.status).toBe(400)
-    const data = await res.json()
-    expect(data.error).toContain('missing sql')
-  })
-
-  // --- sqlite ---
-
-  test('sqlite tables returns 404 when no replica', async () => {
-    const res = await fetch(`${base}/api/sqlite/tables`)
-    expect(res.status).toBe(404)
-    const data = await res.json()
-    expect(data.error).toContain('not found')
-  })
-
-  test('sqlite endpoints work when replica file exists', async () => {
-    // create a fake zero-replica.db using bedrock-sqlite
-    // @ts-expect-error - CJS module
-    const bedrock: any = await import('bedrock-sqlite')
-    const Ctor = bedrock.Database || bedrock.default?.Database || bedrock.default
-    const replicaPath = resolve(DATA_DIR, 'zero-replica.db')
-    const setupDb = new Ctor(replicaPath)
-    setupDb.exec(`
-      CREATE TABLE widgets (
-        id INTEGER PRIMARY KEY,
-        label TEXT NOT NULL,
-        count INTEGER
-      );
-      INSERT INTO widgets (label, count) VALUES
-        ('alpha', 1),
-        ('beta', 2),
-        ('gamma', 3);
-    `)
-    setupDb.close()
-
-    // list tables
-    const tablesRes = await fetch(`${base}/api/sqlite/tables`)
-    expect(tablesRes.status).toBe(200)
-    const tables = await tablesRes.json()
-    expect(tables.tables.some((t: any) => t.name === 'widgets')).toBe(true)
-
-    // browse table data
-    const browseRes = await fetch(`${base}/api/sqlite/table-data?table=widgets`)
-    expect(browseRes.status).toBe(200)
-    const browse = await browseRes.json()
-    expect(browse.rows.length).toBe(3)
-    expect(browse.total).toBe(3)
-
-    // search
-    const searchRes = await fetch(
-      `${base}/api/sqlite/table-data?table=widgets&search=beta`
-    )
-    const search = await searchRes.json()
-    expect(search.rows.length).toBe(1)
-    expect(search.rows[0].label).toBe('beta')
-
-    // raw query
-    const queryRes = await fetch(`${base}/api/sqlite/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sql: 'SELECT count(*) as c FROM widgets' }),
-    })
-    expect(queryRes.status).toBe(200)
-    const q = await queryRes.json()
-    expect(q.rows[0].c).toBe(3)
-    expect(q.fields).toContain('c')
-  })
-
-  // --- CORS ---
-
-  test('OPTIONS returns CORS headers', async () => {
-    const res = await fetch(`${base}/api/db/tables`, { method: 'OPTIONS' })
-    expect(res.status).toBe(200)
-    expect(res.headers.get('access-control-allow-origin')).toBe('*')
-  })
-})

package/src/admin/http-proxy.ts

@@ -1,252 +0,0 @@
-import { createServer, connect, type Socket, type Server } from 'node:net'
-
-import type { ZeroLiteConfig } from '../config.js'
-import type { LogStore } from './log-store.js'
-
-export interface HttpLogEntry {
-  id: number
-  ts: number
-  method: string
-  path: string
-  status: number
-  duration: number
-  reqSize: number
-  resSize: number
-  reqHeaders: Record<string, string>
-  resHeaders: Record<string, string>
-}
-
-export interface HttpLogStore {
-  push(entry: Omit<HttpLogEntry, 'id'>): void
-  query(opts?: { since?: number; path?: string }): {
-    entries: HttpLogEntry[]
-    cursor: number
-  }
-  clear(): void
-}
-
-const MAX_ENTRIES = 10_000
-const TRIM_BATCH = Math.floor(MAX_ENTRIES * 0.1)
-
-export function createHttpLogStore(): HttpLogStore {
-  const entries: HttpLogEntry[] = []
-  let nextId = 1
-
-  function push(entry: Omit<HttpLogEntry, 'id'>) {
-    const full: HttpLogEntry = { ...entry, id: nextId++ }
-    entries.push(full)
-    if (entries.length > MAX_ENTRIES + TRIM_BATCH) {
-      entries.splice(0, entries.length - MAX_ENTRIES)
-    }
-  }
-
-  function query(opts?: { since?: number; path?: string }) {
-    let result: HttpLogEntry[] = entries
-    if (opts?.since) {
-      const since = opts.since
-      let lo = 0
-      let hi = result.length
-      while (lo < hi) {
-        const mid = (lo + hi) >>> 1
-        if (result[mid].id <= since) lo = mid + 1
-        else hi = mid
-      }
-      result = result.slice(lo)
-    }
-    if (opts?.path) {
-      const p = opts.path
-      result = result.filter((e) => e.path.includes(p))
-    }
-    return {
-      entries: result,
-      cursor: entries.length > 0 ? entries[entries.length - 1].id : 0,
-    }
-  }
-
-  function clear() {
-    entries.length = 0
-  }
-
-  return { push, query, clear }
-}
-
-function parseHeaders(raw: string): Record<string, string> {
-  const out: Record<string, string> = {}
-  const lines = raw.split('\r\n')
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i] === '') break
-    const idx = lines[i].indexOf(': ')
-    if (idx > 0) {
-      out[lines[i].slice(0, idx).toLowerCase()] = lines[i].slice(idx + 2)
-    }
-  }
-  return out
-}
-
-// public API routes served directly by the proxy (read-only, no auth)
-// these are available at the sprite's public URL under /__orez/
-const CORS =
-  'Access-Control-Allow-Origin: *\r\nAccess-Control-Allow-Methods: GET, OPTIONS\r\nAccess-Control-Allow-Headers: *'
-
-function httpResponse(
-  status: number,
-  body: string,
-  contentType = 'application/json'
-): Buffer {
-  const headers = `HTTP/1.1 ${status} ${status === 200 ? 'OK' : 'Error'}\r\nContent-Type: ${contentType}\r\nContent-Length: ${Buffer.byteLength(body)}\r\n${CORS}\r\nConnection: close\r\n\r\n`
-  return Buffer.from(headers + body)
-}
-
-function handleOrezRoute(
-  path: string,
-  method: string,
-  logStore?: LogStore,
-  config?: ZeroLiteConfig,
-  startTime?: number
-): Buffer | null {
-  if (method === 'OPTIONS') {
-    return httpResponse(200, '')
-  }
-
-  if (method !== 'GET') {
-    return httpResponse(405, JSON.stringify({ error: 'method not allowed' }))
-  }
-
-  const url = new URL(path, 'http://localhost')
-  const route = url.pathname.replace(/^\/__orez/, '')
-
-  if (route === '/api/logs' && logStore) {
-    const source = url.searchParams.get('source') || undefined
-    const level = url.searchParams.get('level') || undefined
-    const sinceStr = url.searchParams.get('since')
-    const limitStr = url.searchParams.get('limit')
-    const since = sinceStr ? Number(sinceStr) : undefined
-    const limit = limitStr ? Number(limitStr) : undefined
-    return httpResponse(
-      200,
-      JSON.stringify(logStore.query({ source, level, since, limit }))
-    )
-  }
-
-  if (route === '/api/status' && config) {
-    return httpResponse(
-      200,
-      JSON.stringify({
-        uptime: Math.floor((Date.now() - (startTime || Date.now())) / 1000),
-        logLevel: config.logLevel,
-        sqliteMode: config.disableWasmSqlite ? 'native' : 'wasm',
-      })
-    )
-  }
-
-  return httpResponse(404, JSON.stringify({ error: 'not found' }))
-}
-
-// raw tcp proxy that avoids bun's broken node:http upgrade handling.
-// bun silently drops socket.write() data in http server upgrade events,
-// so we do everything at the net level instead.
-//
-// intercepts /__orez/* paths to serve read-only API (logs, status)
-// directly without forwarding to zero-cache.
-export function startHttpProxy(opts: {
-  listenPort: number
-  targetPort: number
-  httpLog: HttpLogStore
-  logStore?: LogStore
-  config?: ZeroLiteConfig
-  startTime?: number
-}): Promise<Server> {
-  const { listenPort, targetPort, httpLog, logStore, config, startTime } = opts
-
-  const server = createServer((client: Socket) => {
-    const start = Date.now()
-
-    let logged = false
-    let reqMethod = ''
-    let reqPath = ''
-    let reqHeaders: Record<string, string> = {}
-
-    // intercept first client chunk to extract request info
-    client.once('data', (chunk: Buffer) => {
-      const str = chunk.toString('utf8')
-      const firstLine = str.split('\r\n')[0] || ''
-      const parts = firstLine.split(' ')
-      reqMethod = parts[0] || 'GET'
-      reqPath = parts[1] || '/'
-      reqHeaders = parseHeaders(str)
-
-      // intercept /__orez/ paths — serve directly, don't forward to zero-cache
-      // check char 0 first to skip the startsWith on hot-path sync/ws traffic
-      if (
-        reqPath.charCodeAt(0) === 47 &&
-        reqPath.charCodeAt(1) === 95 &&
-        reqPath.startsWith('/__orez/')
-      ) {
-        const response = handleOrezRoute(reqPath, reqMethod, logStore, config, startTime)
-        if (response) {
-          client.write(response)
-          client.end()
-          httpLog.push({
-            ts: start,
-            method: reqMethod,
-            path: reqPath,
-            status: 200,
-            duration: Date.now() - start,
-            reqSize: chunk.length,
-            resSize: response.length,
-            reqHeaders,
-            resHeaders: {},
-          })
-          return
-        }
-      }
-
-      // forward to zero-cache
-      const target = connect(targetPort, '127.0.0.1')
-
-      target.setKeepAlive(true, 30_000)
-      target.setTimeout(0)
-      client.setKeepAlive(true, 30_000)
-      client.setTimeout(0)
-
-      target.write(chunk)
-      client.pipe(target)
-
-      // intercept first target chunk to extract response info and log
-      target.once('data', (resChunk: Buffer) => {
-        const resStr = resChunk.toString('utf8')
-        const resFirstLine = resStr.split('\r\n')[0] || ''
-        const status = parseInt(resFirstLine.split(' ')[1]) || 0
-        const resHeaders = parseHeaders(resStr)
-
-        if (!logged) {
-          logged = true
-          httpLog.push({
-            ts: start,
-            method: status === 101 ? 'WS' : reqMethod,
-            path: reqPath,
-            status,
-            duration: Date.now() - start,
-            reqSize: 0,
-            resSize: resChunk.length,
-            reqHeaders,
-            resHeaders,
-          })
-        }
-
-        client.write(resChunk)
-        target.pipe(client)
-      })
-
-      target.on('error', () => client.destroy())
-      client.on('error', () => target.destroy())
-      target.on('close', () => client.destroy())
-      client.on('close', () => target.destroy())
-    })
-  })
-
-  return new Promise((resolve, reject) => {
-    server.listen(listenPort, '127.0.0.1', () => resolve(server as any))
-    server.on('error', reject)
-  })
-}