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

package/src/auth.ts

@@ -1,117 +0,0 @@
-// src/auth.ts
-import { betterAuth } from 'better-auth'
-import { drizzleAdapter } from 'better-auth/adapters/drizzle'
-import { openAPI } from 'better-auth/plugins'
-
-import type { AuthSessionResolver } from './access'
-import type { BetterAuthConfig } from './config'
-import type { AnyDb, Dialect } from './dialect'
-import type { EmailFacade } from './email'
-
-export function createAuth(
-  db: AnyDb,
-  cfg: BetterAuthConfig,
-  dialect: Dialect,
-  userSchema?: Record<string, unknown>,
-) {
-  const hasOpenApi = cfg.plugins?.some((p: any) => p.id === 'open-api')
-  const plugins = hasOpenApi ? cfg.plugins : [...(cfg.plugins || []), openAPI()]
-
-  return betterAuth({
-    ...cfg,
-    plugins,
-    database: drizzleAdapter(db as Parameters<typeof drizzleAdapter>[0], {
-      provider: dialect === 'pg' ? 'pg' : 'sqlite',
-      ...(userSchema ? { schema: userSchema } : {}),
-    }),
-  })
-}
-
-/**
- * Adapt the raw better-auth instance to our internal {@link AuthSessionResolver}
- * contract. better-auth's `getSession` has a union return (a bare session, or a
- * `{ headers, response }` wrapper when `returnHeaders` is set); we only ever
- * call the bare form, so we narrow on `'user' in result` and map to our shape.
- * Keeping this adapter here means internal modules never depend on better-auth's
- * evolving types.
- */
-export function toAuthSessionResolver(
-  auth: ReturnType<typeof createAuth>,
-): AuthSessionResolver {
-  return {
-    api: {
-      async getSession({ headers }) {
-        const result = await auth.api.getSession({ headers })
-        if (result && 'user' in result && result.user) {
-          const session = 'session' in result ? result.session : null
-          const activeOrganizationId =
-            session &&
-            'activeOrganizationId' in session &&
-            typeof session.activeOrganizationId === 'string'
-              ? session.activeOrganizationId
-              : null
-          const role =
-            'role' in result.user && typeof result.user.role === 'string'
-              ? result.user.role
-              : undefined
-          return {
-            user: {
-              id: result.user.id,
-              email: result.user.email,
-              name: result.user.name,
-              ...(role ? { role } : {}),
-            },
-            session: session ? { activeOrganizationId } : null,
-          }
-        }
-        return null
-      },
-    },
-  }
-}
-
-/**
- * Fill better-auth's email hooks from the bunderstack email facade. Only fills
- * gaps: user-supplied handlers always win, and nothing is injected when email
- * isn't configured. emailAndPassword is only touched when the user enabled it
- * (injecting it unasked would enable the feature).
- */
-export function withEmailAuthDefaults(
-  cfg: BetterAuthConfig,
-  email: EmailFacade,
-  emailConfigured: boolean,
-): BetterAuthConfig {
-  if (!emailConfigured) return cfg
-  const out: BetterAuthConfig = { ...cfg }
-
-  if (
-    cfg.emailAndPassword?.enabled &&
-    !cfg.emailAndPassword.sendResetPassword
-  ) {
-    out.emailAndPassword = {
-      ...cfg.emailAndPassword,
-      sendResetPassword: async ({ user, url }) => {
-        await email.send({
-          to: user.email,
-          subject: 'Reset your password',
-          text: `Click the link to reset your password:\n\n${url}\n\nIf you didn't request this, you can ignore this email.`,
-        })
-      },
-    }
-  }
-
-  if (!cfg.emailVerification?.sendVerificationEmail) {
-    out.emailVerification = {
-      ...cfg.emailVerification,
-      sendVerificationEmail: async ({ user, url }) => {
-        await email.send({
-          to: user.email,
-          subject: 'Verify your email',
-          text: `Click the link to verify your email address:\n\n${url}`,
-        })
-      },
-    }
-  }
-
-  return out
-}

package/src/blueprint-generator.ts

