bunderstack 0.17.0-beta.2 → 0.17.0-beta.3

package/src/database/adapter.ts

@@ -1,26 +0,0 @@
-import type { DbFor, Driver } from '../db'
-import type { AnyDb, Dialect } from '../dialect'
-
-export type DatabaseConnection = {
-  url: string
-  authToken?: string
-}
-
-export type DatabaseConnectOptions = { introspect: boolean }
-
-export type DatabaseConnectionResult<TSchema extends Record<string, unknown>> =
-  {
-    db: DbFor<TSchema>
-    close?: () => void | Promise<void>
-  }
-
-export type DatabaseAdapter = {
-  readonly dialect: Dialect
-  readonly driver: Driver
-  connect<TSchema extends Record<string, unknown>>(
-    schema: TSchema,
-    connection: DatabaseConnection,
-    options: DatabaseConnectOptions,
-  ): Promise<DatabaseConnectionResult<TSchema>>
-  migrate(db: AnyDb, migrationsFolder: string): Promise<void>
-}

package/src/database/bun-sql.ts

@@ -1,23 +0,0 @@
-import { drizzle } from 'drizzle-orm/bun-sql'
-import { migrate } from 'drizzle-orm/bun-sql/migrator'
-
-import type { DatabaseAdapter } from './adapter'
-
-export function bunSql(): DatabaseAdapter {
-  return {
-    dialect: 'pg',
-    driver: 'bun-sql',
-    async connect(schema, { url }, { introspect }) {
-      if (introspect) return { db: drizzle.mock({ schema }) as never }
-
-      if (!url.startsWith('postgres://') && !url.startsWith('postgresql://')) {
-        throw new Error('[bunderstack] bunSql adapter requires a Postgres URL')
-      }
-      const db = drizzle(url, { schema })
-      return { db: db as never, close: () => db.$client.close() }
-    },
-    async migrate(db, migrationsFolder) {
-      await migrate(db as never, { migrationsFolder })
-    },
-  }
-}

package/src/database/libsql.ts

@@ -1,28 +0,0 @@
-import { drizzle } from 'drizzle-orm/libsql'
-import { migrate } from 'drizzle-orm/libsql/migrator'
-
-import type { DatabaseAdapter } from './adapter'
-
-export function libsql(): DatabaseAdapter {
-  return {
-    dialect: 'sqlite',
-    driver: 'libsql',
-    async connect(schema, connection, { introspect }) {
-      if (introspect) return { db: drizzle.mock({ schema }) as never }
-
-      if (
-        connection.url.startsWith('postgres://') ||
-        connection.url.startsWith('postgresql://')
-      ) {
-        throw new Error(
-          '[bunderstack] libsql adapter cannot connect to a Postgres URL',
-        )
-      }
-      const db = drizzle({ connection, schema })
-      return { db: db as never, close: () => db.$client.close() }
-    },
-    async migrate(db, migrationsFolder) {
-      await migrate(db as never, { migrationsFolder })
-    },
-  }
-}

package/src/database/pglite.ts

@@ -1,33 +0,0 @@
-import { drizzle } from 'drizzle-orm/pglite'
-import { migrate } from 'drizzle-orm/pglite/migrator'
-import { mkdir } from 'node:fs/promises'
-
-import type { DatabaseAdapter } from './adapter'
-
-const rawPath = (url: string) =>
-  url.startsWith('file:') ? url.slice('file:'.length) : url
-
-export function pglite(): DatabaseAdapter {
-  return {
-    dialect: 'pg',
-    driver: 'pglite',
-    async connect(schema, { url }, { introspect }) {
-      if (introspect) return { db: drizzle.mock({ schema }) as never }
-
-      if (url.startsWith('postgres://') || url.startsWith('postgresql://')) {
-        throw new Error(
-          '[bunderstack] pglite adapter cannot connect to a Postgres URL',
-        )
-      }
-      const raw = rawPath(url)
-      const dataDir = raw === ':memory:' ? 'memory://' : raw
-      if (!dataDir.startsWith('memory://'))
-        await mkdir(dataDir, { recursive: true })
-      const db = drizzle(dataDir, { schema })
-      return { db: db as never, close: () => db.$client.close() }
-    },
-    async migrate(db, migrationsFolder) {
-      await migrate(db as never, { migrationsFolder })
-    },
-  }
-}

