bunderstack 0.16.0 → 0.17.0-beta.2

package/src/crud.ts

@@ -1,400 +0,0 @@
-import { eq, getTableColumns, getTableName, isTable } from 'drizzle-orm'
-import { Hono } from 'hono'
-
-import type { AnyDb } from './dialect'
-import type { RealtimeFacade } from './realtime/facade'
-
-import {
-  checkAccess,
-  resolveSession,
-  rowMatchesScope,
-  stampScope,
-  sanitizeWriteBody,
-  type AccessUser,
-  type AuthSessionResolver,
-  type CrudOperation,
-  type ResolvedAccess,
-  tableEntryForName,
-  type ResolvedTableAccess,
-  type ScopeMap,
-  type ScopeResolver,
-  type AccessContext,
-} from './access'
-import { ErrorCode, apiError, ListQueryError } from './errors'
-import {
-  lookupIdempotency,
-  resolveIdempotencyConfig,
-  storeIdempotency,
-  type IdempotencyConfig,
-} from './idempotency'
-import { executeList, parseListParams } from './list-query'
-import { buildScopeWhere } from './scope'
-
-export type CrudRouterOptions<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-> = {
-  auth?: AuthSessionResolver
-  access: ResolvedAccess
-  idempotency?: boolean | IdempotencyConfig
-  realtime?: RealtimeFacade<TSchema>
-}
-
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
-async function enforce(
-  operation: CrudOperation,
-  access: ResolvedTableAccess,
-  ctx: Parameters<typeof checkAccess>[1],
-) {
-  const rule = access[operation]
-  const result = await checkAccess(rule, ctx, access.ownerColumn)
-  return result
-}
-
-export function buildCrudRouter<TSchema extends Record<string, unknown>>(
-  schema: TSchema,
-  db: AnyDb,
-  options: CrudRouterOptions<TSchema>,
-): Hono {
-  const router = new Hono()
-  const { auth, access, realtime } = options
-  const idempotency = resolveIdempotencyConfig(options.idempotency)
-
-  const scopeFor = (
-    resolver: ScopeResolver | undefined,
-    ctx: AccessContext,
-  ): ScopeMap | undefined => (resolver ? resolver(ctx) : undefined)
-
-  for (const table of Object.values(schema)) {
-    if (!isTable(table)) continue
-
-    const name = getTableName(table)
-    const tableAccess = tableEntryForName(access, name)
-    if (!tableAccess?.enabled) continue
-
-    const idCol = getTableColumns(table)['id']
-    if (!idCol) continue
-
-    router.get(`/${name}`, async (c) => {
-      const { user, activeOrganizationId } = await resolveSession(
-        auth,
-        c.req.raw.headers,
-      )
-      const session = { activeOrganizationId }
-      const denied = await enforce('list', tableAccess, {
-        user,
-        session,
-        request: c.req.raw,
-      })
-      if (!denied.allowed) {
-        return apiError(
-          c,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-          denied.status === 401 ? 401 : 403,
-        )
-      }
-
-      try {
-        const params = parseListParams(new URL(c.req.url), tableAccess)
-        const scope = scopeFor(tableAccess.readScope, {
-          user,
-          session,
-          request: c.req.raw,
-        })
-        const scopeWhere = scope ? buildScopeWhere(table, scope) : undefined
-        const result = await executeList(
-          db,
-          table,
-          tableAccess,
-          params,
-          idCol,
-          scopeWhere,
-        )
-        return c.json(result)
-      } catch (err) {
-        if (err instanceof ListQueryError) {
-          return apiError(c, err.code, err.message, 400, err.details)
-        }
-        throw err
-      }
-    })
-
-    router.get(`/${name}/:id`, async (c) => {
-      const { user, activeOrganizationId } = await resolveSession(
-        auth,
-        c.req.raw.headers,
-      )
-      const session = { activeOrganizationId }
-      const rawId = c.req.param('id')
-      const id = isNaN(Number(rawId)) ? rawId : Number(rawId)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const rows = await (db as any)
-        .select()
-        .from(table)
-        .where(eq(idCol as any, id))
-      if (!rows[0]) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      const denied = await enforce('get', tableAccess, {
-        user,
-        session,
-        request: c.req.raw,
-        row: rows[0] as Record<string, unknown>,
-      })
-      if (!denied.allowed) {
-        return apiError(
-          c,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-          denied.status === 401 ? 401 : 403,
-        )
-      }
-
-      const scope = scopeFor(tableAccess.readScope, {
-        user,
-        session,
-        request: c.req.raw,
-      })
-      if (
-        scope &&
-        !rowMatchesScope(rows[0] as Record<string, unknown>, scope)
-      ) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      return c.json(rows[0])
-    })
-
-    router.post(`/${name}`, async (c) => {
-      const { user, activeOrganizationId } = await resolveSession(
-        auth,
-        c.req.raw.headers,
-      )
-      const session = { activeOrganizationId }
-      const denied = await enforce('create', tableAccess, {
-        user,
-        session,
-        request: c.req.raw,
-      })
-      if (!denied.allowed) {
-        return apiError(
-          c,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-          denied.status === 401 ? 401 : 403,
-        )
-      }
-
-      const rawBody = await c.req.text()
-      let body: unknown
-      try {
-        body = rawBody ? JSON.parse(rawBody) : null
-      } catch {
-        return apiError(c, ErrorCode.VALIDATION_ERROR, 'Invalid JSON', 400)
-      }
-      if (!isRecord(body)) {
-        return apiError(c, ErrorCode.VALIDATION_ERROR, 'Invalid JSON body', 400)
-      }
-
-      const idempotencyKey = c.req.header('Idempotency-Key')?.trim()
-      if (idempotency && idempotencyKey) {
-        const lookup = await lookupIdempotency(
-          db,
-          name,
-          idempotencyKey,
-          rawBody,
-          idempotency,
-        )
-        if (lookup.type === 'conflict') {
-          return apiError(
-            c,
-            ErrorCode.IDEMPOTENCY_CONFLICT,
-            'Idempotency key reused with different body',
-            409,
-          )
-        }
-        if (lookup.type === 'replay') {
-          return new Response(lookup.response, {
-            status: lookup.status,
-            headers: {
-              'Content-Type': 'application/json',
-              'Idempotency-Replayed': 'true',
-            },
-          })
-        }
-      }
-
-      const values = sanitizeWriteBody(
-        body,
-        tableAccess,
-        'create',
-        user?.id ?? null,
-      )
-
-      const scope = scopeFor(tableAccess.writeScope, {
-        user,
-        session,
-        request: c.req.raw,
-        body: body as Record<string, unknown>,
-      })
-      const stamped = scope ? stampScope(values, scope) : values
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const rows = await (db as any).insert(table).values(stamped).returning()
-      const created = rows[0]
-      void realtime?.publish(table as never, 'create', created as never)
-
-      if (idempotency && idempotencyKey) {
-        await storeIdempotency(
-          db,
-          name,
-          idempotencyKey,
-          rawBody,
-          201,
-          created,
-          idempotency,
-        )
-      }
-
-      return c.json(created, 201)
-    })
-
-    router.patch(`/${name}/:id`, async (c) => {
-      const { user, activeOrganizationId } = await resolveSession(
-        auth,
-        c.req.raw.headers,
-      )
-      const session = { activeOrganizationId }
-      const rawId = c.req.param('id')
-      const id = isNaN(Number(rawId)) ? rawId : Number(rawId)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const existing = await (db as any)
-        .select()
-        .from(table)
-        .where(eq(idCol as any, id))
-      if (!existing[0]) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      const readScope = scopeFor(tableAccess.readScope, {
-        user,
-        session,
-        request: c.req.raw,
-      })
-      if (
-        readScope &&
-        !rowMatchesScope(existing[0] as Record<string, unknown>, readScope)
-      ) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      const denied = await enforce('update', tableAccess, {
-        user,
-        session,
-        request: c.req.raw,
-        row: existing[0] as Record<string, unknown>,
-      })
-      if (!denied.allowed) {
-        return apiError(
-          c,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-          denied.status === 401 ? 401 : 403,
-        )
-      }
-
-      let body: unknown
-      try {
-        body = await c.req.json()
-      } catch {
-        return apiError(c, ErrorCode.VALIDATION_ERROR, 'Invalid JSON', 400)
-      }
-      if (!isRecord(body)) {
-        return apiError(c, ErrorCode.VALIDATION_ERROR, 'Invalid JSON body', 400)
-      }
-
-      const values = sanitizeWriteBody(
-        body,
-        tableAccess,
-        'update',
-        user?.id ?? null,
-      )
-
-      const writeScope = scopeFor(tableAccess.writeScope, {
-        user,
-        session,
-        request: c.req.raw,
-        body: body as Record<string, unknown>,
-      })
-      const stamped = writeScope ? stampScope(values, writeScope) : values
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const rows = await (db as any)
-        .update(table)
-        .set(stamped)
-        .where(eq(idCol as any, id))
-        .returning()
-      if (!rows[0]) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-      void realtime?.publish(table as never, 'update', rows[0] as never)
-      return c.json(rows[0])
-    })
-
-    router.delete(`/${name}/:id`, async (c) => {
-      const { user, activeOrganizationId } = await resolveSession(
-        auth,
-        c.req.raw.headers,
-      )
-      const session = { activeOrganizationId }
-      const rawId = c.req.param('id')
-      const id = isNaN(Number(rawId)) ? rawId : Number(rawId)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const existing = await (db as any)
-        .select()
-        .from(table)
-        .where(eq(idCol as any, id))
-      if (!existing[0]) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      const scope = scopeFor(tableAccess.readScope, {
-        user,
-        session,
-        request: c.req.raw,
-      })
-      if (
-        scope &&
-        !rowMatchesScope(existing[0] as Record<string, unknown>, scope)
-      ) {
-        return apiError(c, ErrorCode.NOT_FOUND, 'Not found', 404)
-      }
-
-      const denied = await enforce('delete', tableAccess, {
-        user,
-        session,
-        request: c.req.raw,
-        row: existing[0] as Record<string, unknown>,
-      })
-      if (!denied.allowed) {
-        return apiError(
-          c,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-          denied.status === 401 ? 401 : 403,
-        )
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      await (db as any).delete(table).where(eq(idCol as any, id))
-      void realtime?.publish(table as never, 'delete', existing[0] as never)
-      return new Response(null, { status: 204 })
-    })
-  }
-
-  return router
-}

package/src/realtime/index.ts

@@ -1,242 +0,0 @@
-// packages/bunderstack/src/realtime.ts
-import { Hono } from 'hono'
-
-import {
-  checkAccessSync,
-  resolveSession,
-  rowMatchesScope,
-  tableEntryForName,
-  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 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 = tableEntryForName(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 = tableEntryForName(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