orez 0.2.26 → 0.2.29

package/src/worker/shims/http-service.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-
-import {
-  HttpServiceAdapter,
-  createHttpServiceAdapter,
-  type InjectableFastify,
-  type WebSocketHandler,
-  type WebSocketUpgradeResult,
-} from './http-service.js'
-
-/** minimal mock fastify that records inject() calls and returns canned responses */
-function createMockFastify(
-  responses: Record<
-    string,
-    { status: number; body: string; headers?: Record<string, string> }
-  >
-): InjectableFastify {
-  return {
-    async ready() {},
-    async inject(opts) {
-      const key = `${opts.method} ${opts.url}`
-      const resp = responses[key]
-      if (!resp) {
-        return { statusCode: 404, headers: {}, body: 'not found' }
-      }
-      return {
-        statusCode: resp.status,
-        headers: resp.headers ?? { 'content-type': 'text/plain' },
-        body: resp.body,
-      }
-    },
-  }
-}
-
-/** helper to create a Request (works in node/bun/vitest with fetch globals) */
-function makeRequest(
-  url: string,
-  opts?: { method?: string; headers?: Record<string, string>; body?: string }
-): Request {
-  return new Request(url, {
-    method: opts?.method ?? 'GET',
-    headers: opts?.headers,
-    body: opts?.body,
-  })
-}
-
-describe('HttpServiceAdapter', () => {
-  let adapter: HttpServiceAdapter
-
-  beforeEach(() => {
-    adapter = new HttpServiceAdapter()
-  })
-
-  describe('initialization', () => {
-    it('is not ready before initialize', () => {
-      expect(adapter.isReady).toBe(false)
-    })
-
-    it('is ready after initialize', async () => {
-      await adapter.initialize(createMockFastify({}))
-      expect(adapter.isReady).toBe(true)
-    })
-
-    it('returns 503 when not initialized', async () => {
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/'))
-      expect(resp.status).toBe(503)
-    })
-  })
-
-  describe('HTTP routing via inject()', () => {
-    beforeEach(async () => {
-      await adapter.initialize(
-        createMockFastify({
-          'GET /': { status: 200, body: 'ok' },
-          'GET /keepalive': { status: 200, body: 'alive' },
-          'GET /statz': {
-            status: 200,
-            body: '{"uptime":123}',
-            headers: { 'content-type': 'application/json' },
-          },
-          'POST /data': { status: 201, body: 'created' },
-        })
-      )
-    })
-
-    it('routes GET / to fastify', async () => {
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/'))
-      expect(resp.status).toBe(200)
-      expect(await resp.text()).toBe('ok')
-    })
-
-    it('routes GET /keepalive to fastify', async () => {
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/keepalive'))
-      expect(resp.status).toBe(200)
-      expect(await resp.text()).toBe('alive')
-    })
-
-    it('routes GET /statz with correct content-type', async () => {
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/statz'))
-      expect(resp.status).toBe(200)
-      expect(resp.headers.get('content-type')).toBe('application/json')
-      expect(await resp.text()).toBe('{"uptime":123}')
-    })
-
-    it('handles POST with body', async () => {
-      const resp = await adapter.handleRequest(
-        makeRequest('http://localhost/data', {
-          method: 'POST',
-          body: '{"key":"value"}',
-          headers: { 'content-type': 'application/json' },
-        })
-      )
-      expect(resp.status).toBe(201)
-      expect(await resp.text()).toBe('created')
-    })
-
-    it('returns 404 for unknown routes', async () => {
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/nope'))
-      expect(resp.status).toBe(404)
-    })
-
-    it('preserves query string', async () => {
-      const fastify = createMockFastify({
-        'GET /search?q=hello': { status: 200, body: 'found' },
-      })
-      await adapter.initialize(fastify)
-      const resp = await adapter.handleRequest(
-        makeRequest('http://localhost/search?q=hello')
-      )
-      expect(resp.status).toBe(200)
-      expect(await resp.text()).toBe('found')
-    })
-  })
-
-  describe('WebSocket route matching', () => {
-    const noopHandler: WebSocketHandler = () => {}
-
-    it('matches exact WebSocket routes', () => {
-      adapter.addWsRoute('/replication/v1/changes', noopHandler)
-      const match = adapter.matchWsRoute('/replication/v1/changes')
-      expect(match).not.toBeNull()
-      expect(match!.pattern).toBe('/replication/v1/changes')
-    })
-
-    it('returns null for unmatched paths', () => {
-      adapter.addWsRoute('/replication/v1/changes', noopHandler)
-      expect(adapter.matchWsRoute('/other/path')).toBeNull()
-    })
-
-    it('matches wildcard patterns', () => {
-      adapter.addWsRoute('/replication/v*/changes', noopHandler)
-
-      expect(adapter.matchWsRoute('/replication/v1/changes')).not.toBeNull()
-      expect(adapter.matchWsRoute('/replication/v2/changes')).not.toBeNull()
-      expect(adapter.matchWsRoute('/replication/v99/changes')).not.toBeNull()
-
-      // should not match different structure
-      expect(adapter.matchWsRoute('/replication/v1/snapshot')).toBeNull()
-    })
-
-    it('matches multiple wildcard patterns', () => {
-      const changesHandler: WebSocketHandler = () => {}
-      const snapshotHandler: WebSocketHandler = () => {}
-
-      adapter.addWsRoute('/replication/v*/changes', changesHandler)
-      adapter.addWsRoute('/replication/v*/snapshot', snapshotHandler)
-
-      const changesMatch = adapter.matchWsRoute('/replication/v1/changes')
-      expect(changesMatch).not.toBeNull()
-      expect(changesMatch!.handler).toBe(changesHandler)
-
-      const snapshotMatch = adapter.matchWsRoute('/replication/v2/snapshot')
-      expect(snapshotMatch).not.toBeNull()
-      expect(snapshotMatch!.handler).toBe(snapshotHandler)
-    })
-
-    it('prefers exact match over pattern', () => {
-      const exactHandler: WebSocketHandler = () => {}
-      const patternHandler: WebSocketHandler = () => {}
-
-      adapter.addWsRoute('/replication/v1/changes', exactHandler)
-      adapter.addWsRoute('/replication/v*/changes', patternHandler)
-
-      const match = adapter.matchWsRoute('/replication/v1/changes')
-      expect(match).not.toBeNull()
-      expect(match!.handler).toBe(exactHandler)
-    })
-
-    it('wildcard does not match across slashes', () => {
-      adapter.addWsRoute('/api/v*/data', noopHandler)
-      expect(adapter.matchWsRoute('/api/v1/extra/data')).toBeNull()
-    })
-  })
-
-  describe('WebSocket upgrade detection', () => {
-    beforeEach(async () => {
-      await adapter.initialize(createMockFastify({}))
-    })
-
-    it('detects upgrade header', async () => {
-      adapter.addWsRoute('/ws', () => {})
-
-      // WebSocketPair is a CF global — not available in vitest.
-      // we verify the adapter detects the upgrade and tries to use it.
-      const resp = await adapter.handleRequest(
-        makeRequest('http://localhost/ws', {
-          headers: { upgrade: 'websocket' },
-        })
-      )
-
-      // without WebSocketPair in the runtime, we get a 500
-      // this confirms the adapter correctly detected the upgrade
-      // and attempted ws handling (rather than routing to fastify)
-      expect(resp.status).toBe(500)
-      expect(await resp.text()).toBe('WebSocketPair not available in this runtime')
-    })
-
-    it('returns 404 for ws upgrade with no matching route', async () => {
-      const resp = await adapter.handleRequest(
-        makeRequest('http://localhost/unknown', {
-          headers: { upgrade: 'websocket' },
-        })
-      )
-      expect(resp.status).toBe(404)
-    })
-
-    it('routes non-upgrade requests to fastify even if ws route exists', async () => {
-      adapter.addWsRoute('/dual', () => {})
-
-      // regular GET (no upgrade header) should go to fastify inject
-      const resp = await adapter.handleRequest(makeRequest('http://localhost/dual'))
-      // fastify returns 404 since we didn't register an HTTP route for /dual
-      expect(resp.status).toBe(404)
-    })
-  })
-
-  describe('WebSocket upgrade preparation with mock WebSocketPair', () => {
-    // tests use prepareWebSocketUpgrade() directly because the CF Workers
-    // Response constructor (status 101 + webSocket property) is not available
-    // in Node.js. this tests the full setup logic without the CF-specific part.
-
-    let originalWebSocketPair: unknown
-
-    beforeEach(async () => {
-      originalWebSocketPair = (globalThis as any).WebSocketPair
-      await adapter.initialize(createMockFastify({}))
-    })
-
-    afterEach(() => {
-      if (originalWebSocketPair !== undefined) {
-        ;(globalThis as any).WebSocketPair = originalWebSocketPair
-      } else {
-        delete (globalThis as any).WebSocketPair
-      }
-    })
-
-    it('creates WebSocket pair and returns upgrade result', () => {
-      const mockServer = {
-        accept: vi.fn(),
-        close: vi.fn(),
-        send: vi.fn(),
-        addEventListener: vi.fn(),
-      }
-      const mockClient = { close: vi.fn() }
-
-      ;(globalThis as any).WebSocketPair = class {
-        0 = mockClient
-        1 = mockServer
-      }
-
-      const handler = vi.fn()
-      adapter.addWsRoute('/ws/test', handler)
-
-      const req = makeRequest('http://localhost/ws/test', {
-        headers: { upgrade: 'websocket' },
-      })
-      const url = new URL(req.url)
-      const result = adapter.prepareWebSocketUpgrade(req, url)
-
-      // should be an upgrade result, not a Response or null
-      expect(result).not.toBeNull()
-      expect(result).not.toBeInstanceOf(Response)
-
-      const upgrade = result as WebSocketUpgradeResult
-      expect(upgrade.client).toBe(mockClient)
-      expect(upgrade.server).toBe(mockServer)
-      expect(upgrade.handler).toBe(handler)
-      expect(upgrade.url.pathname).toBe('/ws/test')
-      expect(mockServer.accept).toHaveBeenCalled()
-    })
-
-    it('returns null when no route matches', () => {
-      const req = makeRequest('http://localhost/nope')
-      const url = new URL(req.url)
-      expect(adapter.prepareWebSocketUpgrade(req, url)).toBeNull()
-    })
-
-    it('returns Response(500) when WebSocketPair is unavailable', () => {
-      delete (globalThis as any).WebSocketPair
-
-      adapter.addWsRoute('/ws/test', () => {})
-
-      const req = makeRequest('http://localhost/ws/test')
-      const url = new URL(req.url)
-      const result = adapter.prepareWebSocketUpgrade(req, url)
-
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(500)
-    })
-
-    it('handler invocation catches errors and closes socket', async () => {
-      const mockServer = {
-        accept: vi.fn(),
-        close: vi.fn(),
-        send: vi.fn(),
-        addEventListener: vi.fn(),
-      }
-      const mockClient = { close: vi.fn() }
-
-      ;(globalThis as any).WebSocketPair = class {
-        0 = mockClient
-        1 = mockServer
-      }
-
-      const handler = vi.fn().mockRejectedValue(new Error('handler boom'))
-      adapter.addWsRoute('/ws/fail', handler)
-
-      const req = makeRequest('http://localhost/ws/fail')
-      const url = new URL(req.url)
-      const result = adapter.prepareWebSocketUpgrade(req, url) as WebSocketUpgradeResult
-
-      // simulate what handleWebSocket does: invoke handler and catch errors
-      await Promise.resolve(
-        result.handler(result.server as any, result.request, result.url)
-      ).catch((err) => {
-        try {
-          ;(result.server as any).close(1011, String(err))
-        } catch {
-          // socket may already be closed
-        }
-      })
-
-      expect(handler).toHaveBeenCalled()
-      expect(mockServer.close).toHaveBeenCalledWith(1011, 'Error: handler boom')
-    })
-  })
-
-  describe('createHttpServiceAdapter factory', () => {
-    it('returns a valid adapter', () => {
-      const adapter = createHttpServiceAdapter()
-      expect(adapter).toBeInstanceOf(HttpServiceAdapter)
-      expect(adapter.isReady).toBe(false)
-    })
-  })
-})

