The batteries-included framework for Bun

import { z } from 'zod'
import { route } from '../../../route'

export default route(
  {
    auth: true,
    params: z.object({ id: z.uuid() }),
    body:   z.object({ file: z.file().max(5_000_000) }),
  },
  async (ctx) => {
    // every one of these is typed, validated and guarded
    const { key } = await ctx.storage.upload(`avatars/${ctx.params.id}`, ctx.body.file)

    await ctx.queue.dispatch(resizeAvatar, { key })

    return ctx.db.update(users).set({ avatar: key }).where(eq(users.id, ctx.user.id))
  },
)

import { createApp, loadRoutes } from '@theoven/core'
import { auth } from '@theoven/auth'
import { basicAuth } from '@theoven/auth-basic'
import { db } from '@theoven/db'
import { drizzleSqlite } from '@theoven/db-drizzle'
import { mail, resendMail } from '@theoven/mail'
import { s3Storage, storage } from '@theoven/storage'
import { queue, redisQueue } from '@theoven/queue'

export const app = createApp()
  .use(db(drizzleSqlite({ url: './data.db', schema })))
  .use(storage(s3Storage({ bucket: 'uploads' })))
  .use(queue(redisQueue(), { jobs: [resizeAvatar] }))
  .use(mail(resendMail({ apiKey, from })))
  .use(auth(basicAuth({ db: client, secret })))

// eight auth endpoints, an OpenAPI document and /docs — all mounted
await loadRoutes(app, `${import.meta.dir}/routes`)

import type { Brick } from '@theoven/core'

// A brick is a function returning a descriptor. That is the whole contract.
export function clock(): Brick<'clock', { now(): Date }> {
  return {
    name: 'clock',
    setup: () => ({ now: () => new Date() }),
  }
}

const app = createApp().use(clock())

app.get('/time', (ctx) => ({ now: ctx.clock.now() }))
//                                    ^ typed, because setup's return flowed through .use()