package/src/database/postgres-js.ts

@@ -1,33 +0,0 @@
-import { drizzle } from 'drizzle-orm/postgres-js'
-import { migrate } from 'drizzle-orm/postgres-js/migrator'
-
-import type {
-  DatabaseAdapter,
-  DatabaseConnection,
-  DatabaseConnectOptions,
-} from './adapter'
-
-export function postgresJs(): DatabaseAdapter {
-  return {
-    dialect: 'pg',
-    driver: 'postgres-js',
-    async connect<TSchema extends Record<string, unknown>>(
-      schema: TSchema,
-      { url }: DatabaseConnection,
-      { introspect }: DatabaseConnectOptions,
-    ) {
-      if (introspect) return { db: drizzle.mock({ schema }) as never }
-
-      if (!url.startsWith('postgres://') && !url.startsWith('postgresql://')) {
-        throw new Error(
-          '[bunderstack] postgresJs adapter requires a Postgres URL',
-        )
-      }
-      const db = drizzle<TSchema>({ connection: url, schema })
-      return { db: db as never, close: () => db.$client.end() }
-    },
-    async migrate(db, migrationsFolder) {
-      await migrate(db as never, { migrationsFolder })
-    },
-  }
-}

package/src/db.ts

@@ -1,61 +0,0 @@
-import type { LibSQLDatabase } from 'drizzle-orm/libsql'
-import type { PgDatabase, PgQueryResultHKT, PgTable } from 'drizzle-orm/pg-core'
-
-import type {
-  DatabaseAdapter,
-  DatabaseConnection,
-  DatabaseConnectionResult,
-} from './database/adapter'
-import type { Dialect } from './dialect'
-
-export type Driver = 'libsql' | 'pglite' | 'bun-sql' | 'postgres-js'
-
-/** Per-dialect public db type, computed from the schema's table brands. */
-export type DbFor<TSchema extends Record<string, unknown>> = [
-  Extract<TSchema[keyof TSchema], PgTable>,
-] extends [never]
-  ? LibSQLDatabase<TSchema>
-  : PgDatabase<PgQueryResultHKT, TSchema>
-
-const PG_SERVER_RE = /^postgres(ql)?:\/\//
-const LIBSQL_REMOTE_RE = /^(libsql|wss?|https?):\/\//
-
-export function validateDatabaseUrl(url: string, dialect: Dialect) {
-  if (dialect === 'sqlite') {
-    if (PG_SERVER_RE.test(url)) {
-      throw new Error(
-        '[bunderstack] DATABASE_URL is a Postgres URL but the schema uses sqliteTable. ' +
-          'Define the schema with drizzle-orm/pg-core, or point DATABASE_URL at a SQLite database.',
-      )
-    }
-  } else if (dialect === 'pg') {
-    if (LIBSQL_REMOTE_RE.test(url)) {
-      throw new Error(
-        '[bunderstack] DATABASE_URL looks like a libsql/Turso URL but the schema uses pgTable. ' +
-          'Set DATABASE_URL=postgres://… (or leave it unset for local PGlite).',
-      )
-    }
-  }
-}
-
-export async function createDb<TSchema extends Record<string, unknown>>(
-  schema: TSchema,
-  cfg: DatabaseConnection & {
-    adapter: DatabaseAdapter
-    dialect: Dialect
-    introspect?: boolean
-  },
-): Promise<DatabaseConnectionResult<TSchema> & { driver: Driver }> {
-  if (cfg.adapter.dialect !== cfg.dialect) {
-    throw new Error(
-      `[bunderstack] database adapter dialect ${cfg.adapter.dialect} does not match ${cfg.dialect} schema`,
-    )
-  }
-  if (!cfg.introspect) validateDatabaseUrl(cfg.url, cfg.dialect)
-  const result = await cfg.adapter.connect(
-    schema,
-    { url: cfg.url, authToken: cfg.authToken },
-    { introspect: cfg.introspect ?? false },
-  )
-  return { ...result, driver: cfg.adapter.driver }
-}