package/src/worker/shims/http-service.ts

@@ -1,293 +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
-
-/**
- * http service adapter for CF Workers / Durable Objects.
- *
- * bridges between a Durable Object's fetch() handler and zero-cache's
- * Fastify-based HTTP service. two routing modes:
- *
- * 1. HTTP routes — delegated to Fastify via inject() (health, keepalive, statz, etc.)
- * 2. WebSocket routes — handled via DO native WebSocket pairs, bypassing Fastify
- *    entirely since inject() cannot do upgrades.
- *
- * usage:
- *   const adapter = createHttpServiceAdapter()
- *   adapter.addWsRoute('/replication/v1/changes', handler)
- *   await adapter.initialize(fastifyInstance)
- *   // in DO fetch():
- *   return adapter.handleRequest(request)
- */
-
-// CF Workers globals — not in Node.js types
-declare const WebSocketPair: (new () => { 0: WebSocket; 1: WebSocket }) | undefined
-
-// -- types for the adapter, kept minimal so we don't import fastify at module level --
-
-/** handler for a WebSocket connection routed from a DO */
-export type WebSocketHandler = (
-  server: WebSocket,
-  request: Request,
-  url: URL
-) => void | Promise<void>
-
-/** minimal interface for what we need from fastify (avoids hard dep) */
-export interface InjectableFastify {
-  inject(opts: {
-    method: string
-    url: string
-    headers?: Record<string, string>
-    payload?: string | null
-  }): Promise<{
-    statusCode: number
-    headers: Record<string, string>
-    body: string
-  }>
-  ready(): Promise<void>
-}
-
-/** route match result */
-interface RouteMatch {
-  handler: WebSocketHandler
-  pattern: string
-}
-
-/** result of preparing a WebSocket upgrade (before CF Response creation) */
-export interface WebSocketUpgradeResult {
-  client: WebSocket
-  server: WebSocket
-  handler: WebSocketHandler
-  request: Request
-  url: URL
-}
-
-/**
- * the http service adapter. manages routing between Fastify inject()
- * for regular HTTP and DO-native WebSocket pairs for upgrade requests.
- */
-export class HttpServiceAdapter {
-  private fastify: InjectableFastify | null = null
-  private wsRoutes: Map<string, WebSocketHandler> = new Map()
-  private wsPatterns: Array<{
-    regex: RegExp
-    pattern: string
-    handler: WebSocketHandler
-  }> = []
-  private initialized = false
-
-  /**
-   * register a WebSocket route handler.
-   * supports exact paths and simple patterns with wildcard segments.
-   *
-   * call before initialize() so routes are ready when requests arrive.
-   *
-   * examples:
-   *   addWsRoute('/replication/v1/changes', handler)   -- exact
-   *   addWsRoute('/replication/v[star]/changes', handler) -- wildcard (use *)
-   */
-  addWsRoute(path: string, handler: WebSocketHandler): void {
-    if (path.includes('*')) {
-      // convert glob-style pattern to regex
-      const escaped = path.replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-      const regex = new RegExp('^' + escaped.replace(/\*/g, '[^/]+') + '$')
-      this.wsPatterns.push({ regex, pattern: path, handler })
-    } else {
-      this.wsRoutes.set(path, handler)
-    }
-  }
-
-  /**
-   * initialize with a fastify instance. call after route registration
-   * (e.g., after zero-cache's init callback has run) but before handling requests.
-   * calls fastify.ready() to finalize route compilation.
-   */
-  async initialize(fastify: InjectableFastify): Promise<void> {
-    this.fastify = fastify
-    await fastify.ready()
-    this.initialized = true
-  }
-
-  /** whether the adapter is ready to handle requests */
-  get isReady(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * handle an incoming request from a DO's fetch() method.
-   * routes WebSocket upgrades to DO-native WebSocket handlers,
-   * everything else to Fastify inject().
-   */
-  async handleRequest(request: Request): Promise<Response> {
-    if (!this.initialized) {
-      return new Response('service not ready', { status: 503 })
-    }
-
-    const url = new URL(request.url)
-
-    // websocket upgrade — route to DO native handler
-    if (request.headers.get('upgrade')?.toLowerCase() === 'websocket') {
-      return this.handleWebSocket(request, url)
-    }
-
-    // regular HTTP — fastify inject
-    return this.handleHttp(request, url)
-  }
-
-  /**
-   * route a regular HTTP request through Fastify's inject() mechanism.
-   * this works for all non-WebSocket routes (health, keepalive, statz, etc.).
-   */
-  private async handleHttp(request: Request, url: URL): Promise<Response> {
-    if (!this.fastify) {
-      return new Response('fastify not initialized', { status: 503 })
-    }
-
-    // build headers object from request
-    const headers: Record<string, string> = {}
-    request.headers.forEach((value, key) => {
-      headers[key] = value
-    })
-
-    // read body for non-GET/HEAD requests
-    let payload: string | null = null
-    if (request.method !== 'GET' && request.method !== 'HEAD' && request.body) {
-      payload = await request.text()
-    }
-
-    const result = await this.fastify.inject({
-      method: request.method,
-      url: url.pathname + url.search,
-      headers,
-      payload,
-    })
-
-    return new Response(result.body, {
-      status: result.statusCode,
-      headers: result.headers,
-    })
-  }
-
-  /**
-   * handle a WebSocket upgrade request using DO-native WebSocket pairs.
-   *
-   * creates a WebSocketPair, accepts the server side, and passes it
-   * to the matched route handler. returns the 101 response with the
-   * client side for the DO runtime to manage.
-   *
-   * note: WebSocketPair is a CF Workers global. in non-CF environments
-   * this will throw — callers should polyfill or avoid ws routes.
-   */
-  private handleWebSocket(request: Request, url: URL): Response {
-    const result = this.prepareWebSocketUpgrade(request, url)
-
-    if (!result) {
-      return new Response('no websocket handler for path', { status: 404 })
-    }
-
-    if (result instanceof Response) {
-      return result
-    }
-
-    // invoke handler (fire-and-forget; handler manages the connection lifecycle)
-    // errors in the handler should close the socket, not crash the DO
-    Promise.resolve(result.handler(result.server, result.request, result.url)).catch(
-      (err) => {
-        try {
-          result.server.close(1011, String(err))
-        } catch {
-          // socket may already be closed
-        }
-      }
-    )
-
-    // return 101 with client socket for DO runtime.
-    // CF Workers Response constructor accepts status 101 + webSocket property.
-    // standard fetch spec rejects status 101, so we try CF-style first and
-    // fall back to a plain 101-like response for non-CF environments.
-    try {
-      return new Response(null, {
-        status: 101,
-        // @ts-expect-error — webSocket is a CF Workers Response extension
-        webSocket: result.client,
-      })
-    } catch {
-      // non-CF runtime (Node.js, vitest) — status 101 not allowed.
-      // return a marker response that callers can detect.
-      const resp = new Response(null, { status: 200 })
-      ;(resp as any).__orez_websocket = result.client
-      ;(resp as any).__orez_ws_upgrade = true
-      return resp
-    }
-  }
-
-  /**
-   * prepare a WebSocket upgrade: match route, create pair, accept server side.
-   * separated from handleWebSocket so tests can verify the setup logic without
-   * needing the CF runtime's special Response(101) support.
-   *
-   * returns null if no route matches, a Response if WebSocketPair unavailable,
-   * or a WebSocketUpgradeResult with the pair + handler ready to invoke.
-   */
-  prepareWebSocketUpgrade(
-    request: Request,
-    url: URL
-  ): WebSocketUpgradeResult | Response | null {
-    const match = this.matchWsRoute(url.pathname)
-    if (!match) {
-      return null
-    }
-
-    // WebSocketPair is a CF Workers runtime global
-    const WsPair = (globalThis as any).WebSocketPair
-    if (!WsPair) {
-      return new Response('WebSocketPair not available in this runtime', { status: 500 })
-    }
-
-    const pair = new WsPair()
-    const [client, server] = Object.values(pair) as [WebSocket, WebSocket]
-
-    // accept the server side so we can send/receive (CF Workers WebSocket extension)
-    ;(server as any).accept()
-
-    return { client, server, handler: match.handler, request, url }
-  }
-
-  /**
-   * match a pathname against registered WebSocket routes.
-   * checks exact matches first, then pattern matches.
-   */
-  matchWsRoute(pathname: string): RouteMatch | null {
-    // exact match first
-    const exact = this.wsRoutes.get(pathname)
-    if (exact) {
-      return { handler: exact, pattern: pathname }
-    }
-
-    // pattern match
-    for (const { regex, pattern, handler } of this.wsPatterns) {
-      if (regex.test(pathname)) {
-        return { handler, pattern }
-      }
-    }
-
-    return null
-  }
-}
-
-/**
- * factory function — creates a pre-configured adapter with the standard
- * zero-cache WebSocket routes registered.
- *
- * handlers are placeholders that will be replaced during Phase 3 integration
- * when we wire up the actual zero-cache WebSocket protocol handlers.
- */
-export function createHttpServiceAdapter(): HttpServiceAdapter {
-  const adapter = new HttpServiceAdapter()
-
-  // register known zero-cache websocket route patterns.
-  // actual handlers will be set during integration (Phase 3).
-  // these patterns match zero-cache's replication endpoints.
-  // for now, register the patterns so path matching works.
-
-  return adapter
-}