@@ -1,203 +0,0 @@
-import {
-  mkdir,
-  readFile,
-  realpath,
-  rename,
-  rm,
-  writeFile,
-} from 'node:fs/promises'
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-import {
-  blueprintFromManifest,
-  serializeBlueprint,
-  type BunderstackBlueprint,
-} from './blueprint'
-import { parseManifest } from './manifest'
-
-export type GenerateBlueprintOptions = {
-  directory: string
-  entry?: string
-  output?: string
-  check?: boolean
-}
-
-export type GenerateBlueprintResult = {
-  path: string
-  blueprint: BunderstackBlueprint
-  source: string
-  changed: boolean
-}
-
-export class BlueprintCheckError extends Error {
-  constructor() {
-    super(
-      'bunderstack.blueprint.yaml is missing or stale; run `bunderstack blueprint`',
-    )
-    this.name = 'BlueprintCheckError'
-  }
-}
-
-type AppPackage = {
-  scripts?: Record<string, unknown>
-  dependencies?: Record<string, unknown>
-  devDependencies?: Record<string, unknown>
-  bunderstack?: { entry?: unknown }
-}
-
-function requireRelativePath(value: string, label: string): string {
-  const normalized = value.replaceAll('\\', '/')
-  if (
-    !normalized ||
-    isAbsolute(normalized) ||
-    normalized.split('/').some((part) => !part || part === '..')
-  ) {
-    throw new Error(
-      `[bunderstack] ${label} must be a relative path without traversal`,
-    )
-  }
-  return normalized
-}
-
-function resolveWithin(root: string, value: string, label: string): string {
-  const path = resolve(root, requireRelativePath(value, label))
-  const pathFromRoot = relative(root, path)
-  if (
-    pathFromRoot === '..' ||
-    pathFromRoot.startsWith('../') ||
-    isAbsolute(pathFromRoot)
-  ) {
-    throw new Error(
-      `[bunderstack] ${label} must stay within the application directory`,
-    )
-  }
-  return path
-}
-
-function normalizeProjectPath(
-  root: string,
-  value: string,
-  label: string,
-): string {
-  if (!isAbsolute(value)) return requireRelativePath(value, label)
-  const pathFromRoot = relative(root, resolve(value)) || '.'
-  return requireRelativePath(pathFromRoot, label)
-}
-
-function requireScript(
-  pkg: AppPackage,
-  name: 'build' | 'start' | 'worker',
-  required: boolean,
-): boolean {
-  const value = pkg.scripts?.[name]
-  if (typeof value === 'string' && value.trim()) return true
-  if (required)
-    throw new Error(
-      `[bunderstack] package.json requires a non-empty "${name}" script`,
-    )
-  return false
-}
-
-async function packageVersion(): Promise<string> {
-  const pkg = (await Bun.file(
-    new URL('../package.json', import.meta.url),
-  ).json()) as { version: string }
-  return pkg.version
-}
-
-export async function generateBlueprint(
-  options: GenerateBlueprintOptions,
-): Promise<GenerateBlueprintResult> {
-  const directory = await realpath(resolve(options.directory))
-  const packagePath = join(directory, 'package.json')
-  const pkg = JSON.parse(await readFile(packagePath, 'utf8')) as AppPackage
-  const allDependencies = { ...pkg.dependencies, ...pkg.devDependencies }
-  if (typeof allDependencies['@tanstack/react-start'] !== 'string') {
-    throw new Error(
-      '[bunderstack] package.json must depend on @tanstack/react-start',
-    )
-  }
-  requireScript(pkg, 'build', true)
-  requireScript(pkg, 'start', true)
-
-  const configuredEntry = pkg.bunderstack?.entry
-  const entry = requireRelativePath(
-    options.entry ??
-      (typeof configuredEntry === 'string'
-        ? configuredEntry
-        : 'src/bunderstack.ts'),
-    'entry',
-  )
-  const entryPath = resolveWithin(directory, entry, 'entry')
-  if (!(await Bun.file(entryPath).exists())) {
-    throw new Error(`[bunderstack] entry does not exist: ${entry}`)
-  }
-  const output = requireRelativePath(
-    options.output ?? 'bunderstack.blueprint.yaml',
-    'output',
-  )
-  const outputPath = resolveWithin(directory, output, 'output')
-
-  const previousIntrospection = process.env.BUNDERSTACK_INTROSPECT
-  process.env.BUNDERSTACK_INTROSPECT = '1'
-  let app: { manifest?: unknown; close?: () => Promise<void> } | undefined
-  try {
-    const module = (await import(
-      `${pathToFileURL(entryPath).href}?blueprint=${Date.now()}`
-    )) as {
-      app?: typeof app
-    }
-    app = module.app
-    if (!app) throw new Error(`[bunderstack] ${entry} must export app`)
-    const manifest = parseManifest(app.manifest)
-    const workerRequired = manifest.background.jobs.length > 0
-    requireScript(pkg, 'worker', workerRequired)
-    const migrationsDirectory = normalizeProjectPath(
-      directory,
-      manifest.database.migrationsDirectory,
-      'migrationsDirectory',
-    )
-    const migrationJournal = join(
-      resolveWithin(directory, migrationsDirectory, 'migrationsDirectory'),
-      'meta',
-      '_journal.json',
-    )
-    const migrationMode = (await Bun.file(migrationJournal).exists())
-      ? 'migrations'
-      : 'push'
-    const blueprint = blueprintFromManifest({
-      manifest: {
-        ...manifest,
-        database: { ...manifest.database, migrationsDirectory },
-      },
-      generatorVersion: await packageVersion(),
-      entry,
-      migrationMode,
-    })
-    const source = serializeBlueprint(blueprint)
-    const existing = (await Bun.file(outputPath).exists())
-      ? await Bun.file(outputPath).text()
-      : undefined
-    if (options.check) {
-      if (existing !== source) throw new BlueprintCheckError()
-      return { path: outputPath, blueprint, source, changed: false }
-    }
-    if (existing === source)
-      return { path: outputPath, blueprint, source, changed: false }
-    await mkdir(dirname(outputPath), { recursive: true })
-    const temporary = `${outputPath}.${process.pid}.${Date.now()}.tmp`
-    try {
-      await writeFile(temporary, source, { mode: 0o600 })
-      await rename(temporary, outputPath)
-    } finally {
-      await rm(temporary, { force: true })
-    }
-    return { path: outputPath, blueprint, source, changed: true }
-  } finally {
-    await app?.close?.()
-    if (previousIntrospection === undefined)
-      delete process.env.BUNDERSTACK_INTROSPECT
-    else process.env.BUNDERSTACK_INTROSPECT = previousIntrospection
-  }
-}