package/src/dialect.ts

@@ -1,38 +0,0 @@
-// src/dialect.ts — schema-driven dialect detection. Imports only dialect-core
-// drizzle entrypoints (no drivers), safe in every module graph.
-import { is } from 'drizzle-orm'
-import { PgTable } from 'drizzle-orm/pg-core'
-import { SQLiteTable } from 'drizzle-orm/sqlite-core'
-
-export type Dialect = 'sqlite' | 'pg'
-
-/**
- * Minimal structural view of a drizzle db shared by both dialects. Internal
- * modules run dynamic tables (Record<string, unknown> schemas) where drizzle's
- * generics add no safety, so they accept this instead of a per-dialect union.
- * The public surface (`app.db`, API context) keeps full per-dialect typing via
- * `DbFor` in db.ts.
- */
-export type AnyDb = {
-  select: (...args: any[]) => any
-  insert: (...args: any[]) => any
-  update: (...args: any[]) => any
-  delete: (...args: any[]) => any
-}
-
-/** Classify a schema by its table brands. Mixed dialects are a config error. */
-export function detectDialect(schema: Record<string, unknown>): Dialect {
-  let pgKey: string | undefined
-  let sqliteKey: string | undefined
-  for (const [key, value] of Object.entries(schema)) {
-    if (is(value, PgTable)) pgKey ??= key
-    else if (is(value, SQLiteTable)) sqliteKey ??= key
-  }
-  if (pgKey !== undefined && sqliteKey !== undefined) {
-    throw new Error(
-      `[bunderstack] schema mixes dialects: "${pgKey}" is a Postgres table while "${sqliteKey}" is a SQLite table. ` +
-        'Define every table with the same dialect (drizzle-orm/pg-core or drizzle-orm/sqlite-core).',
-    )
-  }
-  return pgKey !== undefined ? 'pg' : 'sqlite'
-}

package/src/email/smtp.ts

@@ -1,45 +0,0 @@
-import nodemailer from 'nodemailer'
-
-import type { EmailAdapter } from '../email'
-
-type SmtpTransport = {
-  sendMail(message: Record<string, unknown>): Promise<{ messageId?: string }>
-}
-
-export function createSmtpAdapter(
-  options: { url: string },
-  createTransport: (url: string) => SmtpTransport = (url) =>
-    nodemailer.createTransport(url) as SmtpTransport,
-): EmailAdapter {
-  const toArray = (v: string | string[] | undefined) =>
-    v === undefined ? undefined : Array.isArray(v) ? v : [v]
-
-  let transportPromise: Promise<{
-    sendMail(opts: Record<string, unknown>): Promise<{ messageId?: string }>
-  }> | null = null
-
-  const getTransport = () => {
-    transportPromise ??= Promise.resolve(createTransport(options.url))
-    return transportPromise
-  }
-
-  return {
-    async send(msg) {
-      const transport = await getTransport()
-      const info = await transport.sendMail({
-        from: msg.from,
-        to: toArray(msg.to)!.join(', '),
-        subject: msg.subject,
-        html: msg.html,
-        text: msg.text,
-        replyTo: msg.replyTo,
-        cc: toArray(msg.cc)?.join(', '),
-        bcc: toArray(msg.bcc)?.join(', '),
-      })
-      return { id: info.messageId }
-    },
-  }
-}
-
-export const smtp = (options: { url: string }): EmailAdapter =>
-  createSmtpAdapter(options)

package/src/email.ts

