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

package/src/list-query.ts

@@ -1,416 +0,0 @@
-import {
-  and,
-  asc,
-  desc,
-  eq,
-  getTableColumns,
-  gt,
-  ilike,
-  inArray,
-  is,
-  like,
-  lt,
-  or,
-  sql,
-  type SQL,
-} from 'drizzle-orm'
-import { PgTable } from 'drizzle-orm/pg-core'
-
-import type { ResolvedTableAccess, SortOrder } from './access'
-import type { AnyDb } from './dialect'
-
-import { ErrorCode, ListQueryError } from './errors'
-
-/** Caps both `?limit=` and the number of values in a comma-separated `IN` filter. */
-export const MAX_LIST_LIMIT = 200
-
-export const RESERVED_LIST_PARAMS = new Set([
-  'limit',
-  'offset',
-  'sort',
-  'order',
-  'q',
-  'cursor',
-  'count',
-])
-
-export type ParsedListParams = {
-  limit: number
-  offset?: number
-  sort: string
-  order: SortOrder
-  q: string
-  cursor?: string
-  count: boolean
-  filters: Record<string, unknown>
-}
-
-export type ListResult<T> = {
-  items: T[]
-  limit: number
-  offset?: number
-  cursor?: string
-  nextCursor?: string
-  hasMore: boolean
-  total?: number
-  q?: string
-  sort: string
-  order: SortOrder
-}
-
-type CursorPayload = {
-  sort: string
-  order: SortOrder
-  v: string | number | null
-  id: string | number
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
-function isCursorPayload(value: unknown): value is CursorPayload {
-  if (!isRecord(value)) return false
-  return (
-    typeof value.sort === 'string' &&
-    (value.order === 'asc' || value.order === 'desc') &&
-    (value.v === null ||
-      typeof value.v === 'string' ||
-      typeof value.v === 'number') &&
-    (typeof value.id === 'string' || typeof value.id === 'number')
-  )
-}
-
-function parseBoolean(value: string | undefined): boolean {
-  if (!value) return false
-  const v = value.toLowerCase()
-  return v === 'true' || v === '1'
-}
-
-function parseLimit(raw: string | undefined): number {
-  if (raw === undefined || raw === '') return 20
-  const n = Number(raw)
-  if (!Number.isInteger(n) || n < 1) {
-    throw new ListQueryError(
-      `limit must be an integer between 1 and ${MAX_LIST_LIMIT}`,
-    )
-  }
-  return Math.min(n, MAX_LIST_LIMIT)
-}
-
-function parseOffset(raw: string | undefined): number {
-  if (raw === undefined || raw === '') return 0
-  const n = Number(raw)
-  if (!Number.isInteger(n) || n < 0) {
-    throw new ListQueryError('offset must be a non-negative integer')
-  }
-  return n
-}
-
-function parseOrder(raw: string | undefined): SortOrder {
-  if (!raw || raw === 'asc') return 'asc'
-  if (raw === 'desc') return 'desc'
-  throw new ListQueryError('order must be "asc" or "desc"')
-}
-
-export function parseListParams(
-  url: URL,
-  access: ResolvedTableAccess,
-): ParsedListParams {
-  const params = url.searchParams
-  const limit = parseLimit(params.get('limit') ?? undefined)
-  const cursor = params.get('cursor')?.trim() || undefined
-  const hasOffset = params.has('offset') && params.get('offset') !== ''
-  const offset = hasOffset
-    ? parseOffset(params.get('offset') ?? undefined)
-    : undefined
-
-  if (cursor && hasOffset) {
-    throw new ListQueryError('cursor and offset cannot be used together')
-  }
-
-  const sort = params.get('sort')?.trim() || access.defaultSort.column
-  const order = params.has('order')
-    ? parseOrder(params.get('order') ?? undefined)
-    : params.has('sort')
-      ? 'asc'
-      : access.defaultSort.order
-
-  if (!access.sortableColumns.includes(sort)) {
-    throw new ListQueryError(`sort column "${sort}" is not allowed`)
-  }
-
-  const filters: Record<string, unknown> = {}
-  for (const [key, value] of params.entries()) {
-    if (RESERVED_LIST_PARAMS.has(key)) continue
-    if (!access.filterableColumns.includes(key)) {
-      throw new ListQueryError(`filter column "${key}" is not allowed`)
-    }
-    filters[key] = value === 'null' ? null : value
-  }
-
-  const q = params.get('q')?.trim().slice(0, 100) ?? ''
-  const count = parseBoolean(params.get('count') ?? undefined)
-
-  if (cursor) {
-    const decoded = decodeCursor(cursor)
-    if (decoded.sort !== sort || decoded.order !== order) {
-      throw new ListQueryError(
-        'cursor does not match sort and order parameters',
-        ErrorCode.INVALID_CURSOR,
-      )
-    }
-  }
-
-  return {
-    limit,
-    offset: cursor ? undefined : (offset ?? 0),
-    sort,
-    order,
-    q,
-    cursor,
-    count,
-    filters,
-  }
-}
-
-function buildSearchWhere(
-  table: Parameters<typeof getTableColumns>[0],
-  searchableColumns: string[] | undefined,
-  q: string,
-): SQL | undefined {
-  if (!q || !searchableColumns?.length) return undefined
-  const columns = getTableColumns(table)
-  const pattern = `%${q.replace(/[%_\\]/g, (ch) => `\\${ch}`)}%`
-  // LIKE is case-insensitive in SQLite but case-sensitive in Postgres; use
-  // ilike there so search behaves identically across dialects.
-  const likeOp = is(table, PgTable) ? ilike : like
-  const conditions = searchableColumns
-    .filter((name) => name in columns)
-    .map((name) => likeOp(columns[name]!, pattern))
-  return conditions.length ? or(...conditions) : undefined
-}
-
-function coerceFilterValue(
-  table: Parameters<typeof getTableColumns>[0],
-  columnName: string,
-  raw: unknown,
-): unknown {
-  if (raw === null) return null
-  const col = getTableColumns(table)[columnName]
-  if (!col) return raw
-
-  const dataType = col.dataType
-  if (
-    dataType === 'number' ||
-    dataType === 'integer' ||
-    dataType === 'bigint'
-  ) {
-    const n = Number(raw)
-    if (Number.isNaN(n)) {
-      throw new ListQueryError(`filter "${columnName}" must be a number`)
-    }
-    return n
-  }
-  if (dataType === 'boolean') {
-    const s = String(raw).toLowerCase()
-    if (s === 'true' || s === '1') return true
-    if (s === 'false' || s === '0') return false
-    throw new ListQueryError(`filter "${columnName}" must be a boolean`)
-  }
-  if (dataType === 'date') {
-    const d = new Date(raw as string | number)
-    if (Number.isNaN(d.getTime())) {
-      throw new ListQueryError(`filter "${columnName}" must be a valid date`)
-    }
-    return d
-  }
-  return String(raw)
-}
-
-function buildFilterWhere(
-  table: Parameters<typeof getTableColumns>[0],
-  filters: Record<string, unknown>,
-): SQL | undefined {
-  const columns = getTableColumns(table)
-  const conditions: SQL[] = []
-
-  for (const [name, raw] of Object.entries(filters)) {
-    const col = columns[name]
-    if (!col) continue
-
-    if (raw === null) {
-      conditions.push(sql`${col} IS NULL`)
-      continue
-    }
-
-    // `?column=a,b,c` — TypeIDs and other filterable values never contain
-    // commas, so this is a safe, zero-syntax way to do `column IN (...)`.
-    if (typeof raw === 'string' && raw.includes(',')) {
-      const parts = raw.split(',').filter((p) => p.length > 0)
-      if (parts.length > MAX_LIST_LIMIT) {
-        throw new ListQueryError(
-          `filter "${name}" accepts at most ${MAX_LIST_LIMIT} comma-separated values`,
-        )
-      }
-      const values = parts.map((p) => coerceFilterValue(table, name, p))
-      conditions.push(inArray(col, values))
-      continue
-    }
-
-    const value = coerceFilterValue(table, name, raw)
-    if (value === null) {
-      conditions.push(sql`${col} IS NULL`)
-    } else {
-      conditions.push(eq(col, value))
-    }
-  }
-
-  return conditions.length ? and(...conditions) : undefined
-}
-
-function serializeCursorValue(value: unknown): string | number | null {
-  if (value == null) return null
-  if (value instanceof Date) return value.toISOString()
-  if (typeof value === 'number' || typeof value === 'string') return value
-  return String(value)
-}
-
-export function encodeCursor(payload: CursorPayload): string {
-  return Buffer.from(JSON.stringify(payload)).toString('base64url')
-}
-
-export function decodeCursor(cursor: string): CursorPayload {
-  try {
-    const parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'))
-    if (!isCursorPayload(parsed)) {
-      throw new Error('invalid cursor shape')
-    }
-    return parsed
-  } catch {
-    throw new ListQueryError('invalid cursor', ErrorCode.INVALID_CURSOR)
-  }
-}
-
-function buildCursorWhere(
-  table: Parameters<typeof getTableColumns>[0],
-  sortColName: string,
-  order: SortOrder,
-  cursor: CursorPayload,
-  idCol: unknown,
-): SQL {
-  const columns = getTableColumns(table)
-  const sortCol = columns[sortColName]!
-  const sortValue = coerceFilterValue(table, sortColName, cursor.v)
-
-  if (order === 'desc') {
-    return or(
-      lt(sortCol, sortValue),
-      and(eq(sortCol, sortValue), lt(idCol as never, cursor.id)),
-    )!
-  }
-  return or(
-    gt(sortCol, sortValue),
-    and(eq(sortCol, sortValue), gt(idCol as never, cursor.id)),
-  )!
-}
-
-function buildOrderBy(
-  table: Parameters<typeof getTableColumns>[0],
-  sortColName: string,
-  order: SortOrder,
-  idCol: unknown,
-) {
-  const columns = getTableColumns(table)
-  const sortCol = columns[sortColName]!
-  const idOrder = order === 'asc' ? asc(idCol as never) : desc(idCol as never)
-  return order === 'asc' ? [asc(sortCol), idOrder] : [desc(sortCol), idOrder]
-}
-
-export async function executeList<T extends Record<string, unknown>>(
-  db: AnyDb,
-  table: Parameters<typeof getTableColumns>[0],
-  access: ResolvedTableAccess,
-  params: ParsedListParams,
-  idCol: unknown,
-  scopeWhere?: SQL,
-): Promise<ListResult<T>> {
-  const searchWhere = buildSearchWhere(
-    table,
-    access.searchableColumns,
-    params.q,
-  )
-  const filterWhere = buildFilterWhere(table, params.filters)
-  let where = and(
-    ...(searchWhere ? [searchWhere] : []),
-    ...(filterWhere ? [filterWhere] : []),
-    ...(scopeWhere ? [scopeWhere] : []),
-  )
-
-  if (params.cursor) {
-    const cursorPayload = decodeCursor(params.cursor)
-    const cursorWhere = buildCursorWhere(
-      table,
-      params.sort,
-      params.order,
-      cursorPayload,
-      idCol,
-    )
-    where = where ? and(where, cursorWhere) : cursorWhere
-  }
-
-  const orderBy = buildOrderBy(table, params.sort, params.order, idCol)
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let query = (db as any).select().from(table)
-  if (where) query = query.where(where)
-  query = query.orderBy(...orderBy)
-
-  if (params.offset !== undefined) {
-    query = query.limit(params.limit).offset(params.offset)
-  } else {
-    query = query.limit(params.limit)
-  }
-
-  const items = (await query) as T[]
-
-  let total: number | undefined
-  if (params.count) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let countQuery = (db as any)
-      .select({ count: sql<number>`count(*)` })
-      .from(table)
-    if (where) countQuery = countQuery.where(where)
-    const [row] = await countQuery
-    total = Number(row?.count ?? 0)
-  }
-
-  const hasMore =
-    total !== undefined && params.offset !== undefined
-      ? params.offset + items.length < total
-      : items.length === params.limit
-
-  let nextCursor: string | undefined
-  if (items.length === params.limit) {
-    const last = items[items.length - 1]!
-    nextCursor = encodeCursor({
-      sort: params.sort,
-      order: params.order,
-      v: serializeCursorValue(last[params.sort]),
-      id: last.id as string | number,
-    })
-  }
-
-  return {
-    items,
-    limit: params.limit,
-    ...(params.offset !== undefined ? { offset: params.offset } : {}),
-    ...(params.cursor ? { cursor: params.cursor } : {}),
-    ...(nextCursor ? { nextCursor } : {}),
-    hasMore,
-    ...(total !== undefined ? { total } : {}),
-    ...(params.q ? { q: params.q } : {}),
-    sort: params.sort,
-    order: params.order,
-  }
-}

