bunderstack 0.15.2 → 0.17.0-beta.0

package/src/jobs/cron-runner.ts

@@ -1,224 +0,0 @@
-import { and, eq, lt, or, sql } from 'drizzle-orm'
-
-import type { AnyDb } from '../dialect'
-import type { BackgroundDefs } from './define'
-
-import { cronRunsTableFor } from '../internal-tables'
-import { cronMatches, parseCron } from './cron'
-
-const LEASE_MS = 60_000
-
-export type CronRunResult =
-  | { status: 'succeeded' }
-  | { status: 'duplicate' }
-  | { status: 'running' }
-
-export async function runScheduledSlot(args: {
-  db: AnyDb
-  taskId: string
-  schedule: string
-  slot: number
-  now: number
-  run: (scheduledFor: Date) => Promise<void> | void
-  leaseMs?: number
-  heartbeatIntervalMs?: number
-  heartbeatCleanupTimeoutMs?: number
-}): Promise<CronRunResult> {
-  const { db, taskId, schedule, slot, now, run } = args
-  const leaseMs = args.leaseMs ?? LEASE_MS
-  const heartbeatIntervalMs =
-    args.heartbeatIntervalMs ?? Math.max(1, Math.floor(leaseMs / 4))
-  const heartbeatCleanupTimeoutMs = args.heartbeatCleanupTimeoutMs ?? 1_000
-
-  if (slot % 60_000 !== 0 || !cronMatches(parseCron(schedule), slot)) {
-    throw new Error('[bunderstack] cron slot does not match its schedule')
-  }
-
-  const t = cronRunsTableFor(db)
-  const leaseUntil = now + leaseMs
-  const inserted = await db
-    .insert(t)
-    .values({
-      taskId,
-      scheduledAt: slot,
-      status: 'running',
-      attempts: 1,
-      lockedUntil: leaseUntil,
-      startedAt: now,
-    })
-    .onConflictDoNothing({ target: [t.taskId, t.scheduledAt] })
-    .returning({ taskId: t.taskId, attempts: t.attempts })
-
-  let ownershipAttempt: number
-  if (inserted[0]) {
-    ownershipAttempt = Number(inserted[0].attempts)
-  } else {
-    const existing = await db
-      .select({ status: t.status, lockedUntil: t.lockedUntil })
-      .from(t)
-      .where(and(eq(t.taskId, taskId), eq(t.scheduledAt, slot)))
-      .limit(1)
-    const row = existing[0]
-    if (!row || row.status === 'succeeded') return { status: 'duplicate' }
-    if (row.status === 'running' && Number(row.lockedUntil) >= now) {
-      return { status: 'running' }
-    }
-    const reclaimed = await db
-      .update(t)
-      .set({
-        status: 'running',
-        lockedUntil: leaseUntil,
-        startedAt: now,
-        attempts: sql`${t.attempts} + 1`,
-        lastError: null,
-      })
-      .where(
-        and(
-          eq(t.taskId, taskId),
-          eq(t.scheduledAt, slot),
-          or(eq(t.status, 'failed'), lt(t.lockedUntil, now)),
-        ),
-      )
-      .returning({ taskId: t.taskId, attempts: t.attempts })
-    const reclaimedRow = reclaimed[0]
-    if (!reclaimedRow) return { status: 'running' }
-    ownershipAttempt = Number(reclaimedRow.attempts)
-  }
-
-  let heartbeatTimer: Timer | undefined
-  let heartbeatInFlight: Promise<void> | undefined
-  let heartbeatStopped = false
-
-  const scheduleHeartbeat = () => {
-    heartbeatTimer = setTimeout(() => {
-      heartbeatTimer = undefined
-      if (heartbeatStopped) return
-
-      heartbeatInFlight = (async () => {
-        try {
-          const renewUntil = Date.now() + leaseMs
-          await db
-            .update(t)
-            .set({ lockedUntil: renewUntil })
-            .where(
-              and(
-                eq(t.taskId, taskId),
-                eq(t.scheduledAt, slot),
-                eq(t.status, 'running'),
-                eq(t.startedAt, now),
-                eq(t.attempts, ownershipAttempt),
-              ),
-            )
-        } catch {
-          // Best effort renewal
-        }
-      })()
-
-      void heartbeatInFlight.finally(() => {
-        heartbeatInFlight = undefined
-        if (!heartbeatStopped) scheduleHeartbeat()
-      })
-    }, heartbeatIntervalMs)
-  }
-
-  const stopHeartbeat = async () => {
-    heartbeatStopped = true
-    if (heartbeatTimer) {
-      clearTimeout(heartbeatTimer)
-      heartbeatTimer = undefined
-    }
-    const inFlight = heartbeatInFlight
-    if (!inFlight) return
-
-    let cleanupTimer: Timer | undefined
-    try {
-      await Promise.race([
-        inFlight,
-        new Promise<void>((resolve) => {
-          cleanupTimer = setTimeout(resolve, heartbeatCleanupTimeoutMs)
-        }),
-      ])
-    } finally {
-      if (cleanupTimer) clearTimeout(cleanupTimer)
-    }
-  }
-
-  scheduleHeartbeat()
-
-  try {
-    await run(new Date(slot))
-
-    const updated = await db
-      .update(t)
-      .set({ status: 'succeeded', lockedUntil: null, finishedAt: Date.now() })
-      .where(
-        and(
-          eq(t.taskId, taskId),
-          eq(t.scheduledAt, slot),
-          eq(t.status, 'running'),
-          eq(t.startedAt, now),
-          eq(t.attempts, ownershipAttempt),
-        ),
-      )
-      .returning({ taskId: t.taskId })
-
-    if (!updated[0]) {
-      throw new Error(
-        '[bunderstack] cron lease ownership was lost during execution',
-      )
-    }
-
-    return { status: 'succeeded' }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    await db
-      .update(t)
-      .set({
-        status: 'failed',
-        lockedUntil: null,
-        lastError: message,
-        finishedAt: Date.now(),
-      })
-      .where(
-        and(
-          eq(t.taskId, taskId),
-          eq(t.scheduledAt, slot),
-          eq(t.status, 'running'),
-          eq(t.startedAt, now),
-          eq(t.attempts, ownershipAttempt),
-        ),
-      )
-    throw error
-  } finally {
-    await stopHeartbeat()
-  }
-}
-
-export async function runCronSlot(args: {
-  db: AnyDb
-  defs: BackgroundDefs
-  ctx: Record<string, unknown>
-  name: string
-  slot: number
-  now: number
-  leaseMs?: number
-  heartbeatIntervalMs?: number
-  heartbeatCleanupTimeoutMs?: number
-}): Promise<CronRunResult> {
-  const definition = args.defs[args.name]
-  if (!definition || definition.kind !== 'cron') {
-    throw new Error(`[bunderstack] unknown cron "${args.name}"`)
-  }
-  return runScheduledSlot({
-    db: args.db,
-    taskId: `cron:${args.name}`,
-    schedule: definition.schedule,
-    slot: args.slot,
-    now: args.now,
-    leaseMs: args.leaseMs,
-    heartbeatIntervalMs: args.heartbeatIntervalMs,
-    heartbeatCleanupTimeoutMs: args.heartbeatCleanupTimeoutMs,
-    run: (scheduledFor) =>
-      definition.handler({ scheduledFor }, args.ctx as never),
-  })
-}

