bunderstack 0.17.0-beta.0 → 0.17.0-beta.3

package/src/config.ts

@@ -1,215 +0,0 @@
-// src/config.ts
-import { betterAuth } from 'better-auth'
-import * as v from 'valibot'
-
-import type { AnyRouter } from '@orpc/server'
-import type { AuthSessionResolver, TableAccessInput } from './access'
-import type { BunderstackApiBuilder } from './api/builder'
-import type { DatabaseAdapter } from './database/adapter'
-import type { EmailConfigInput } from './email'
-import type { IdempotencyConfig } from './idempotency'
-import type { RateLimitConfig } from './rate-limit'
-
-import { validateEnv, type BaseEnv, type EnvConfigInput, type ValidatedEnv } from './env'
-import {
-  resolveBuckets,
-  type ResolvedStorageBuckets,
-  type StorageConfigInput,
-} from './storage/buckets'
-
-export type BetterAuthConfig = Omit<
-  NonNullable<Parameters<typeof betterAuth>[0]>,
-  'database'
->
-
-// Only the union-shaped options need runtime validation: they are the ones a
-// JavaScript caller can plausibly get wrong in a way that fails confusingly
-// downstream. Everything else is either typed-only or read raw from `options`.
-const RuntimeOptionsSchema = v.object({
-  rateLimit: v.optional(
-    v.union([
-      v.boolean(),
-      v.object({
-        windowMs: v.optional(v.number()),
-        max: v.optional(v.number()),
-      }),
-    ]),
-  ),
-  idempotency: v.optional(
-    v.union([v.boolean(), v.object({ ttlMs: v.optional(v.number()) })]),
-  ),
-  realtime: v.optional(
-    v.union([
-      v.boolean(),
-      v.object({
-        bufferSize: v.optional(v.number()),
-        resumeSeconds: v.optional(v.number()),
-        redis: v.optional(
-          v.union([
-            v.string(),
-            v.object({ url: v.string(), token: v.optional(v.string()) }),
-          ]),
-        ),
-      }),
-    ]),
-  ),
-  openapi: v.optional(v.boolean()),
-})
-
-export type BunderstackConfig<
-  TSchema extends Record<string, unknown>,
-  TAccess extends Record<string, TableAccessInput> | undefined =
-    | Record<string, TableAccessInput>
-    | undefined,
-  TStorage extends StorageConfigInput | undefined =
-    | StorageConfigInput
-    | undefined,
-  TEnv extends EnvConfigInput | undefined = EnvConfigInput | undefined,
-  TCustomApiRouter extends AnyRouter | undefined = AnyRouter | undefined,
-> = {
-  schema: TSchema
-  access?: TAccess
-  database: {
-    adapter: DatabaseAdapter
-    url?: string
-    authToken?: string
-    migrations?: string
-  }
-  auth?: BetterAuthConfig
-  /**
-   * Reuse an application-owned session reader for the unified API while
-   * keeping Bunderstack's auth handler available.
-   */
-  authResolver?: AuthSessionResolver
-  storage?: TStorage
-  env?: TEnv
-  /**
-   * Stand-in for `process.env`. Feeds both env validation and platform
-   * overrides, so tests and embedders have one injection point instead of
-   * three.
-   */
-  processEnv?: Record<string, string | undefined>
-  background?: { autoStart?: boolean }
-  email?: EmailConfigInput
-  /**
-   * Unified oRPC API builder callback.
-   */
-  api?: (
-    builder: BunderstackApiBuilder<TSchema, ValidatedEnv<TEnv>>,
-  ) => TCustomApiRouter
-  rateLimit?: boolean | RateLimitConfig
-  idempotency?: boolean | IdempotencyConfig
-  /** Generate and serve `/api/openapi.json`. Disabled by default. */
-  openapi?: boolean
-  realtime?:
-    | boolean
-    | {
-        bufferSize?: number
-        resumeSeconds?: number
-        redis?: string | { url: string; token?: string }
-      }
-}
-
-export type ResolvedConfig = {
-  database: {
-    adapter: DatabaseAdapter
-    url: string
-    authToken?: string
-    migrations: string
-  }
-  auth: BetterAuthConfig
-  storage: ResolvedStorageBuckets
-  realtime?:
-    | boolean
-    | {
-        bufferSize?: number
-        resumeSeconds?: number
-        redis?: string | { url: string; token?: string }
-      }
-}
-
-export function resolveConfig<
-  TSchema extends Record<string, unknown>,
-  TAccess extends Record<string, TableAccessInput> | undefined = undefined,
-  TStorage extends StorageConfigInput | undefined = undefined,
-  TEnv extends EnvConfigInput | undefined = undefined,
-  TCustomApiRouter extends AnyRouter | undefined = undefined,
->(
-  options: BunderstackConfig<
-    TSchema,
-    TAccess,
-    TStorage,
-    TEnv,
-    TCustomApiRouter
-  >,
-  env?: BaseEnv,
-  // Platform-injected overrides (Bunderhost & co.) beat code-level config so
-  // apps with hardcoded local urls deploy unchanged.
-  platformSource: Record<string, string | undefined> = process.env as Record<
-    string,
-    string | undefined
-  >,
-): ResolvedConfig {
-  const parsed = v.parse(RuntimeOptionsSchema, options)
-  // Self-validate when the caller didn't pass a pre-validated env, so
-  // resolveConfig stays usable standalone.
-  const resolvedEnv =
-    env ?? validateEnv(options.env as EnvConfigInput | undefined)
-
-  const adapter = options.database?.adapter
-  if (!adapter) {
-    throw new Error('[bunderstack] database.adapter is required')
-  }
-
-  const defaultUrl =
-    adapter.dialect === 'sqlite' ? 'file:./data.db' : 'file:./data.pglite'
-
-  return {
-    database: {
-      adapter,
-      url:
-        platformSource['BUNDERSTACK_DATABASE_URL'] ??
-        options.database?.url ??
-        resolvedEnv.DATABASE_URL ??
-        defaultUrl,
-      authToken:
-        platformSource['BUNDERSTACK_DATABASE_AUTH_TOKEN'] ??
-        options.database?.authToken ??
-        resolvedEnv.DATABASE_AUTH_TOKEN,
-      migrations: options.database?.migrations ?? './migrations',
-    },
-    auth: (() => {
-      const authInput = options.auth ?? {}
-      return {
-        ...authInput,
-        secret: authInput.secret ?? resolvedEnv.AUTH_SECRET,
-      }
-    })(),
-    storage: resolveBuckets(options.storage, platformSource),
-    realtime: parsed.realtime,
-  }
-}
-
-export function resolveRealtimeRedisUrl(
-  realtime: ResolvedConfig['realtime'],
-  env?: BaseEnv,
-  platformSource: Record<string, string | undefined> = process.env as Record<
-    string,
-    string | undefined
-  >,
-): string | undefined {
-  const platformRedis = platformSource['REDIS_URL']
-  if (platformRedis) return platformRedis
-
-  const envRedis = env?.REDIS_URL
-  if (envRedis) return envRedis
-
-  const fromConfig =
-    typeof realtime === 'object' && realtime.redis
-      ? typeof realtime.redis === 'string'
-        ? realtime.redis
-        : realtime.redis.url
-      : undefined
-
-  return fromConfig ?? undefined
-}

