@risingwave/wavelet-server 0.2.4 → 0.2.5

package/src/index.ts

@@ -1,31 +0,0 @@
-export { WaveletServer } from './server.js'
-export { loadConfig } from './config-loader.js'
-export { DdlManager } from './ddl-manager.js'
-export type { DdlAction } from './ddl-manager.js'
-
-async function main() {
-  const { loadConfig } = await import('./config-loader.js')
-  const { WaveletServer } = await import('./server.js')
-
-  const configPath = process.argv[2] || './wavelet.config.ts'
-  const config = await loadConfig(configPath)
-
-  const server = new WaveletServer(config)
-  await server.start()
-
-  const shutdown = async () => {
-    console.log('\nShutting down...')
-    await server.stop()
-    process.exit(0)
-  }
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-}
-
-// Only run main() when executed directly, not when imported as a library
-if (require.main === module) {
-  main().catch((err) => {
-    console.error('Fatal:', err)
-    process.exit(1)
-  })
-}

package/src/jwt.ts

@@ -1,56 +0,0 @@
-import * as jose from 'jose'
-
-export type JwtClaims = Record<string, unknown>
-
-export class JwtVerifier {
-  private secret: Uint8Array | null = null
-  private jwksUrl: string | null = null
-  private issuer: string | undefined
-  private audience: string | undefined
-
-  constructor(config?: { secret?: string; jwksUrl?: string; issuer?: string; audience?: string }) {
-    if (config?.secret) {
-      this.secret = new TextEncoder().encode(config.secret)
-    }
-    if (config?.jwksUrl) {
-      this.jwksUrl = config.jwksUrl
-    }
-    this.issuer = config?.issuer
-    this.audience = config?.audience
-  }
-
-  isConfigured(): boolean {
-    return this.secret !== null || this.jwksUrl !== null
-  }
-
-  async verify(token: string): Promise<JwtClaims> {
-    try {
-      if (this.secret) {
-        const { payload } = await jose.jwtVerify(token, this.secret, {
-          issuer: this.issuer,
-          audience: this.audience,
-        })
-        return payload as JwtClaims
-      }
-
-      if (this.jwksUrl) {
-        const jwks = jose.createRemoteJWKSet(new URL(this.jwksUrl))
-        const { payload } = await jose.jwtVerify(token, jwks, {
-          issuer: this.issuer,
-          audience: this.audience,
-        })
-        return payload as JwtClaims
-      }
-
-      throw new Error('JWT verification not configured')
-    } catch (err: any) {
-      if (err.code === 'ERR_JWT_EXPIRED') {
-        throw new Error('Token expired. Please refresh your authentication token.')
-      }
-      if (err.code === 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED') {
-        throw new Error('Invalid token signature. Check your JWT secret configuration.')
-      }
-      throw new Error(`Authentication failed: ${err.message}`)
-    }
-  }
-}

package/src/server.ts