@@ -1,154 +0,0 @@
-// src/email.ts — email sending: console / resend / custom adapters.
-// SMTP is provided by the static `bunderstack/email/smtp` factory subpath.
-
-export type EmailMessage = {
-  to: string | string[]
-  subject: string
-  html?: string
-  text?: string
-  from?: string
-  replyTo?: string
-  cc?: string | string[]
-  bcc?: string | string[]
-}
-
-export type SentEmail = { id?: string }
-
-/** Adapters receive the message with `from` already resolved. */
-export type EmailAdapter = {
-  send(msg: EmailMessage & { from: string }): Promise<SentEmail>
-}
-
-export type EmailConfigInput = {
-  from: string
-  provider?: 'resend' | 'console' | EmailAdapter | EmailAdapter['send']
-}
-
-export type EmailFacade = {
-  send(msg: EmailMessage): Promise<SentEmail>
-}
-
-export type CreateEmailOptions = {
-  env: { RESEND_API_KEY?: string; SMTP_URL?: string; NODE_ENV?: string }
-  /** Test seam for the resend adapter. */
-  fetchFn?: typeof fetch
-}
-
-/** Root string provider tag ('resend' | 'console') or undefined. */
-export function emailProviderTag(
-  config: EmailConfigInput | undefined,
-): string | undefined {
-  return typeof config?.provider === 'string' ? config.provider : undefined
-}
-
-const toArray = (v: string | string[] | undefined) =>
-  v === undefined ? undefined : Array.isArray(v) ? v : [v]
-
-function createConsoleAdapter(): EmailAdapter {
-  return {
-    async send(msg) {
-      const line = '─'.repeat(60)
-      console.log(
-        [
-          line,
-          '📧 email (console provider — not sent)',
-          `from:    ${msg.from}`,
-          `to:      ${toArray(msg.to)!.join(', ')}`,
-          `subject: ${msg.subject}`,
-          line,
-          msg.text ?? msg.html ?? '',
-          line,
-        ].join('\n'),
-      )
-      return {}
-    },
-  }
-}
-
-function createResendAdapter(
-  apiKey: string,
-  fetchFn: typeof fetch,
-): EmailAdapter {
-  return {
-    async send(msg) {
-      const res = await fetchFn('https://api.resend.com/emails', {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          from: msg.from,
-          to: toArray(msg.to),
-          subject: msg.subject,
-          html: msg.html,
-          text: msg.text,
-          reply_to: msg.replyTo,
-          cc: toArray(msg.cc),
-          bcc: toArray(msg.bcc),
-        }),
-      })
-      if (!res.ok) {
-        throw new Error(`resend API error (${res.status}): ${await res.text()}`)
-      }
-      const data = (await res.json()) as { id?: string }
-      return { id: data.id }
-    },
-  }
-}
-
-function resolveAdapter(
-  config: EmailConfigInput,
-  opts: CreateEmailOptions,
-): EmailAdapter {
-  const provider = config.provider
-  if (typeof provider === 'function') return { send: provider }
-  if (typeof provider === 'object') return provider
-  const fetchFn = opts.fetchFn ?? globalThis.fetch.bind(globalThis)
-  switch (provider) {
-    case 'resend':
-      return createResendAdapter(opts.env.RESEND_API_KEY ?? '', fetchFn)
-
-    case 'console':
-      return createConsoleAdapter()
-    case undefined:
-      if (opts.env.NODE_ENV === 'production') {
-        throw new Error(
-          'email is configured without a provider — set email.provider ' +
-            "('resend' | a custom adapter) for production",
-        )
-      }
-      return createConsoleAdapter()
-    default:
-      if (provider === 'smtp') {
-        throw new Error(
-          "email provider 'smtp' was removed. Import `smtp` from 'bunderstack/email/smtp' instead.",
-        )
-      }
-      return createConsoleAdapter()
-  }
-}
-
-export function createEmail(
-  config: EmailConfigInput | undefined,
-  opts: CreateEmailOptions,
-): EmailFacade {
-  if (!config) {
-    return {
-      async send() {
-        throw new Error(
-          'email is not configured — add an email key to your bunderstack config',
-        )
-      },
-    }
-  }
-  const adapter = resolveAdapter(config, opts)
-  return {
-    async send(msg) {
-      if (!msg.html && !msg.text) {
-        throw new Error('email message needs html or text content')
-      }
-      return adapter.send({ ...msg, from: msg.from ?? config.from })
-    },
-  }
-}

