The TypeScript backend
framework.

import { Router } from '@pearl-framework/http'
import { Authenticate } from '@pearl-framework/auth'

const router = new Router()

// Public
router.get('/health', ctx =>
  ctx.json({ status: 'ok', ts: Date.now() })
)

// Params, query, body — all typed
router.get('/posts/:id', async ctx => {
  const id   = ctx.param('id')
  const page = ctx.query('page') ?? '1'
  const post = await db.query.posts
    .findFirst({ where: eq(posts.id, Number(id)) })
  return post
    ? ctx.json(post)
    : ctx.json({ error: 'Not found' }, 404)
})

// Protected — Authenticate() is a typed middleware
router.post('/posts', createPost, [Authenticate(auth)])
router.put('/posts/:id',  updatePost, [Authenticate(auth)])

import { pgTable, serial, text, integer, timestamp } from 'drizzle-orm/pg-core'

export const posts = pgTable('posts', {
  id:        serial('id').primaryKey(),
  title:     text('title').notNull(),
  content:   text('content').notNull(),
  authorId:  integer('author_id').references(() => users.id),
  status:    text('status', { enum: ['draft','published'] })
               .notNull().default('draft'),
  createdAt: timestamp('created_at').defaultNow(),
})

// Fully typed, full autocomplete
const post = await db.query.posts.findFirst({
  where: eq(posts.id, Number(ctx.param('id'))),
  with:  { author: true },
})

// $ pearl migrate

import { FormRequest } from '@pearl-framework/validate'
import { z } from 'zod'

export class CreatePostRequest extends FormRequest {
  schema = z.object({
    title:   z.string().min(3).max(120),
    content: z.string().min(10),
    tags:    z.array(z.string()).max(5).optional(),
    status:  z.enum(['draft', 'published']).default('draft'),
  })
}

async function createPost(ctx: HttpContext) {
  const data = await CreatePostRequest.validate(ctx)
  // data is fully typed: { title: string, content: string, ... }
  const [post] = await db.insert(posts).values(data).returning()
  return ctx.json(post, 201)
}

// Bad input auto-rejected:
// HTTP 422 { errors: { title: ['Too short'] } }

import { Job } from '@pearl-framework/queue'
import { Event, Listen, emit } from '@pearl-framework/events'

class SendWelcomeEmailJob extends Job {
  userId!: number

  async handle() {
    await Mail.send(new WelcomeMail(this.userId))
  }
}

class UserRegisteredEvent extends Event {
  constructor(public user: User) { super() }
}

// Fire from your service
await emit(new UserRegisteredEvent(user))

@Listen(UserRegisteredEvent)
class OnUserRegistered {
  async handle({ user }: UserRegisteredEvent) {
    await Queue.dispatch(
      Object.assign(new SendWelcomeEmailJob(), { userId: user.id })
    )
  }
}

import { Router, HttpKernel } from '@pearl-framework/http'
import { ErrorHandler } from './middleware/ErrorHandler.js'
import { SecurityHeaders } from './middleware/SecurityHeaders.js'
import { Cors } from './middleware/Cors.js'
import { apiRateLimit } from './middleware/RateLimit.js'

const router = new Router()

// Order matters — error handler outermost, rate limit innermost
router.use(new ErrorHandler())
router.use(new SecurityHeaders())
router.use(new Cors())
router.use(apiRateLimit)

const kernel = new HttpKernel({
  maxBodyBytes:     1024 * 1024,                  // 1 MiB cap
  onUnhandledError: (err) => apm.report(err),     // never leaks to clients
})

await kernel.useRouter(router).listen(3000)