@@ -1,89 +0,0 @@
-import { createServer, type IncomingMessage, type ServerResponse, type Server } from 'node:http'
-import type { WaveletConfig } from '@risingwave/wavelet'
-import { CursorManager } from './cursor-manager.js'
-import { WebSocketFanout } from './ws-fanout.js'
-import { WebhookFanout } from './webhook.js'
-import { HttpApi } from './http-api.js'
-import { JwtVerifier } from './jwt.js'
-
-export class WaveletServer {
-  private httpServer: ReturnType<typeof createServer> | null = null
-  private cursorManager: CursorManager
-  private fanout: WebSocketFanout
-  private webhooks: WebhookFanout
-  private httpApi: HttpApi
-  private jwt: JwtVerifier
-
-  constructor(private config: WaveletConfig) {
-    this.jwt = new JwtVerifier(config.jwt)
-    const queries = config.queries ?? config.views ?? {}
-    const events = config.events ?? config.streams ?? {}
-    this.cursorManager = new CursorManager(config.database, queries)
-    this.fanout = new WebSocketFanout(this.cursorManager, this.jwt, queries)
-    this.webhooks = new WebhookFanout(queries, config.jwt?.secret)
-    this.httpApi = new HttpApi(config.database, events, queries, this.jwt)
-  }
-
-  async start(): Promise<void> {
-    const port = this.config.server?.port ?? 8080
-    const host = this.config.server?.host ?? '0.0.0.0'
-
-    this.httpServer = createServer((req, res) => this.httpApi.handle(req, res))
-    this.fanout.attach(this.httpServer)
-
-    await this.cursorManager.initialize()
-    this.cursorManager.startPolling((queryName, diffs) => {
-      this.fanout.broadcast(queryName, diffs)
-      this.webhooks.broadcast(queryName, diffs)
-    })
-
-    await new Promise<void>((resolve) => {
-      this.httpServer!.listen(port, host, () => {
-        console.log(`Wavelet server listening on ${host}:${port}`)
-        console.log(`WebSocket: ws://${host}:${port}/subscribe/{query}`)
-        console.log(`HTTP API:  http://${host}:${port}/v1/`)
-        resolve()
-      })
-    })
-  }
-
-  /**
-   * Attach to an existing HTTP server instead of creating one.
-   * Used by Wavelet Cloud to run multiple instances on a shared port.
-   */
-  async attachTo(server: Server, opts?: { pathPrefix?: string }): Promise<{
-    handleHttp: (req: IncomingMessage, res: ServerResponse) => void
-  }> {
-    const prefix = opts?.pathPrefix ?? ''
-
-    this.fanout.attach(server, prefix)
-
-    await this.cursorManager.initialize()
-    this.cursorManager.startPolling((queryName, diffs) => {
-      this.fanout.broadcast(queryName, diffs)
-      this.webhooks.broadcast(queryName, diffs)
-    })
-
-    const handleHttp = (req: IncomingMessage, res: ServerResponse) => {
-      if (prefix && req.url?.startsWith(prefix)) {
-        req.url = req.url.slice(prefix.length) || '/'
-      }
-      this.httpApi.handle(req, res)
-    }
-
-    return { handleHttp }
-  }
-
-  async stop(): Promise<void> {
-    this.cursorManager.stopPolling()
-    this.fanout.closeAll()
-    await this.cursorManager.close()
-    await new Promise<void>((resolve) => {
-      if (this.httpServer) {
-        this.httpServer.close(() => resolve())
-      } else {
-        resolve()
-      }
-    })
-  }
-}

package/src/webhook.ts

@@ -1,67 +0,0 @@
-import { createHmac } from 'node:crypto'
-import type { QueryDef, SqlFragment } from '@risingwave/wavelet'
-import type { ViewDiff } from './cursor-manager.js'
-
-const TIMEOUT_MS = 10000
-
-export class WebhookFanout {
-  private webhooks: Map<string, string> = new Map() // queryName -> url
-
-  constructor(
-    queries: Record<string, QueryDef | SqlFragment>,
-    private signingSecret?: string
-  ) {
-    for (const [name, def] of Object.entries(queries)) {
-      if ('_tag' in def && def._tag === 'sql') continue
-      const qd = def as QueryDef
-      if (qd.webhook) {
-        this.webhooks.set(name, qd.webhook)
-      }
-    }
-  }
-
-  async broadcast(queryName: string, diff: ViewDiff): Promise<void> {
-    const url = this.webhooks.get(queryName)
-    if (!url) return
-
-    const body = JSON.stringify({
-      query: queryName,
-      cursor: diff.cursor,
-      inserted: diff.inserted,
-      updated: diff.updated,
-      deleted: diff.deleted,
-    })
-
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'User-Agent': 'Wavelet-Webhook/1.0',
-    }
-
-    if (this.signingSecret) {
-      const signature = createHmac('sha256', this.signingSecret)
-        .update(body)
-        .digest('hex')
-      headers['X-Wavelet-Signature'] = `sha256=${signature}`
-    }
-
-    try {
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS)
-
-      await fetch(url, {
-        method: 'POST',
-        headers,
-        body,
-        signal: controller.signal,
-      })
-
-      clearTimeout(timeout)
-    } catch (err: any) {
-      if (err.name === 'AbortError') {
-        console.error(`[webhook] Timeout sending to ${url} for query ${queryName}`)
-      } else {
-        console.error(`[webhook] Failed to send to ${url} for query ${queryName}:`, err.message)
-      }
-    }
-  }
-}

package/src/ws-fanout.ts