package/src/env.ts

@@ -1,180 +0,0 @@
-// src/env.ts — env validation. Browser-safe: type-only Standard Schema import.
-import type { StandardSchemaV1 } from '@standard-schema/spec'
-
-import {
-  StandardSchemaValidationError,
-  validateStandardSchema,
-} from './standard-schema'
-
-export const CLIENT_PREFIX = 'PUBLIC_' as const
-
-export type EnvConfigInput = {
-  server?: Record<string, StandardSchemaV1>
-  client?: Record<string, StandardSchemaV1>
-  /** Explicit value source for client vars (e.g. Vite's import.meta.env). */
-  runtimeEnv?: Record<string, unknown>
-}
-
-export type BunderstackRole = 'all' | 'web' | 'worker'
-
-const ROLES: readonly BunderstackRole[] = ['all', 'web', 'worker']
-
-/** Vars bunderstack itself consumes, always validated. */
-export type BaseEnv = {
-  NODE_ENV?: string
-  DATABASE_URL: string
-  DATABASE_AUTH_TOKEN?: string
-  AUTH_SECRET: string
-  REDIS_URL?: string
-  RESEND_API_KEY?: string
-  SMTP_URL?: string
-  BUNDERSTACK_ROLE: BunderstackRole
-}
-
-type InferVars<T> =
-  T extends Record<string, StandardSchemaV1>
-    ? { [K in keyof T]: StandardSchemaV1.InferOutput<T[K]> }
-    : unknown
-
-// Non-distributive so `ValidatedEnv<undefined>` is BaseEnv, not `never`.
-export type ValidatedEnv<TEnv extends EnvConfigInput | undefined> = [
-  TEnv,
-] extends [EnvConfigInput]
-  ? BaseEnv &
-      InferVars<NonNullable<TEnv>['server']> &
-      InferVars<NonNullable<TEnv>['client']>
-  : BaseEnv
-
-export class BunderstackEnvError extends Error {
-  readonly issues: string[]
-
-  constructor(issues: string[]) {
-    super(`Invalid environment:\n  - ${issues.join('\n  - ')}`)
-    this.name = 'BunderstackEnvError'
-    this.issues = issues
-  }
-}
-
-export type ValidateEnvOptions = {
-  /** String tag of the configured email provider ('resend' | 'smtp'), if any. */
-  emailProvider?: string
-  /** Value source; defaults to process.env. Tests pass this explicitly. */
-  source?: Record<string, string | undefined>
-  /** Dialect-aware DATABASE_URL fallback; createBunderstack passes it. */
-  defaultDatabaseUrl?: string
-}
-
-const DEV_AUTH_SECRET = 'dev-secret-change-in-prod'
-
-function validateSection(
-  section: Record<string, StandardSchemaV1> | undefined,
-  kind: 'server' | 'client',
-  source: Record<string, unknown>,
-  issues: string[],
-  out: Record<string, unknown>,
-) {
-  for (const [key, schema] of Object.entries(section ?? {})) {
-    const isPublic = key.startsWith(CLIENT_PREFIX)
-    if (kind === 'server' && isPublic) {
-      issues.push(
-        `${key}: server vars must not start with ${CLIENT_PREFIX} (move it to env.client)`,
-      )
-      continue
-    }
-    if (kind === 'client' && !isPublic) {
-      issues.push(
-        `${key}: client vars must start with ${CLIENT_PREFIX} (rename it or move it to env.server)`,
-      )
-      continue
-    }
-    try {
-      out[key] = validateStandardSchema(schema, source[key], 'env')
-    } catch (error) {
-      if (!(error instanceof StandardSchemaValidationError)) throw error
-      for (const issue of error.issues) {
-        const path = issue.path.map(String).join('.')
-        issues.push(`${key}${path ? `.${path}` : ''}: ${issue.message}`)
-      }
-    }
-  }
-}
-
-export function validateEnv<TEnv extends EnvConfigInput | undefined>(
-  envConfig: TEnv,
-  options: ValidateEnvOptions = {},
-): ValidatedEnv<TEnv> {
-  const source =
-    options.source ?? (process.env as Record<string, string | undefined>)
-  const issues: string[] = []
-  const isProduction = source.NODE_ENV === 'production'
-
-  const base: BaseEnv = {
-    NODE_ENV: source.NODE_ENV,
-    DATABASE_URL:
-      source.DATABASE_URL ?? options.defaultDatabaseUrl ?? 'file:./data.db',
-    DATABASE_AUTH_TOKEN: source.DATABASE_AUTH_TOKEN,
-    AUTH_SECRET: source.AUTH_SECRET ?? DEV_AUTH_SECRET,
-    REDIS_URL: source.REDIS_URL,
-    RESEND_API_KEY: source.RESEND_API_KEY,
-    SMTP_URL: source.SMTP_URL,
-    BUNDERSTACK_ROLE: (source.BUNDERSTACK_ROLE ?? 'all') as BunderstackRole,
-  }
-  if (isProduction && !source.AUTH_SECRET) {
-    issues.push('AUTH_SECRET: required in production')
-  }
-  if (
-    source.BUNDERSTACK_ROLE !== undefined &&
-    !ROLES.includes(source.BUNDERSTACK_ROLE as BunderstackRole)
-  ) {
-    issues.push(
-      `BUNDERSTACK_ROLE: must be one of ${ROLES.join(', ')} (got "${String(source.BUNDERSTACK_ROLE)}")`,
-    )
-  }
-  if (options.emailProvider === 'resend' && !source.RESEND_API_KEY) {
-    issues.push("RESEND_API_KEY: required when email provider is 'resend'")
-  }
-  if (options.emailProvider === 'smtp' && !source.SMTP_URL) {
-    issues.push("SMTP_URL: required when email provider is 'smtp'")
-  }
-
-  const userVars: Record<string, unknown> = {}
-  validateSection(envConfig?.server, 'server', source, issues, userVars)
-  validateSection(envConfig?.client, 'client', source, issues, userVars)
-
-  // Introspection (Bunderhost builder) imports the app declaration to read
-  // its manifest; missing user env must not kill the boot there.
-  const lenient = source.BUNDERSTACK_INTROSPECT === '1'
-  if (issues.length > 0 && !lenient) throw new BunderstackEnvError(issues)
-  return { ...base, ...userVars } as ValidatedEnv<TEnv>
-}
-
-/**
- * Browser-side companion (t3-env style): validates ONLY the client section.
- * Server keys exist on the returned object as traps that throw on access, so
- * a leaked import fails loudly instead of silently reading undefined.
- */
-export function createClientEnv<TEnv extends EnvConfigInput>(
-  envConfig: TEnv,
-): InferVars<TEnv['client']> {
-  const source =
-    envConfig.runtimeEnv ??
-    (typeof process !== 'undefined'
-      ? (process.env as Record<string, unknown>)
-      : {})
-  const issues: string[] = []
-  const values: Record<string, unknown> = {}
-  validateSection(envConfig.client, 'client', source, issues, values)
-  if (issues.length > 0) throw new BunderstackEnvError(issues)
-
-  const serverKeys = new Set(Object.keys(envConfig.server ?? {}))
-  return new Proxy(values, {
-    get(target, prop) {
-      if (typeof prop === 'string' && serverKeys.has(prop)) {
-        throw new Error(
-          `${prop} is server-only and not available in client env`,
-        )
-      }
-      return Reflect.get(target, prop)
-    },
-  }) as InferVars<TEnv['client']>
-}