package/src/cron.ts

@@ -1,3 +0,0 @@
-export { cronMatches, parseCron } from './jobs/cron'
-export { floorSlot, slotsDue, CRON_PREFIX, SLOT_MS } from './jobs/slots'
-export type { CatchUp } from './jobs/slots'

package/src/crud-operations.ts

@@ -1,488 +0,0 @@
-import {
-  eq,
-  getTableColumns,
-  getTableName,
-  isTable,
-  type Table,
-} from 'drizzle-orm'
-
-import type { AnyDb } from './dialect'
-import type { RealtimeFacade } from './realtime/facade'
-
-import {
-  checkAccess,
-  rowMatchesScope,
-  sanitizeWriteBody,
-  stampScope,
-  tableEntryForName,
-  type AccessUser,
-  type ResolvedAccess,
-  type ResolvedTableAccess,
-  type ScopeMap,
-  type ScopeResolver,
-} from './access'
-import {
-  BunderstackError,
-  ErrorCode,
-  ListQueryError,
-  type BunderstackErrorCode,
-  type ErrorCodeValue,
-} from './errors'
-import {
-  lookupIdempotency,
-  resolveIdempotencyConfig,
-  storeIdempotency,
-  type IdempotencyConfig,
-} from './idempotency'
-import { executeList, parseListParams, type ListResult } from './list-query'
-import { buildScopeWhere } from './scope'
-
-export interface CrudExecutionContext {
-  request: Request
-  user: AccessUser | null
-  session: { activeOrganizationId: string | null }
-}
-
-function errorCodeForStatus(status: number): BunderstackErrorCode {
-  if (status === 401) return 'UNAUTHORIZED'
-  if (status === 403) return 'FORBIDDEN'
-  if (status === 404) return 'NOT_FOUND'
-  if (status === 409) return 'CONFLICT'
-  if (status === 413) return 'PAYLOAD_TOO_LARGE'
-  if (status === 429) return 'RATE_LIMITED'
-  return 'VALIDATION_ERROR'
-}
-
-export class CrudOperationError extends BunderstackError {
-  constructor(
-    status: number,
-    readonly legacyCode: ErrorCodeValue,
-    message: string,
-    details?: unknown,
-  ) {
-    const code = errorCodeForStatus(status)
-    super(
-      code,
-      message,
-      legacyCode === code
-        ? details
-        : {
-            code: legacyCode,
-            ...(details === undefined ? {} : { details }),
-          },
-    )
-    this.name = 'CrudOperationError'
-  }
-}
-
-export type CrudOperationsDeps<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
-> = {
-  schema: TSchema
-  db: AnyDb
-  access: ResolvedAccess
-  idempotency?: boolean | IdempotencyConfig
-  realtime?: RealtimeFacade<TSchema>
-}
-
-export type CreateResult =
-  | { type: 'created'; status: 201; record: Record<string, unknown> }
-  | {
-      type: 'replay'
-      status: number
-      body: string
-      record: Record<string, unknown>
-    }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
-function isUniqueConstraintError(error: unknown): boolean {
-  const seen = new Set<unknown>()
-  let current = error
-
-  while (isRecord(current) && !seen.has(current)) {
-    seen.add(current)
-    const code = current['code']
-    if (
-      code === '23505' ||
-      code === 'SQLITE_CONSTRAINT_UNIQUE' ||
-      code === 'SQLITE_CONSTRAINT_PRIMARYKEY'
-    ) {
-      return true
-    }
-
-    const message = current['message']
-    if (
-      typeof message === 'string' &&
-      (/duplicate key value violates unique constraint/i.test(message) ||
-        /unique constraint failed/i.test(message))
-    ) {
-      return true
-    }
-
-    current = current['cause']
-  }
-
-  return false
-}
-
-function coerceId(rawId: string | number): string | number {
-  if (typeof rawId === 'number') return rawId
-  return isNaN(Number(rawId)) ? rawId : Number(rawId)
-}
-
-export function createCrudOperations<
-  TSchema extends Record<string, unknown> = Record<string, unknown>,
->(deps: CrudOperationsDeps<TSchema>) {
-  const { schema, db, access, realtime } = deps
-  const idempotency = resolveIdempotencyConfig(deps.idempotency)
-
-  const scopeFor = (
-    resolver: ScopeResolver | undefined,
-    ctx: {
-      user: AccessUser | null
-      session: { activeOrganizationId: string | null }
-      request: Request
-      row?: Record<string, unknown>
-      body?: Record<string, unknown>
-    },
-  ): ScopeMap | undefined => (resolver ? resolver(ctx) : undefined)
-
-  function resolveTable(tableName: string) {
-    const table = Object.values(schema).find(
-      (t) => isTable(t) && getTableName(t) === tableName,
-    ) as Table | undefined
-    if (!table) {
-      throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-    }
-    const tableAccess = tableEntryForName(access, tableName)
-    if (!tableAccess || !tableAccess.enabled) {
-      throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-    }
-    const idCol = getTableColumns(table)['id']
-    if (!idCol) {
-      throw new CrudOperationError(
-        400,
-        ErrorCode.VALIDATION_ERROR,
-        `Table ${tableName} has no id column`,
-      )
-    }
-    return { table, tableAccess, idCol }
-  }
-
-  return {
-    async list(
-      tableName: string,
-      paramsInput: URL | Record<string, unknown> | undefined,
-      ctx: CrudExecutionContext,
-    ): Promise<ListResult<Record<string, unknown>>> {
-      const { table, tableAccess, idCol } = resolveTable(tableName)
-
-      const denied = await checkAccess(
-        tableAccess.list,
-        ctx,
-        tableAccess.ownerColumn,
-      )
-      if (!denied.allowed) {
-        throw new CrudOperationError(
-          denied.status === 401 ? 401 : 403,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-        )
-      }
-
-      let urlObj: URL
-      if (paramsInput instanceof URL) {
-        urlObj = paramsInput
-      } else {
-        urlObj = new URL(ctx.request.url || 'http://localhost')
-        if (paramsInput) {
-          for (const [k, v] of Object.entries(paramsInput)) {
-            if (v !== undefined && v !== null) {
-              urlObj.searchParams.set(k, String(v))
-            }
-          }
-        }
-      }
-
-      try {
-        const params = parseListParams(urlObj, tableAccess)
-        const scope = scopeFor(tableAccess.readScope, ctx)
-        const scopeWhere = scope ? buildScopeWhere(table, scope) : undefined
-        return await executeList(
-          db,
-          table,
-          tableAccess,
-          params,
-          idCol,
-          scopeWhere,
-        )
-      } catch (err) {
-        if (err instanceof ListQueryError) {
-          throw new CrudOperationError(400, err.code, err.message, err.details)
-        }
-        throw err
-      }
-    },
-
-    async get(
-      tableName: string,
-      rawId: string | number,
-      ctx: CrudExecutionContext,
-    ): Promise<Record<string, unknown>> {
-      const { table, tableAccess, idCol } = resolveTable(tableName)
-      const id = coerceId(rawId)
-
-      const rows = await db
-        .select()
-        .from(table)
-        .where(eq(idCol, id))
-      if (!rows[0]) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-      const row = rows[0] as Record<string, unknown>
-
-      const denied = await checkAccess(
-        tableAccess.get,
-        { ...ctx, row },
-        tableAccess.ownerColumn,
-      )
-      if (!denied.allowed) {
-        throw new CrudOperationError(
-          denied.status === 401 ? 401 : 403,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-        )
-      }
-
-      const scope = scopeFor(tableAccess.readScope, ctx)
-      if (scope && !rowMatchesScope(row, scope)) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-
-      return row
-    },
-
-    async create(
-      tableName: string,
-      body: unknown,
-      rawBody: string | undefined,
-      idempotencyKey: string | undefined,
-      ctx: CrudExecutionContext,
-    ): Promise<CreateResult> {
-      const { table, tableAccess } = resolveTable(tableName)
-
-      const denied = await checkAccess(
-        tableAccess.create,
-        ctx,
-        tableAccess.ownerColumn,
-      )
-      if (!denied.allowed) {
-        throw new CrudOperationError(
-          denied.status === 401 ? 401 : 403,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-        )
-      }
-
-      if (!isRecord(body)) {
-        throw new CrudOperationError(
-          400,
-          ErrorCode.VALIDATION_ERROR,
-          'Invalid JSON body',
-        )
-      }
-
-      const trimmedKey = idempotencyKey?.trim()
-      const effectiveRawBody = rawBody ?? JSON.stringify(body)
-
-      if (idempotency && trimmedKey) {
-        const lookup = await lookupIdempotency(
-          db,
-          tableName,
-          trimmedKey,
-          effectiveRawBody,
-          idempotency,
-        )
-        if (lookup.type === 'conflict') {
-          throw new CrudOperationError(
-            409,
-            ErrorCode.IDEMPOTENCY_CONFLICT,
-            'Idempotency key reused with different body',
-          )
-        }
-        if (lookup.type === 'replay') {
-          return {
-            type: 'replay',
-            status: lookup.status,
-            body: lookup.response,
-            record: JSON.parse(lookup.response) as Record<string, unknown>,
-          }
-        }
-      }
-
-      const values = sanitizeWriteBody(
-        body,
-        tableAccess,
-        'create',
-        ctx.user?.id ?? null,
-      )
-
-      const scope = scopeFor(tableAccess.writeScope, { ...ctx, body })
-      const stamped = scope ? stampScope(values, scope) : values
-
-      let rows: Record<string, unknown>[]
-      try {
-        rows = await db.insert(table).values(stamped).returning()
-      } catch (error) {
-        if (isUniqueConstraintError(error)) {
-          throw new CrudOperationError(
-            409,
-            ErrorCode.CONFLICT,
-            'Record already exists',
-          )
-        }
-        throw error
-      }
-      const created = rows[0] as Record<string, unknown>
-      void realtime?.publish(table as never, 'create', created as never)
-
-      if (idempotency && trimmedKey) {
-        await storeIdempotency(
-          db,
-          tableName,
-          trimmedKey,
-          effectiveRawBody,
-          201,
-          created,
-          idempotency,
-        )
-      }
-
-      return {
-        type: 'created',
-        status: 201,
-        record: created,
-      }
-    },
-
-    async update(
-      tableName: string,
-      rawId: string | number,
-      body: unknown,
-      ctx: CrudExecutionContext,
-    ): Promise<Record<string, unknown>> {
-      const { table, tableAccess, idCol } = resolveTable(tableName)
-      const id = coerceId(rawId)
-
-      const existing = await db
-        .select()
-        .from(table)
-        .where(eq(idCol, id))
-      if (!existing[0]) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-      const existingRow = existing[0] as Record<string, unknown>
-
-      const readScope = scopeFor(tableAccess.readScope, ctx)
-      if (readScope && !rowMatchesScope(existingRow, readScope)) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-
-      const denied = await checkAccess(
-        tableAccess.update,
-        { ...ctx, row: existingRow },
-        tableAccess.ownerColumn,
-      )
-      if (!denied.allowed) {
-        throw new CrudOperationError(
-          denied.status === 401 ? 401 : 403,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-        )
-      }
-
-      if (!isRecord(body)) {
-        throw new CrudOperationError(
-          400,
-          ErrorCode.VALIDATION_ERROR,
-          'Invalid JSON body',
-        )
-      }
-
-      const values = sanitizeWriteBody(
-        body,
-        tableAccess,
-        'update',
-        ctx.user?.id ?? null,
-      )
-
-      if (Object.keys(values).length === 0) {
-        throw new CrudOperationError(
-          400,
-          ErrorCode.VALIDATION_ERROR,
-          'No writable fields to update',
-        )
-      }
-
-      const writeScope = scopeFor(tableAccess.writeScope, { ...ctx, body })
-      const stamped = writeScope ? stampScope(values, writeScope) : values
-
-      const rows = await db
-        .update(table)
-        .set(stamped)
-        .where(eq(idCol, id))
-        .returning()
-
-      if (!rows[0]) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-      const updated = rows[0] as Record<string, unknown>
-      void realtime?.publish(table as never, 'update', updated as never)
-      return updated
-    },
-
-    async delete(
-      tableName: string,
-      rawId: string | number,
-      ctx: CrudExecutionContext,
-    ): Promise<void> {
-      const { table, tableAccess, idCol } = resolveTable(tableName)
-      const id = coerceId(rawId)
-
-      const existing = await db
-        .select()
-        .from(table)
-        .where(eq(idCol, id))
-      if (!existing[0]) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-      const existingRow = existing[0] as Record<string, unknown>
-
-      const readScope = scopeFor(tableAccess.readScope, ctx)
-      if (readScope && !rowMatchesScope(existingRow, readScope)) {
-        throw new CrudOperationError(404, ErrorCode.NOT_FOUND, 'Not found')
-      }
-
-      const denied = await checkAccess(
-        tableAccess.delete,
-        { ...ctx, row: existingRow },
-        tableAccess.ownerColumn,
-      )
-      if (!denied.allowed) {
-        throw new CrudOperationError(
-          denied.status === 401 ? 401 : 403,
-          ErrorCode.FORBIDDEN,
-          'Forbidden',
-        )
-      }
-
-      await db.delete(table).where(eq(idCol, id))
-      void realtime?.publish(table as never, 'delete', existingRow as never)
-    },
-  }
-}
-
-export type CrudOperations = ReturnType<typeof createCrudOperations>