bunderstack 0.17.0-beta.2 → 0.17.0-beta.4

package/src/provision.ts

@@ -1,128 +0,0 @@
-// src/provision.ts
-import { access, mkdir } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
-
-import type { AnyDb, Dialect } from './dialect'
-
-import { detectDialect } from './dialect'
-import {
-  PROVISION_INTERNALS,
-  type WithProvisionInternals,
-} from './provision-internals'
-
-/** Create the local backing directory for file-based urls, per dialect. */
-async function ensureLocalDataDir(
-  url: string,
-  dialect: Dialect,
-): Promise<void> {
-  if (dialect === 'pg') {
-    // PGlite data dir: `file:<dir>` or a bare path; server/memory urls need nothing.
-    if (/^postgres(ql)?:\/\//.test(url)) return
-    const raw = url.startsWith('file:') ? url.slice('file:'.length) : url
-    if (raw === ':memory:' || raw.startsWith('memory://')) return
-    await mkdir(raw, { recursive: true })
-    return
-  }
-  const match = /^file:(.+)$/.exec(url)
-  if (!match) return
-  const filePath = match[1]!
-  if (filePath === ':memory:') return
-  await mkdir(dirname(filePath), { recursive: true })
-}
-
-async function exists(path: string): Promise<boolean> {
-  try {
-    await access(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-const DRIZZLE_KIT_HINT =
-  '[bunderstack] Schema push requires drizzle-kit, which is not installed.\n' +
-  '  Development: run `bun add -d drizzle-kit` — provision() will push schema changes to the database on startup.\n' +
-  '  Production: generate migrations locally with `bunx drizzle-kit generate` and commit the folder — provision() applies them without drizzle-kit.'
-
-/** Push the merged schema to the database via drizzle-kit/api. */
-export async function provisionSchema<TSchema extends Record<string, unknown>>(
-  db: AnyDb,
-  schema: TSchema,
-  options?: { force?: boolean; databaseUrl?: string },
-): Promise<void> {
-  const dialect = detectDialect(schema)
-  if (options?.databaseUrl) {
-    await ensureLocalDataDir(options.databaseUrl, dialect)
-  }
-
-  let kit: typeof import('drizzle-kit/api')
-  try {
-    kit = await import('drizzle-kit/api')
-  } catch (cause) {
-    throw new Error(DRIZZLE_KIT_HINT, { cause })
-  }
-
-  const result =
-    dialect === 'pg'
-      ? await kit.pushSchema(schema, db as never)
-      : await kit.pushSQLiteSchema(schema, db as never)
-
-  if (result.hasDataLoss && !options?.force) {
-    throw new Error(
-      '[bunderstack] Schema push would cause data loss. Run `bunx drizzle-kit push` or call provision(app, { force: true }).',
-    )
-  }
-
-  if (result.warnings.length > 0) {
-    for (const warning of result.warnings) {
-      console.warn(`[bunderstack] ${warning}`)
-    }
-  }
-
-  if (result.statementsToExecute.length === 0) return
-
-  await result.apply()
-
-  console.log(
-    `[bunderstack] provisioned ${result.statementsToExecute.length} schema change(s)`,
-  )
-}
-
-/**
- * Provision the database for a Bunderstack app.
- *
- * The migrations folder is the mode switch:
- * - `<migrations>/meta/_journal.json` exists → apply committed migrations via
- *   drizzle-orm's migrator. Pure runtime; drizzle-kit is never imported, so a
- *   fresh clone deploys with `bun install --production`.
- * - No migrations → development: push the schema straight to the database via
- *   drizzle-kit (install it with `bun add -d drizzle-kit`).
- *
- * Once you run `bunx drizzle-kit generate` for the first time, provision stops
- * pushing and every schema change goes through an explicit `generate`.
- */
-export async function provision(
-  app: object,
-  options?: { force?: boolean },
-): Promise<void> {
-  if (process.env.BUNDERSTACK_INTROSPECT === '1') return
-
-  const internals = (app as WithProvisionInternals)[PROVISION_INTERNALS]
-  if (!internals) {
-    throw new Error(
-      '[bunderstack] provision() expects the app returned by createBunderstack().',
-    )
-  }
-
-  const { db, schema, databaseUrl, migrationsFolder, dialect, adapter } =
-    internals
-  const journal = join(migrationsFolder, 'meta', '_journal.json')
-
-  if (await exists(journal)) {
-    await ensureLocalDataDir(databaseUrl, dialect)
-    await adapter.migrate(db as never, migrationsFolder)
-    return
-  }
-
-  await provisionSchema(db, schema, { force: options?.force, databaseUrl })
-}

package/src/rate-limit.ts

@@ -1,71 +0,0 @@
-export type RateLimitConfig = {
-  windowMs?: number
-  max?: number
-  skip?: (req: Request) => boolean
-}
-
-type Bucket = {
-  count: number
-  resetAt: number
-}
-
-const buckets = new Map<string, Bucket>()
-
-function resolveConfig(
-  config: boolean | RateLimitConfig | undefined,
-): RateLimitConfig | null {
-  if (!config) return null
-  if (config === true) return {}
-  return config
-}
-
-function clientKey(req: Request): string {
-  const forwarded = req.headers.get('x-forwarded-for')
-  if (forwarded) return forwarded.split(',')[0]!.trim()
-  return req.headers.get('x-real-ip') ?? 'local'
-}
-
-export function createRateLimiter(
-  config: boolean | RateLimitConfig | undefined,
-): (req: Request) => Promise<Response | null> {
-  const resolved = resolveConfig(config)
-  if (!resolved) {
-    return async (_req: Request) => null
-  }
-
-  const windowMs = resolved.windowMs ?? 60_000
-  const max = resolved.max ?? 100
-
-  return async (req: Request): Promise<Response | null> => {
-    if (resolved.skip?.(req)) return null
-
-    const key = `${clientKey(req)}:${new URL(req.url).pathname}`
-    const now = Date.now()
-    let bucket = buckets.get(key)
-
-    if (!bucket || bucket.resetAt <= now) {
-      bucket = { count: 0, resetAt: now + windowMs }
-      buckets.set(key, bucket)
-    }
-
-    bucket.count += 1
-    if (bucket.count > max) {
-      const retryAfter = Math.ceil((bucket.resetAt - now) / 1000)
-      return new Response(
-        JSON.stringify({
-          error: 'Too many requests',
-          code: 'TOO_MANY_REQUESTS',
-        }),
-        {
-          status: 429,
-          headers: {
-            'Content-Type': 'application/json',
-            'Retry-After': String(retryAfter),
-          },
-        },
-      )
-    }
-
-    return null
-  }
-}

package/src/realtime/facade.ts

@@ -1,74 +0,0 @@
-import {
-  getTableName,
-  isTable,
-  type InferSelectModel,
-  type Table,
-} from 'drizzle-orm'
-
-import type {
-  RealtimeAction,
-  RealtimePublisher,
-} from './publisher'
-
-export type RealtimeTransport = 'disabled' | 'memory' | 'redis'
-
-export type SchemaTable<TSchema extends Record<string, unknown>> = Extract<
-  TSchema[keyof TSchema],
-  Table
->
-
-export interface RealtimeFacade<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-> {
-  readonly enabled: boolean
-  readonly transport: RealtimeTransport
-
-  publish<TTable extends SchemaTable<TSchema>>(
-    table: TTable,
-    action: RealtimeAction,
-    record: InferSelectModel<TTable>,
-  ): Promise<void>
-}
-
-/**
- * One name for a table everywhere: events, subscriptions, and the CRUD router
- * all use the schema key. Pass the schema so a key like `creditBalances` is not
- * published as its SQL name `credit_balances` — clients subscribe with the key
- * they call procedures with. Without a schema, the SQL name is the only name
- * available and is used as-is.
- */
-export function createRealtimeFacade<TSchema extends Record<string, unknown>>(
-  publisher?: RealtimePublisher,
-  transport: RealtimeTransport = publisher ? 'memory' : 'disabled',
-  schema?: TSchema,
-): RealtimeFacade<TSchema> {
-  if (!publisher && transport !== 'disabled') {
-    throw new Error(
-      '[bunderstack] an enabled realtime transport requires a publisher',
-    )
-  }
-  if (publisher && transport === 'disabled') {
-    throw new Error(
-      '[bunderstack] a realtime publisher cannot use the disabled transport',
-    )
-  }
-
-  const keyByTableName = new Map<string, string>()
-  for (const [key, value] of Object.entries(schema ?? {})) {
-    if (isTable(value)) keyByTableName.set(getTableName(value), key)
-  }
-
-  return {
-    enabled: publisher !== undefined,
-    transport,
-    async publish(table, action, record) {
-      if (!publisher) return
-      const tableName = getTableName(table)
-      await publisher.publish('change', {
-        table: keyByTableName.get(tableName) ?? tableName,
-        action,
-        record: record as unknown as Record<string, unknown>,
-      })
-    },
-  }
-}

package/src/realtime/filter.ts

@@ -1,81 +0,0 @@
-import { getEventMeta, withEventMeta } from '@orpc/server'
-
-import type {
-  AccessUser,
-  ResolvedAccess,
-} from '../access'
-import type { RealtimeChange } from './publisher'
-
-import {
-  checkAccess,
-  rowMatchesScope,
-  tableEntryForName,
-} from '../access'
-
-export interface FilterRealtimeChangesOptions {
-  subscriptions: readonly string[]
-  access: ResolvedAccess
-  request: Request
-  getSession: () => Promise<{
-    user: AccessUser | null
-    activeOrganizationId: string | null
-  }>
-}
-
-export async function* filterRealtimeChanges(
-  source: AsyncIterable<RealtimeChange>,
-  options: FilterRealtimeChangesOptions,
-): AsyncGenerator<RealtimeChange, void, void> {
-  const subscriptions = new Set(options.subscriptions)
-  let sessionPromise:
-    | ReturnType<FilterRealtimeChangesOptions['getSession']>
-    | undefined
-  const getSession = () => (sessionPromise ??= options.getSession())
-
-  for await (const change of source) {
-    // Events name tables by schema key; the SQL-name lookup stays as a fallback
-    // for publishers outside the CRUD path that only know the physical name.
-    const entry =
-      options.access.get(change.table) ??
-      tableEntryForName(options.access, change.table)
-    if (!entry?.enabled) continue
-
-    const recordId = change.record.id
-    if (
-      !subscriptions.has(change.table) &&
-      (recordId == null ||
-        !subscriptions.has(`${change.table}/${String(recordId)}`))
-    ) {
-      continue
-    }
-    if (entry.get === 'deny') continue
-
-    const needsSession = entry.get !== 'public' || entry.readScope !== undefined
-    const session = needsSession
-      ? await getSession()
-      : { user: null, activeOrganizationId: null }
-    const context = {
-      request: options.request,
-      user: session.user,
-      row: change.record,
-      session: { activeOrganizationId: session.activeOrganizationId },
-    }
-    if (!(await checkAccess(entry.get, context, entry.ownerColumn)).allowed) {
-      continue
-    }
-    if (
-      entry.readScope &&
-      !rowMatchesScope(change.record, entry.readScope(context))
-    ) {
-      continue
-    }
-
-    const projected: RealtimeChange = {
-      table: change.table,
-      action: change.action,
-      record: change.record,
-    }
-    const meta = getEventMeta(change)
-    yield meta ? withEventMeta(projected, meta) : projected
-  }
-}

package/src/realtime/heartbeat.ts

@@ -1,80 +0,0 @@
-export const REALTIME_HEARTBEAT_INTERVAL_MS = 5_000
-
-export type RealtimeHeartbeat = { type: 'heartbeat' }
-
-type SourceState<T> =
-  | { status: 'pending' }
-  | { status: 'ready'; result: IteratorResult<T> }
-  | { status: 'error'; error: unknown }
-
-/**
- * Emits a transport-only event whenever the source has been idle for an
- * interval. Heartbeats are deliberately not published, persisted, or assigned
- * event IDs, so they do not affect replay and resume semantics.
- */
-export async function* withRealtimeHeartbeat<T>(
-  source: AsyncIterable<T>,
-  options: { intervalMs?: number; signal?: AbortSignal },
-): AsyncGenerator<T | RealtimeHeartbeat, void, void> {
-  const intervalMs = Math.max(
-    1,
-    options.intervalMs ?? REALTIME_HEARTBEAT_INTERVAL_MS,
-  )
-  const iterator = source[Symbol.asyncIterator]()
-  let state: SourceState<T> = { status: 'pending' }
-  let wake: (() => void) | undefined
-  const getState = (): SourceState<T> => state
-
-  const requestNext = () => {
-    state = { status: 'pending' }
-    void iterator.next().then(
-      (result) => {
-        state = { status: 'ready', result }
-        wake?.()
-      },
-      (error: unknown) => {
-        state = { status: 'error', error }
-        wake?.()
-      },
-    )
-  }
-
-  requestNext()
-  try {
-    while (!options.signal?.aborted) {
-      let current = getState()
-      if (current.status === 'pending') {
-        await new Promise<void>((resolve) => {
-          let settled = false
-          const finish = () => {
-            if (settled) return
-            settled = true
-            clearTimeout(timer)
-            options.signal?.removeEventListener('abort', finish)
-            resolve()
-          }
-          const timer = setTimeout(finish, intervalMs)
-          options.signal?.addEventListener('abort', finish, { once: true })
-          wake = finish
-        })
-        wake = undefined
-
-        if (options.signal?.aborted) break
-        current = getState()
-        if (current.status === 'pending') {
-          yield { type: 'heartbeat' }
-          continue
-        }
-      }
-
-      if (current.status === 'error') throw current.error
-      if (current.result.done) break
-
-      yield current.result.value
-      requestNext()
-    }
-  } finally {
-    wake = undefined
-    await iterator.return?.()
-  }
-}

package/src/realtime/publisher.ts

@@ -1,46 +0,0 @@
-import type { Publisher } from '@orpc/publisher'
-import type { RedisClient } from 'bun'
-
-import { BunRedisPublisher } from '@orpc/bun'
-import { MemoryPublisher } from '@orpc/publisher/memory'
-
-export type RealtimeAction = 'create' | 'update' | 'delete'
-
-export interface RealtimeChange {
-  table: string
-  action: RealtimeAction
-  record: Record<string, unknown>
-}
-
-export interface RealtimeEvents extends Record<string, object> {
-  change: RealtimeChange
-}
-
-export type RealtimePublisher = Publisher<RealtimeEvents>
-
-export interface RealtimePublisherOptions {
-  maxBufferedEvents?: number
-  resumeSeconds?: number
-}
-
-export function createMemoryRealtimePublisher(
-  options: RealtimePublisherOptions = {},
-): RealtimePublisher {
-  return new MemoryPublisher<RealtimeEvents>({
-    maxBufferedEvents: options.maxBufferedEvents,
-    resume: { enabled: true, seconds: options.resumeSeconds ?? 300 },
-  })
-}
-
-export function createRedisRealtimePublisher(
-  redis: RedisClient,
-  subscriber: RedisClient | Promise<RedisClient>,
-  options: RealtimePublisherOptions & { prefix?: string } = {},
-): RealtimePublisher {
-  return new BunRedisPublisher<RealtimeEvents>(redis, {
-    subscriber,
-    prefix: options.prefix ?? 'bunderstack:',
-    maxBufferedEvents: options.maxBufferedEvents,
-    resume: { enabled: true, seconds: options.resumeSeconds ?? 300 },
-  })
-}

package/src/schema-export-pg.ts

@@ -1,7 +0,0 @@
-// src/schema-export-pg.ts — pg twins under the same names bunderstack/schema
-// uses, so `export * from 'bunderstack/schema/pg'` mirrors the sqlite setup.
-export {
-  bunderstackFilesPg as bunderstackFiles,
-  bunderstackIdempotencyPg as bunderstackIdempotency,
-  bunderstackJobsPg as bunderstackJobs,
-} from './internal-tables-pg'

package/src/schema-export.ts

@@ -1,5 +0,0 @@
-export {
-  bunderstackFiles,
-  bunderstackIdempotency,
-  bunderstackJobs,
-} from './internal-tables'

package/src/scope.ts

@@ -1,17 +0,0 @@
-import { and, eq, getTableColumns, inArray, type SQL } from 'drizzle-orm'
-
-import type { ScopeMap } from './access'
-
-export function buildScopeWhere(
-  table: Parameters<typeof getTableColumns>[0],
-  scope: ScopeMap,
-): SQL | undefined {
-  const columns = getTableColumns(table)
-  const conditions: SQL[] = []
-  for (const [name, value] of Object.entries(scope)) {
-    const col = columns[name]
-    if (!col) continue
-    conditions.push(Array.isArray(value) ? inArray(col, value) : eq(col, value))
-  }
-  return conditions.length ? and(...conditions) : undefined
-}

package/src/standard-schema.ts

@@ -1,59 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
-
-export type StandardSchema = StandardSchemaV1
-export type InferStandardOutput<TSchema extends StandardSchemaV1> =
-  StandardSchemaV1.InferOutput<TSchema>
-
-export type StandardSchemaIssue = {
-  path: PropertyKey[]
-  message: string
-}
-
-export class StandardSchemaValidationError extends Error {
-  readonly issues: StandardSchemaIssue[]
-
-  constructor(label: string, issues: readonly StandardSchemaV1.Issue[]) {
-    const normalized = issues.map((issue) => ({
-      path: [...(issue.path ?? [])].map((segment) =>
-        typeof segment === 'object' ? segment.key : segment,
-      ),
-      message: issue.message,
-    }))
-    super(
-      normalized
-        .map((issue) => {
-          const path = issue.path.map(String).join('.')
-          return `${label}${path ? `.${path}` : ''}: ${issue.message}`
-        })
-        .join('\n'),
-    )
-    this.name = 'StandardSchemaValidationError'
-    this.issues = normalized
-  }
-}
-
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'then' in value &&
-    typeof value.then === 'function'
-  )
-}
-
-export function validateStandardSchema<TSchema extends StandardSchemaV1>(
-  schema: TSchema,
-  value: unknown,
-  label: string,
-): StandardSchemaV1.InferOutput<TSchema> {
-  const result = schema['~standard'].validate(value)
-  if (isPromiseLike(result)) {
-    throw new Error(
-      `[bunderstack] ${label} schema validation must be synchronous`,
-    )
-  }
-  if (result.issues) {
-    throw new StandardSchemaValidationError(label, result.issues)
-  }
-  return result.value
-}