package/src/jobs/local-cron.ts

@@ -1,78 +0,0 @@
-import { cronMatches, parseCron } from './cron'
-
-type Timer = ReturnType<typeof setTimeout> | number
-
-export type LocalCronDefinition = {
-  name: string
-  schedule: string
-}
-
-export type LocalCronSchedulerOptions = {
-  cron: readonly LocalCronDefinition[]
-  runSlot: (name: string, scheduledFor: number) => Promise<void>
-  now?: () => number
-  setTimer?: (callback: () => void, delayMs: number) => Timer
-  clearTimer?: (timer: Timer) => void
-  onError?: (error: Error) => void
-}
-
-export type LocalCronScheduler = {
-  tick: () => Promise<void>
-  close: () => Promise<void>
-}
-
-/**
- * Runs declared cron handlers locally. Production schedules should be delivered
- * by the hosting platform through the signed cron endpoint instead.
- */
-export function startLocalCronScheduler(
-  options: LocalCronSchedulerOptions,
-): LocalCronScheduler {
-  const cron = options.cron.map((definition) => ({
-    ...definition,
-    expression: parseCron(definition.schedule),
-  }))
-  const now = options.now ?? Date.now
-  const setTimer = options.setTimer ?? setTimeout
-  const clearTimer = options.clearTimer ?? clearTimeout
-  let timer: Timer | undefined
-  let closed = false
-
-  const scheduleNextTick = () => {
-    if (closed || timer) return
-
-    const delay = 60_000 - (now() % 60_000)
-    timer = setTimer(() => {
-      timer = undefined
-      void tick().catch((error: unknown) => {
-        options.onError?.(
-          error instanceof Error ? error : new Error(String(error)),
-        )
-      })
-    }, delay)
-  }
-
-  const tick = async () => {
-    if (closed) return
-
-    const scheduledFor = Math.floor(now() / 60_000) * 60_000
-    for (const definition of cron) {
-      if (cronMatches(definition.expression, scheduledFor)) {
-        await options.runSlot(definition.name, scheduledFor)
-      }
-    }
-
-    scheduleNextTick()
-  }
-
-  return {
-    tick,
-    async close() {
-      closed = true
-      if (timer) {
-        clearTimer(timer)
-        timer = undefined
-      }
-    },
-  }
-}

