@risingwave/wavelet-server 0.2.1 → 0.2.5

package/src/http-api.ts

@@ -1,278 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import pg from 'pg'
-import type { EventDef, QueryDef, SqlFragment } from '@risingwave/wavelet'
-import type { JwtVerifier, JwtClaims } from './jwt.js'
-
-const { Pool } = pg
-
-const MAX_BODY_SIZE = 10 * 1024 * 1024 // 10MB
-
-export class HttpApi {
-  private pool: InstanceType<typeof Pool> | null = null
-
-  constructor(
-    private connectionString: string,
-    private events: Record<string, EventDef>,
-    private queries: Record<string, QueryDef | SqlFragment>,
-    private jwt?: JwtVerifier
-  ) {}
-
-  async handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
-    // CORS
-    res.setHeader('Access-Control-Allow-Origin', '*')
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204)
-      res.end()
-      return
-    }
-
-    const url = new URL(req.url ?? '/', `http://${req.headers.host}`)
-
-    try {
-      // POST /v1/events/{name}
-      const eventMatch = url.pathname.match(/^\/v1\/events\/([^/]+)$/)
-      if (eventMatch && req.method === 'POST') {
-        await this.handleWrite(eventMatch[1], req, res)
-        return
-      }
-
-      // POST /v1/events/{name}/batch
-      const batchMatch = url.pathname.match(/^\/v1\/events\/([^/]+)\/batch$/)
-      if (batchMatch && req.method === 'POST') {
-        await this.handleBatchWrite(batchMatch[1], req, res)
-        return
-      }
-
-      // GET /v1/queries/{name}
-      const queryMatch = url.pathname.match(/^\/v1\/queries\/([^/]+)$/)
-      if (queryMatch && req.method === 'GET') {
-        await this.handleRead(queryMatch[1], url, req, res)
-        return
-      }
-
-      // GET /v1/health
-      if (url.pathname === '/v1/health') {
-        this.json(res, 200, { status: 'ok' })
-        return
-      }
-
-      // GET /v1/queries - list available queries
-      if (url.pathname === '/v1/queries' && req.method === 'GET') {
-        this.json(res, 200, { queries: Object.keys(this.queries) })
-        return
-      }
-
-      // GET /v1/events - list available events
-      if (url.pathname === '/v1/events' && req.method === 'GET') {
-        this.json(res, 200, { events: Object.keys(this.events) })
-        return
-      }
-
-      this.json(res, 404, {
-        error: 'Not found',
-        message: `${req.method} ${url.pathname} does not match any route.`,
-        routes: [
-          'GET  /v1/health',
-          'GET  /v1/queries',
-          'GET  /v1/queries/{name}',
-          'GET  /v1/events',
-          'POST /v1/events/{name}',
-          'POST /v1/events/{name}/batch',
-        ],
-      })
-    } catch (err: any) {
-      console.error('HTTP error:', err)
-      this.json(res, 500, { error: err.message })
-    }
-  }
-
-  private ensurePool(): InstanceType<typeof Pool> {
-    if (!this.pool) {
-      this.pool = new Pool({ connectionString: this.connectionString, max: 10 })
-    }
-    return this.pool
-  }
-
-  private async handleWrite(eventName: string, req: IncomingMessage, res: ServerResponse): Promise<void> {
-    const eventDef = this.events[eventName]
-    if (!eventDef) {
-      const available = Object.keys(this.events)
-      this.json(res, 404, {
-        error: `Event '${eventName}' not found.`,
-        available_events: available,
-      })
-      return
-    }
-
-    const body = await this.readBody(req)
-    const data = JSON.parse(body)
-
-    const pool = this.ensurePool()
-    const columns = Object.keys(eventDef.columns)
-    const values = columns.map((col) => data[col])
-    const placeholders = columns.map((_, i) => `$${i + 1}`)
-
-    await pool.query(
-      `INSERT INTO ${eventName} (${columns.join(', ')}) VALUES (${placeholders.join(', ')})`,
-      values
-    )
-
-    this.json(res, 200, { ok: true })
-  }
-
-  private async handleBatchWrite(eventName: string, req: IncomingMessage, res: ServerResponse): Promise<void> {
-    const eventDef = this.events[eventName]
-    if (!eventDef) {
-      const available = Object.keys(this.events)
-      this.json(res, 404, {
-        error: `Event '${eventName}' not found.`,
-        available_events: available,
-      })
-      return
-    }
-
-    const body = await this.readBody(req)
-    const items: any[] = JSON.parse(body)
-
-    if (!Array.isArray(items)) {
-      this.json(res, 400, { error: 'Batch endpoint expects a JSON array.' })
-      return
-    }
-
-    if (items.length === 0) {
-      this.json(res, 200, { ok: true, count: 0 })
-      return
-    }
-
-    const pool = this.ensurePool()
-    const columns = Object.keys(eventDef.columns)
-
-    // Build a single INSERT with multiple VALUE rows
-    const allValues: unknown[] = []
-    const rowPlaceholders: string[] = []
-
-    for (let i = 0; i < items.length; i++) {
-      const row = items[i]
-      const offset = i * columns.length
-      const ph = columns.map((_, j) => `$${offset + j + 1}`)
-      rowPlaceholders.push(`(${ph.join(', ')})`)
-      for (const col of columns) {
-        allValues.push(row[col])
-      }
-    }
-
-    await pool.query(
-      `INSERT INTO ${eventName} (${columns.join(', ')}) VALUES ${rowPlaceholders.join(', ')}`,
-      allValues
-    )
-
-    this.json(res, 200, { ok: true, count: items.length })
-  }
-
-  private async handleRead(queryName: string, url: URL, req: IncomingMessage, res: ServerResponse): Promise<void> {
-    if (!this.queries[queryName]) {
-      const available = Object.keys(this.queries)
-      this.json(res, 404, {
-        error: `Query '${queryName}' not found.`,
-        available_queries: available,
-      })
-      return
-    }
-
-    // JWT verification for queries with filterBy
-    const queryDef = this.queries[queryName]
-    const filterBy = this.getFilterBy(queryDef)
-
-    let claims: JwtClaims | null = null
-    if (filterBy && this.jwt?.isConfigured()) {
-      const token = url.searchParams.get('token')
-        ?? req.headers.authorization?.replace('Bearer ', '')
-
-      if (!token) {
-        this.json(res, 401, { error: 'Authentication required for filtered queries.' })
-        return
-      }
-
-      claims = await this.jwt.verify(token)
-    }
-
-    const pool = this.ensurePool()
-
-    // Build WHERE clause: start with filterBy if applicable
-    const params: string[] = []
-    const values: unknown[] = []
-
-    if (filterBy && claims) {
-      const claimValue = claims[filterBy]
-      if (claimValue === undefined) {
-        // No matching claim -- return empty result, not all data
-        this.json(res, 200, { query: queryName, rows: [] })
-        return
-      }
-      values.push(String(claimValue))
-      params.push(`${filterBy} = $${values.length}`)
-    }
-
-    // Add query params as additional filters, validating column names
-    const knownColumns = this.getQueryColumns(queryDef)
-    for (const [key, value] of url.searchParams.entries()) {
-      if (key === 'token') continue // skip JWT token param
-      if (knownColumns && !knownColumns.includes(key)) {
-        this.json(res, 400, { error: `Unknown column '${key}'. Known columns: ${knownColumns.join(', ')}` })
-        return
-      }
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
-        this.json(res, 400, { error: `Invalid column name: '${key}'` })
-        return
-      }
-      values.push(value)
-      params.push(`${key} = $${values.length}`)
-    }
-
-    let sql = `SELECT * FROM ${queryName}`
-    if (params.length > 0) {
-      sql += ` WHERE ${params.join(' AND ')}`
-    }
-
-    const result = await pool.query(sql, values)
-    this.json(res, 200, { query: queryName, rows: result.rows })
-  }
-
-  private getFilterBy(queryDef: QueryDef | SqlFragment): string | undefined {
-    if ('_tag' in queryDef && queryDef._tag === 'sql') return undefined
-    return (queryDef as QueryDef).filterBy
-  }
-
-  private getQueryColumns(queryDef: QueryDef | SqlFragment): string[] | null {
-    if ('_tag' in queryDef && queryDef._tag === 'sql') return null
-    const qd = queryDef as QueryDef
-    if (qd.columns) return Object.keys(qd.columns)
-    return null
-  }
-
-  private json(res: ServerResponse, status: number, data: unknown): void {
-    res.writeHead(status, { 'Content-Type': 'application/json' })
-    res.end(JSON.stringify(data))
-  }
-
-  private readBody(req: IncomingMessage): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let body = ''
-      let size = 0
-      req.on('data', (chunk) => {
-        size += chunk.length
-        if (size > MAX_BODY_SIZE) {
-          req.destroy()
-          reject(new Error(`Request body exceeds ${MAX_BODY_SIZE / 1024 / 1024}MB limit`))
-          return
-        }
-        body += chunk
-      })
-      req.on('end', () => resolve(body))
-      req.on('error', reject)
-    })
-  }
-}

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,171 +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
-}
-
-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 }
-
-    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 }))
-  }
-
-  broadcast(queryName: string, diff: ViewDiff): void {
-    const subs = this.subscribers.get(queryName)
-    if (!subs || subs.size === 0) return
-
-    const queryDef = this.queries[queryName]
-    const filterBy = this.getFilterBy(queryDef)
-
-    for (const sub of subs) {
-      if (sub.ws.readyState !== WebSocket.OPEN) continue
-
-      let filteredDiff = diff
-      if (filterBy && sub.claims) {
-        filteredDiff = this.filterDiff(diff, filterBy, sub.claims)
-      }
-
-      if (
-        filteredDiff.inserted.length === 0 &&
-        filteredDiff.updated.length === 0 &&
-        filteredDiff.deleted.length === 0
-      ) {
-        continue
-      }
-
-      sub.ws.send(JSON.stringify({
-        type: 'diff',
-        query: queryName,
-        cursor: filteredDiff.cursor,
-        inserted: filteredDiff.inserted,
-        updated: filteredDiff.updated,
-        deleted: filteredDiff.deleted,
-      }))
-    }
-  }
-
-  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
-  }
-
-  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"]
-}