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

package/src/list-query.ts

@@ -1,333 +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 an `IN` filter. */
-export const MAX_LIST_LIMIT = 200
-
-/** Default page size when a request omits `limit`. */
-export const DEFAULT_LIST_LIMIT = 20
-
-/**
- * What a list procedure accepts. Shape and column types are enforced by the
- * generated input schema, so by the time these params arrive they are already
- * validated and coerced — this module only applies policy (defaults, the limit
- * cap, cursor rules).
- */
-export type ListParamsInput = {
-  limit?: number
-  offset?: number
-  cursor?: string
-  sort?: string
-  order?: SortOrder
-  q?: string
-  count?: boolean
-  filters?: Record<string, unknown>
-}
-
-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')
-  )
-}
-
-/**
- * Applies list policy to already-validated input: defaults, the limit cap, and
- * the rules a schema cannot express (cursor excludes offset, and a cursor must
- * agree with the sort it was minted for).
- */
-export function resolveListParams(
-  input: ListParamsInput,
-  access: ResolvedTableAccess,
-): ParsedListParams {
-  const cursor = input.cursor?.trim() || undefined
-  if (cursor && input.offset !== undefined) {
-    throw new ListQueryError('cursor and offset cannot be used together')
-  }
-
-  const sort = input.sort ?? access.defaultSort.column
-  const order = input.order ?? (input.sort ? 'asc' : access.defaultSort.order)
-
-  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: Math.min(input.limit ?? DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT),
-    offset: cursor ? undefined : (input.offset ?? 0),
-    sort,
-    order,
-    q: input.q?.trim() ?? '',
-    cursor,
-    count: input.count ?? false,
-    filters: input.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
-}
-
-/**
- * Cursors carry their sort value as JSON, so a date column arrives as a string
- * and has to be rebuilt. Filter values need no such repair — the generated
- * input schema already types them.
- */
-function coerceCursorValue(
-  table: Parameters<typeof getTableColumns>[0],
-  columnName: string,
-  raw: string | number | null,
-): unknown {
-  if (raw === null) return null
-  const col = getTableColumns(table)[columnName]
-  if (col?.dataType === 'date') return new Date(raw)
-  return raw
-}
-
-function buildFilterWhere(
-  table: Parameters<typeof getTableColumns>[0],
-  filters: Record<string, unknown>,
-): SQL | undefined {
-  const columns = getTableColumns(table)
-  const conditions: SQL[] = []
-
-  for (const [name, value] of Object.entries(filters)) {
-    const col = columns[name]
-    if (!col || value === undefined) continue
-
-    if (value === null) {
-      conditions.push(sql`${col} IS NULL`)
-    } else if (Array.isArray(value)) {
-      if (value.length) conditions.push(inArray(col, value))
-    } 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 = coerceCursorValue(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,
-        },
-      ],
-    },
-  })
-}

package/src/provision-internals.ts

@@ -1,29 +0,0 @@
-import type { Driver } from './db'
-// src/provision-internals.ts
-import type { AnyDb, Dialect } from './dialect'
-
-/**
- * Hidden handle connecting `createBunderstack()` to the optional
- * `bunderstack/provision` entry. Lives in its own module so the main entry
- * never imports provision code (and its drizzle-kit reference).
- */
-export const PROVISION_INTERNALS: unique symbol = Symbol.for(
-  'bunderstack.provision-internals',
-)
-
-export interface ProvisionInternals {
-  /** Runtime db typed over the MERGED schema (user + internal tables). */
-  db: AnyDb
-  /** Merged schema used for push. */
-  schema: Record<string, unknown>
-  databaseUrl: string
-  /** Resolved migrations folder (config `database.migrations`). */
-  migrationsFolder: string
-  dialect: Dialect
-  driver: Driver
-  adapter: import('./database/adapter').DatabaseAdapter
-}
-
-export interface WithProvisionInternals {
-  [PROVISION_INTERNALS]?: ProvisionInternals
-}