@@ -1,245 +0,0 @@
-import { WebSocketServer, WebSocket } from 'ws'
-import type { IncomingMessage, Server } from 'node:http'
-import type { QueryDef, SqlFragment } from '@risingwave/wavelet'
-import type { CursorManager, ViewDiff } from './cursor-manager.js'
-import type { JwtVerifier, JwtClaims } from './jwt.js'
-
-interface Subscriber {
-  ws: WebSocket
-  queryName: string
-  claims: JwtClaims | null
-  ready: boolean
-  pendingDiffs: ViewDiff[]
-}
-
-export class WebSocketFanout {
-  private wss: WebSocketServer | null = null
-  private subscribers: Map<string, Set<Subscriber>> = new Map() // queryName -> subscribers
-
-  constructor(
-    private cursorManager: CursorManager,
-    private jwt: JwtVerifier,
-    private queries: Record<string, QueryDef | SqlFragment>
-  ) {}
-
-  attach(server: Server, pathPrefix?: string): void {
-    this.wss = new WebSocketServer({ noServer: true })
-
-    server.on('upgrade', (req, socket, head) => {
-      const pathname = req.url?.split('?')[0] ?? ''
-      const subscribePrefix = (pathPrefix ?? '') + '/subscribe/'
-
-      if (pathname.startsWith(subscribePrefix)) {
-        this.wss!.handleUpgrade(req, socket, head, (ws) => {
-          this.wss!.emit('connection', ws, req)
-        })
-      }
-    })
-
-    this.wss.on('connection', async (ws: WebSocket, req: IncomingMessage) => {
-      // Strip path prefix before handling
-      if (pathPrefix && req.url?.startsWith(pathPrefix)) {
-        req.url = req.url.slice(pathPrefix.length)
-      }
-      try {
-        await this.handleConnection(ws, req)
-      } catch (err: any) {
-        ws.send(JSON.stringify({ error: err.message }))
-        ws.close(4000, err.message)
-      }
-    })
-  }
-
-  private async handleConnection(ws: WebSocket, req: IncomingMessage): Promise<void> {
-    const url = new URL(req.url ?? '', `http://${req.headers.host ?? 'localhost'}`)
-    const match = url.pathname?.match(/^\/subscribe\/(.+)$/)
-
-    if (!match) {
-      throw new Error(
-        `Invalid path: ${url.pathname}. Use /subscribe/{queryName}. ` +
-        `Available queries: ${Object.keys(this.queries).join(', ')}`
-      )
-    }
-
-    const queryName = match[1]
-
-    if (!this.queries[queryName]) {
-      const available = Object.keys(this.queries)
-      throw new Error(
-        `Query '${queryName}' not found. Available queries: ${available.join(', ')}`
-      )
-    }
-
-    // Verify JWT if configured
-    let claims: JwtClaims | null = null
-    const token = url.searchParams.get('token')
-      ?? req.headers.authorization?.replace('Bearer ', '')
-
-    if (this.jwt.isConfigured()) {
-      if (!token) {
-        throw new Error('Authentication required. Pass token as query param or Authorization header.')
-      }
-      claims = await this.jwt.verify(token)
-    }
-
-    const subscriber: Subscriber = {
-      ws,
-      queryName,
-      claims,
-      ready: false,
-      pendingDiffs: [],
-    }
-
-    if (!this.subscribers.has(queryName)) {
-      this.subscribers.set(queryName, new Set())
-    }
-    this.subscribers.get(queryName)!.add(subscriber)
-
-    ws.on('close', () => {
-      this.subscribers.get(queryName)?.delete(subscriber)
-    })
-
-    // Heartbeat: detect dead connections behind proxies/load balancers
-    const pingInterval = setInterval(() => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.ping()
-      }
-    }, 30000)
-    ws.on('close', () => clearInterval(pingInterval))
-    ws.on('pong', () => { /* connection alive */ })
-
-    ws.send(JSON.stringify({ type: 'connected', query: queryName }))
-
-    const bootstrap = await this.cursorManager.bootstrap(queryName)
-    const snapshotRows = this.filterSnapshotRows(queryName, bootstrap.snapshotRows, claims)
-    ws.send(JSON.stringify({
-      type: 'snapshot',
-      query: queryName,
-      rows: snapshotRows,
-    }))
-
-    for (const diff of bootstrap.diffs) {
-      const filteredDiff = this.filterDiffForSubscriber(queryName, diff, claims)
-      if (this.isEmptyDiff(filteredDiff)) continue
-      if (ws.readyState !== WebSocket.OPEN) break
-      ws.send(this.serializeDiffMessage(queryName, filteredDiff))
-    }
-
-    const handoffCursor = bootstrap.lastCursor
-    subscriber.ready = true
-    for (const diff of subscriber.pendingDiffs) {
-      if (ws.readyState !== WebSocket.OPEN) break
-      if (handoffCursor && this.compareCursor(diff.cursor, handoffCursor) <= 0) {
-        continue
-      }
-      ws.send(this.serializeDiffMessage(queryName, diff))
-    }
-    subscriber.pendingDiffs = []
-  }
-
-  broadcast(queryName: string, diff: ViewDiff): void {
-    const subs = this.subscribers.get(queryName)
-    if (!subs || subs.size === 0) return
-
-    for (const sub of subs) {
-      if (sub.ws.readyState !== WebSocket.OPEN) continue
-
-      const filteredDiff = this.filterDiffForSubscriber(queryName, diff, sub.claims)
-      if (this.isEmptyDiff(filteredDiff)) continue
-
-      if (!sub.ready) {
-        sub.pendingDiffs.push(filteredDiff)
-        continue
-      }
-
-      sub.ws.send(this.serializeDiffMessage(queryName, filteredDiff))
-    }
-  }
-
-  private filterSnapshotRows(
-    queryName: string,
-    rows: Record<string, unknown>[],
-    claims: JwtClaims | null
-  ): Record<string, unknown>[] {
-    const queryDef = this.queries[queryName]
-    const filterBy = this.getFilterBy(queryDef)
-
-    if (filterBy && claims) {
-      const claimValue = claims[filterBy]
-      if (claimValue === undefined) return []
-
-      return rows.filter((row) => String(row[filterBy]) === String(claimValue))
-    }
-
-    return rows
-  }
-
-  private filterDiffForSubscriber(
-    queryName: string,
-    diff: ViewDiff,
-    claims: JwtClaims | null
-  ): ViewDiff {
-    const queryDef = this.queries[queryName]
-    const filterBy = this.getFilterBy(queryDef)
-
-    if (filterBy && claims) {
-      return this.filterDiff(diff, filterBy, claims)
-    }
-
-    return diff
-  }
-
-  private filterDiff(diff: ViewDiff, filterBy: string, claims: JwtClaims): ViewDiff {
-    const claimValue = claims[filterBy]
-    if (claimValue === undefined) {
-      // No matching claim -- return empty diff, not all data
-      return { cursor: diff.cursor, inserted: [], updated: [], deleted: [] }
-    }
-
-    const filterFn = (row: Record<string, unknown>) =>
-      String(row[filterBy]) === String(claimValue)
-
-    return {
-      cursor: diff.cursor,
-      inserted: diff.inserted.filter(filterFn),
-      updated: diff.updated.filter(filterFn),
-      deleted: diff.deleted.filter(filterFn),
-    }
-  }
-
-  private getFilterBy(queryDef: QueryDef | SqlFragment): string | undefined {
-    if ('_tag' in queryDef && queryDef._tag === 'sql') return undefined
-    return (queryDef as QueryDef).filterBy
-  }
-
-  private isEmptyDiff(diff: ViewDiff): boolean {
-    return diff.inserted.length === 0 && diff.updated.length === 0 && diff.deleted.length === 0
-  }
-
-  private serializeDiffMessage(queryName: string, diff: ViewDiff): string {
-    return JSON.stringify({
-      type: 'diff',
-      query: queryName,
-      cursor: diff.cursor,
-      inserted: diff.inserted,
-      updated: diff.updated,
-      deleted: diff.deleted,
-    })
-  }
-
-  private compareCursor(left: string, right: string): number {
-    const leftValue = BigInt(left)
-    const rightValue = BigInt(right)
-    if (leftValue === rightValue) return 0
-    return leftValue < rightValue ? -1 : 1
-  }
-
-  closeAll(): void {
-    for (const [, subs] of this.subscribers) {
-      for (const sub of subs) {
-        sub.ws.close(1001, 'Server shutting down')
-      }
-    }
-    this.wss?.close()
-  }
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src"]
-}