package/src/blueprint.ts

@@ -1,264 +0,0 @@
-import * as v from 'valibot'
-import { parse, stringify } from 'yaml'
-
-import type { BunderstackManifest } from './manifest'
-
-import { parseCron } from './jobs/cron'
-import { validateStandardSchema } from './standard-schema'
-
-export type MigrationMode = 'migrations' | 'push'
-
-export type BunderstackBlueprint = {
-  version: 1
-  generator: { name: 'bunderstack'; version: string }
-  application: {
-    framework: 'tanstack-start'
-    scripts: { build: 'build'; start: 'start'; worker?: 'worker' }
-  }
-  bunderstack: { entry: string; manifestVersion: 3 }
-  resources: {
-    database: BunderstackManifest['database'] & { migrationMode: MigrationMode }
-    storage: BunderstackManifest['storage']
-    realtime?: { required: true }
-  }
-  environment: BunderstackManifest['environment']
-  background: BunderstackManifest['background'] & {
-    worker: { required: boolean }
-  }
-}
-
-const nonEmpty = v.pipe(v.string(), v.minLength(1))
-const relativePath = v.pipe(
-  nonEmpty,
-  v.check(
-    (value) =>
-      !value.startsWith('/') &&
-      !value.includes('\\') &&
-      value.split('/').every((part) => part !== '' && part !== '..'),
-    'entry must be 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 blueprintSchema = v.strictObject({
-  version: v.literal(1),
-  generator: v.strictObject({
-    name: v.literal('bunderstack'),
-    version: nonEmpty,
-  }),
-  application: v.strictObject({
-    framework: v.literal('tanstack-start'),
-    scripts: v.strictObject({
-      build: v.literal('build'),
-      start: v.literal('start'),
-      worker: v.optional(v.literal('worker')),
-    }),
-  }),
-  bunderstack: v.strictObject({
-    entry: relativePath,
-    manifestVersion: v.literal(3),
-  }),
-  resources: v.strictObject({
-    database: v.strictObject({
-      dialect: v.picklist(['sqlite', 'pg']),
-      migrationsDirectory: relativePath,
-      migrationMode: v.picklist(['migrations', 'push']),
-      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.optional(v.strictObject({ required: v.literal(true) })),
-  }),
-  environment: v.array(
-    v.strictObject({
-      key: nonEmpty,
-      required: v.boolean(),
-      scope: v.picklist(['server', 'client']),
-    }),
-  ),
-  background: v.strictObject({
-    worker: v.strictObject({ required: v.boolean() }),
-    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)
-  }
-}
-
-export function parseBlueprint(value: unknown): BunderstackBlueprint {
-  const blueprint = validateStandardSchema(
-    blueprintSchema,
-    value,
-    'blueprint',
-  ) as BunderstackBlueprint
-  rejectDuplicates(
-    'database physical table',
-    blueprint.resources.database.tables.map((entry) => entry.physicalName),
-  )
-  rejectDuplicates(
-    'database export table',
-    blueprint.resources.database.tables.map((entry) => entry.exportName),
-  )
-  rejectDuplicates(
-    'storage bucket',
-    blueprint.resources.storage.buckets.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'environment key',
-    blueprint.environment.map((entry) => entry.key),
-  )
-  rejectDuplicates(
-    'background job',
-    blueprint.background.jobs.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'background cron',
-    blueprint.background.cron.map((entry) => entry.name),
-  )
-  rejectDuplicates(
-    'background maintenance',
-    blueprint.background.maintenance.map((entry) => entry.name),
-  )
-  if (
-    !blueprint.resources.storage.buckets.some(
-      (bucket) => bucket.name === blueprint.resources.storage.defaultBucket,
-    )
-  ) {
-    throw new Error(
-      '[bunderstack] storage defaultBucket must be declared in storage buckets',
-    )
-  }
-  const workerRequired = blueprint.background.jobs.length > 0
-  if (blueprint.background.worker.required !== workerRequired) {
-    throw new Error(
-      '[bunderstack] background worker.required must match declared queue jobs',
-    )
-  }
-  if (Boolean(blueprint.application.scripts.worker) !== workerRequired) {
-    throw new Error(
-      '[bunderstack] application worker script must match declared queue jobs',
-    )
-  }
-  return blueprint
-}
-
-export function blueprintFromManifest(args: {
-  manifest: BunderstackManifest
-  generatorVersion: string
-  entry: string
-  migrationMode: MigrationMode
-}): BunderstackBlueprint {
-  const workerRequired = args.manifest.background.jobs.length > 0
-  return parseBlueprint({
-    version: 1,
-    generator: { name: 'bunderstack', version: args.generatorVersion },
-    application: {
-      framework: 'tanstack-start',
-      scripts: {
-        build: 'build',
-        start: 'start',
-        ...(workerRequired ? { worker: 'worker' } : {}),
-      },
-    },
-    bunderstack: { entry: args.entry, manifestVersion: 3 },
-    resources: {
-      database: {
-        ...args.manifest.database,
-        migrationMode: args.migrationMode,
-        tables: sortBy(
-          args.manifest.database.tables,
-          (entry) => entry.physicalName,
-        ),
-      },
-      storage: {
-        ...args.manifest.storage,
-        buckets: sortBy(args.manifest.storage.buckets, (entry) => entry.name),
-      },
-      ...(args.manifest.realtime.required
-        ? { realtime: { required: true } }
-        : {}),
-    },
-    environment: sortBy(args.manifest.environment, (entry) => entry.key),
-    background: {
-      worker: { required: workerRequired },
-      jobs: sortBy(args.manifest.background.jobs, (entry) => entry.name),
-      cron: sortBy(args.manifest.background.cron, (entry) => entry.name),
-      maintenance: sortBy(
-        args.manifest.background.maintenance,
-        (entry) => entry.name,
-      ),
-    },
-  })
-}
-
-export function parseBlueprintYaml(source: string): BunderstackBlueprint {
-  return parseBlueprint(parse(source) as unknown)
-}
-
-export function serializeBlueprint(value: BunderstackBlueprint): string {
-  const blueprint = parseBlueprint(value)
-  const options = {
-    aliasDuplicateObjects: false,
-    defaultKeyType: 'PLAIN',
-    defaultStringType: 'PLAIN',
-    lineWidth: 0,
-  } as const
-  const source = stringify(
-    parseBlueprintYaml(stringify(blueprint, options)),
-    options,
-  )
-  return source.replace(
-    /^(\s*schedule: )(.+)$/gm,
-    (_match, prefix: string, value: string) => {
-      const schedule = value.startsWith('"') ? JSON.parse(value) : value
-      return `${prefix}${JSON.stringify(schedule)}`
-    },
-  )
-}

package/src/cli.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env bun
-import {
-  BlueprintCheckError,
-  generateBlueprint,
-  type GenerateBlueprintOptions,
-} from './blueprint-generator'
-
-export type CliIo = {
-  stdout(message: string): void
-  stderr(message: string): void
-}
-
-const help = `Usage: bunderstack blueprint [directory] [--entry <path>] [--output <path>] [--check]
-
-Generate a committed deployment declaration for a TanStack Start application.
-Entry precedence: --entry, package.json#bunderstack.entry, src/bunderstack.ts.`
-
-export async function runCli(
-  args: string[],
-  io: CliIo,
-  generate: typeof generateBlueprint = generateBlueprint,
-): Promise<number> {
-  if (args[0] === '--help' || args[0] === '-h') {
-    io.stdout(help)
-    return 0
-  }
-  if (args[0] === '--version') {
-    io.stdout(
-      (
-        (await Bun.file(
-          new URL('../package.json', import.meta.url),
-        ).json()) as { version: string }
-      ).version,
-    )
-    return 0
-  }
-  if (args[0] !== 'blueprint') {
-    io.stderr(
-      'Usage: bunderstack blueprint [directory] [--entry <path>] [--output <path>] [--check]',
-    )
-    return 2
-  }
-  const options: GenerateBlueprintOptions = { directory: process.cwd() }
-  for (let index = 1; index < args.length; index++) {
-    const argument = args[index]!
-    if (argument === '--check') {
-      options.check = true
-      continue
-    }
-    if (argument === '--entry' || argument === '--output') {
-      const value = args[++index]
-      if (!value || value.startsWith('--')) {
-        io.stderr(`[bunderstack] missing value for ${argument}`)
-        return 2
-      }
-      if (argument === '--entry') options.entry = value
-      else options.output = value
-      continue
-    }
-    if (argument.startsWith('-')) {
-      io.stderr(`[bunderstack] unknown option: ${argument}`)
-      return 2
-    }
-    if (options.directory !== process.cwd()) {
-      io.stderr('[bunderstack] only one application directory is allowed')
-      return 2
-    }
-    options.directory = argument
-  }
-  try {
-    const result = await generate(options)
-    io.stdout(
-      options.check || !result.changed
-        ? 'bunderstack.blueprint.yaml is current'
-        : 'Generated bunderstack.blueprint.yaml',
-    )
-    return 0
-  } catch (error) {
-    io.stderr(error instanceof Error ? error.message : String(error))
-    return error instanceof BlueprintCheckError ? 1 : 1
-  }
-}
-
-if (import.meta.main) {
-  const exitCode = await runCli(process.argv.slice(2), {
-    stdout: (message) => console.log(message),
-    stderr: (message) => console.error(message),
-  })
-  process.exit(exitCode)
-}