package/src/manifest.ts

@@ -1,297 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
-
-import { getTableName, isTable } from 'drizzle-orm'
-import * as v from 'valibot'
-
-import type { Dialect } from './dialect'
-import type { EnvConfigInput } from './env'
-import type { JobsDefs } from './jobs/define'
-import type { ResolvedBucket, ResolvedStorageBuckets } from './storage/buckets'
-
-import {
-  bunderstackFiles,
-  bunderstackIdempotency,
-  bunderstackJobs,
-} from './internal-tables'
-import { parseCron } from './jobs/cron'
-import {
-  StandardSchemaValidationError,
-  validateStandardSchema,
-} from './standard-schema'
-
-export type ManifestEnvVar = {
-  key: string
-  required: boolean
-  scope: 'server' | 'client'
-}
-
-export type BunderstackManifest = {
-  version: 3
-  database: {
-    dialect: Dialect
-    migrationsDirectory: string
-    tables: { exportName: string; physicalName: string; system: boolean }[]
-  }
-  storage: {
-    defaultBucket: string
-    buckets: { name: string; visibility: ResolvedBucket['visibility'] }[]
-  }
-  realtime: { required: boolean }
-  environment: ManifestEnvVar[]
-  background: {
-    jobs: { name: string }[]
-    cron: { name: string; schedule: string; timezone: 'UTC' }[]
-    maintenance: {
-      name: 'storage-sweep'
-      schedule: string
-      timezone: 'UTC'
-    }[]
-  }
-}
-
-const nonEmpty = v.pipe(v.string(), v.minLength(1))
-const migrationDirectory = v.pipe(
-  nonEmpty,
-  v.check(
-    (value) =>
-      value.startsWith('/') ||
-      (!value.includes('\\') &&
-        value.split('/').every((part) => part !== '..' && part !== '')),
-    'migrationsDirectory must be an absolute path or a relative path without traversal',
-  ),
-)
-const cronSchedule = v.pipe(
-  nonEmpty,
-  v.check((value) => {
-    try {
-      parseCron(value)
-      return true
-    } catch {
-      return false
-    }
-  }, 'invalid cron schedule'),
-)
-
-const manifestSchema = v.strictObject({
-  version: v.literal(3),
-  database: v.strictObject({
-    dialect: v.picklist(['sqlite', 'pg']),
-    migrationsDirectory: migrationDirectory,
-    tables: v.array(
-      v.strictObject({
-        exportName: nonEmpty,
-        physicalName: nonEmpty,
-        system: v.boolean(),
-      }),
-    ),
-  }),
-  storage: v.strictObject({
-    defaultBucket: nonEmpty,
-    buckets: v.array(
-      v.strictObject({
-        name: nonEmpty,
-        visibility: v.picklist(['public', 'private']),
-      }),
-    ),
-  }),
-  realtime: v.strictObject({ required: v.boolean() }),
-  environment: v.array(
-    v.strictObject({
-      key: nonEmpty,
-      required: v.boolean(),
-      scope: v.picklist(['server', 'client']),
-    }),
-  ),
-  background: v.strictObject({
-    jobs: v.array(v.strictObject({ name: nonEmpty })),
-    cron: v.array(
-      v.strictObject({
-        name: nonEmpty,
-        schedule: cronSchedule,
-        timezone: v.literal('UTC'),
-      }),
-    ),
-    maintenance: v.array(
-      v.strictObject({
-        name: v.literal('storage-sweep'),
-        schedule: cronSchedule,
-        timezone: v.literal('UTC'),
-      }),
-    ),
-  }),
-})
-
-function sortBy<T>(entries: readonly T[], key: (entry: T) => string): T[] {
-  return [...entries].sort((left, right) => key(left).localeCompare(key(right)))
-}
-
-function rejectDuplicates(collection: string, values: readonly string[]): void {
-  const seen = new Set<string>()
-  for (const value of values) {
-    if (seen.has(value))
-      throw new Error(`[bunderstack] duplicate ${collection} "${value}"`)
-    seen.add(value)
-  }
-}
-
-function describeTables(schema: Record<string, unknown>) {
-  const systemNames = new Set<string>(
-    systemTables().map((table) => table.physicalName),
-  )
-  return sortBy(
-    Object.entries(schema).flatMap(([exportName, value]) =>
-      isTable(value) && !systemNames.has(getTableName(value))
-        ? [{ exportName, physicalName: getTableName(value), system: false }]
-        : [],
-    ),
-    (entry) => entry.physicalName,
-  )
-}
-
-function describeSection(
-  section: Record<string, StandardSchemaV1> | undefined,
-  scope: ManifestEnvVar['scope'],
-): ManifestEnvVar[] {
-  return Object.entries(section ?? {}).map(([key, schema]) => {
-    let required = false
-    try {
-      validateStandardSchema(schema, undefined, 'env')
-    } catch (error) {
-      if (!(error instanceof StandardSchemaValidationError)) throw error
-      required = true
-    }
-    return { key, required, scope }
-  })
-}
-
-function systemTables() {
-  return [
-    {
-      exportName: '_system.files',
-      physicalName: getTableName(bunderstackFiles),
-      system: true,
-    },
-    {
-      exportName: '_system.idempotency',
-      physicalName: getTableName(bunderstackIdempotency),
-      system: true,
-    },
-    {
-      exportName: '_system.jobs',
-      physicalName: getTableName(bunderstackJobs),
-      system: true,
-    },
-  ]
-}
-
-export function parseManifest(value: unknown): BunderstackManifest {
-  const manifest = validateStandardSchema(
-    manifestSchema,
-    value,
-    'manifest',
-  ) as BunderstackManifest
-  rejectDuplicates(
-    'database physical table',
-    manifest.database.tables.map((entry) => entry.physicalName),
-  )
-  rejectDuplicates(
-    'database export table',
-    manifest.database.tables.map((entry) => entry.exportName),
-  )
-  rejectDuplicates(
-    'storage bucket',
-    manifest.storage.buckets.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'environment key',
-    manifest.environment.map((entry) => entry.key),
-  )
-  rejectDuplicates(
-    'background job',
-    manifest.background.jobs.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'background cron',
-    manifest.background.cron.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'background maintenance',
-    manifest.background.maintenance.map((entry) => entry.name),
-  )
-  return manifest
-}
-
-export function buildManifest(args: {
-  schema: Record<string, unknown>
-  dialect: Dialect
-  migrationsDirectory: string
-  storage: ResolvedStorageBuckets
-  envConfig: EnvConfigInput | undefined
-  emailProvider: string | undefined
-  realtime: boolean
-  jobs: JobsDefs | undefined
-}): BunderstackManifest {
-  const environment = [
-    ...describeSection(args.envConfig?.server, 'server'),
-    ...describeSection(args.envConfig?.client, 'client'),
-    ...(args.emailProvider === 'resend'
-      ? [{ key: 'RESEND_API_KEY', required: true, scope: 'server' as const }]
-      : []),
-    ...(args.emailProvider === 'smtp'
-      ? [{ key: 'SMTP_URL', required: true, scope: 'server' as const }]
-      : []),
-  ]
-  rejectDuplicates(
-    'environment key',
-    environment.map((entry) => entry.key),
-  )
-
-  return parseManifest({
-    version: 3,
-    database: {
-      dialect: args.dialect,
-      migrationsDirectory: args.migrationsDirectory,
-      tables: sortBy(
-        [...systemTables(), ...describeTables(args.schema)],
-        (entry) => entry.physicalName,
-      ),
-    },
-    storage: {
-      defaultBucket: args.storage.defaultBucket,
-      buckets: sortBy(
-        [...args.storage.buckets.values()].map((bucket) => ({
-          name: bucket.name,
-          visibility: bucket.visibility,
-        })),
-        (bucket) => bucket.name,
-      ),
-    },
-    realtime: { required: args.realtime },
-    environment: sortBy(environment, (entry) => entry.key),
-    background: {
-      jobs: sortBy(
-        Object.entries(args.jobs ?? {})
-          .filter(([, def]) => def.kind === 'job')
-          .map(([name]) => ({ name })),
-        (entry) => entry.name,
-      ),
-      cron: sortBy(
-        Object.entries(args.jobs ?? {})
-          .filter(([, def]) => def.kind === 'cron')
-          .map(([name, def]) => ({
-            name,
-            schedule: def.kind === 'cron' ? def.schedule : '',
-            timezone: 'UTC' as const,
-          })),
-        (entry) => entry.name,
-      ),
-      maintenance: [
-        {
-          name: 'storage-sweep',
-          schedule: '0 4 * * *',
-          timezone: 'UTC' as const,
-        },
-      ],
-    },
-  })
-}