package/src/realtime/index.ts

@@ -1,250 +0,0 @@
-// packages/bunderstack/src/realtime.ts
-import { Hono } from 'hono'
-
-import {
-  checkAccessSync,
-  resolveSession,
-  rowMatchesScope,
-  type AccessUser,
-  type AuthSessionResolver,
-  type ResolvedAccess,
-  type ResolvedTableAccess,
-} from '../access'
-
-export type RealtimeAction = 'create' | 'update' | 'delete'
-
-type Subscriber = {
-  id: string
-  send: (data: string) => void
-  user: AccessUser | null
-  activeOrganizationId: string | null
-  subscriptions: Set<string>
-}
-
-type BufferedEvent = {
-  eventId: number
-  table: string
-  action: RealtimeAction
-  record: Record<string, unknown>
-}
-
-type RealtimeContextBody = {
-  clientId: string
-  subscriptions: string[]
-  since?: number | null
-}
-
-export type RealtimeBroker = {
-  start(): Promise<void>
-  close(): Promise<void>
-  register(send: (data: string) => void): { id: string }
-  setContext(
-    id: string,
-    ctx: {
-      user: AccessUser | null
-      activeOrganizationId: string | null
-      subscriptions: Set<string>
-      since?: number | null
-    },
-  ): { gap: boolean } | Promise<{ gap: boolean }>
-  unregister(id: string): void
-  publish(
-    table: string,
-    action: RealtimeAction,
-    record: Record<string, unknown>,
-  ): void | Promise<void>
-}
-
-function tableEntry(
-  access: ResolvedAccess,
-  tableName: string,
-): ResolvedTableAccess | undefined {
-  for (const entry of access.values()) {
-    if (entry.tableName === tableName) return entry
-  }
-  return undefined
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
-function isRealtimeContextBody(value: unknown): value is RealtimeContextBody {
-  if (!isRecord(value)) return false
-  return (
-    typeof value.clientId === 'string' &&
-    Array.isArray(value.subscriptions) &&
-    value.subscriptions.every((item) => typeof item === 'string') &&
-    (value.since === undefined ||
-      value.since === null ||
-      typeof value.since === 'number')
-  )
-}
-
-function scopeOk(
-  entry: ResolvedTableAccess,
-  ctx: Parameters<typeof checkAccessSync>[1],
-  record: Record<string, unknown>,
-): boolean {
-  if (!entry.readScope) return true
-  return rowMatchesScope(record, entry.readScope(ctx))
-}
-
-export function buildRealtimeRouter(
-  broker: RealtimeBroker,
-  opts: { auth?: AuthSessionResolver; keepaliveMs?: number },
-): Hono {
-  const router = new Hono()
-  const keepaliveMs = opts.keepaliveMs ?? 30000
-
-  router.get('/realtime', () => {
-    const encoder = new TextEncoder()
-    let handle: { id: string }
-    let keepalive: ReturnType<typeof setInterval>
-
-    const stream = new ReadableStream({
-      async start(controller) {
-        await broker.start()
-        const send = (data: string) =>
-          controller.enqueue(encoder.encode(`data: ${data}\n\n`))
-        handle = broker.register(send)
-        send(JSON.stringify({ clientId: handle.id }))
-        keepalive = setInterval(
-          () => controller.enqueue(encoder.encode(': ping\n\n')),
-          keepaliveMs,
-        )
-      },
-      cancel() {
-        clearInterval(keepalive)
-        broker.unregister(handle.id)
-      },
-    })
-
-    return new Response(stream, {
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-      },
-    })
-  })
-
-  router.post('/realtime', async (c) => {
-    const body = await c.req.json().catch(() => null)
-    if (!isRealtimeContextBody(body)) {
-      return c.json({ error: 'clientId and subscriptions required' }, 400)
-    }
-    const { user, activeOrganizationId } = await resolveSession(
-      opts.auth,
-      c.req.raw.headers,
-    )
-    const { gap } = await broker.setContext(body.clientId, {
-      user,
-      activeOrganizationId,
-      subscriptions: new Set(body.subscriptions),
-      since: body.since ?? null,
-    })
-    return c.json({ gap }, 200)
-  })
-
-  return router
-}
-
-export function createRealtimeBroker(opts: {
-  access: ResolvedAccess
-  bufferSize?: number
-}): RealtimeBroker {
-  const subscribers = new Map<string, Subscriber>()
-  const bufferSize = opts.bufferSize ?? 1000
-  const buffer: BufferedEvent[] = []
-  let nextId = 1
-
-  // Returns true when this subscriber should receive this record (topic + access + scope).
-  function deliverable(
-    s: Subscriber,
-    table: string,
-    record: Record<string, unknown>,
-    id: unknown,
-  ): boolean {
-    const entry = tableEntry(opts.access, table)
-    if (!entry) return false
-    const topicMatch =
-      s.subscriptions.has(table) ||
-      (id != null && s.subscriptions.has(`${table}/${String(id)}`))
-    if (!topicMatch) return false
-    const ctx = {
-      user: s.user,
-      request: new Request('http://realtime.local'),
-      row: record,
-      session: { activeOrganizationId: s.activeOrganizationId },
-    }
-    if (typeof entry.get === 'function') return false // function get-rules unsupported on realtime v1
-    if (!checkAccessSync(entry.get, ctx, entry.ownerColumn).allowed)
-      return false
-    if (!scopeOk(entry, ctx, record)) return false
-    return true
-  }
-
-  return {
-    async start() {},
-    async close() {},
-    register(send) {
-      const id = crypto.randomUUID()
-      subscribers.set(id, {
-        id,
-        send,
-        user: null,
-        activeOrganizationId: null,
-        subscriptions: new Set(),
-      })
-      return { id }
-    },
-    setContext(id, ctx) {
-      const s = subscribers.get(id)
-      if (!s) return { gap: false }
-      s.user = ctx.user
-      s.activeOrganizationId = ctx.activeOrganizationId
-      s.subscriptions = ctx.subscriptions
-
-      const since = ctx.since ?? null
-      if (since == null) return { gap: false } // fresh client; current data already loaded by queries
-
-      const maxId = nextId - 1
-      // since ahead of anything we issued => server restarted / different epoch => full catch-up.
-      if (since > maxId) return { gap: true }
-      const oldest = buffer.length ? buffer[0]!.eventId : nextId
-      const gap = since < oldest - 1 // events between since and oldest were evicted
-      for (const e of buffer) {
-        if (e.eventId <= since) continue
-        if (!deliverable(s, e.table, e.record, e.record['id'])) continue
-        s.send(
-          JSON.stringify({
-            eventId: e.eventId,
-            action: e.action,
-            table: e.table,
-            record: e.record,
-          }),
-        )
-      }
-      return { gap }
-    },
-    unregister(id) {
-      subscribers.delete(id)
-    },
-    publish(table, action, record) {
-      const entry = tableEntry(opts.access, table)
-      if (!entry) return
-      const eventId = nextId++
-      buffer.push({ eventId, table, action, record })
-      if (buffer.length > bufferSize) buffer.shift()
-      const id = record['id']
-      const payload = JSON.stringify({ eventId, action, table, record })
-      for (const s of subscribers.values()) {
-        if (!deliverable(s, table, record, id)) continue
-        s.send(payload)
-      }
-    },
-  }
-}
-
-export const createMemoryRealtimeBroker = createRealtimeBroker