@stjoseph/prumo 0.0.6 → 0.1.0

package/templates/api/src/domain/users/use-cases/find-profile.use-case.ts

@@ -0,0 +1,22 @@
+import { inject, injectable } from 'tsyringe'
+import type { Profile } from '@/domain/users/entities/profile.entity'
+import { ProfileNotFoundError } from '@/domain/users/errors/profile-not-found.error'
+import {
+  PROFILE_REPOSITORY,
+  type ProfileRepository,
+} from '@/domain/users/repositories/profile.repository'
+
+@injectable()
+export class FindProfileUseCase {
+  constructor(@inject(PROFILE_REPOSITORY) private readonly profiles: ProfileRepository) {}
+
+  async execute(userId: string): Promise<Profile> {
+    const profile = await this.profiles.findByUserId(userId)
+
+    if (profile === null) {
+      throw new ProfileNotFoundError()
+    }
+
+    return profile
+  }
+}

package/templates/api/src/domain/users/use-cases/update-profile.use-case.ts

@@ -0,0 +1,26 @@
+import { inject, injectable } from 'tsyringe'
+import type { UpdateProfileDto } from '@/domain/users/dto/update-profile.dto'
+import type { Profile } from '@/domain/users/entities/profile.entity'
+import { ProfileNotFoundError } from '@/domain/users/errors/profile-not-found.error'
+import {
+  PROFILE_REPOSITORY,
+  type ProfileRepository,
+} from '@/domain/users/repositories/profile.repository'
+
+@injectable()
+export class UpdateProfileUseCase {
+  constructor(@inject(PROFILE_REPOSITORY) private readonly profiles: ProfileRepository) {}
+
+  async execute(userId: string, changes: UpdateProfileDto): Promise<Profile> {
+    const profile = await this.profiles.findByUserId(userId)
+
+    if (profile === null) {
+      throw new ProfileNotFoundError()
+    }
+
+    profile.update(changes)
+    await this.profiles.save(profile)
+
+    return profile
+  }
+}

package/templates/api/src/infra/auth/auth.cli.ts

@@ -0,0 +1,5 @@
+import { loadEnv } from '@/infra/config/env'
+import { createAuth } from './auth.factory'
+
+// Read by Better Auth's CLI (`auth migrate --config`), which only needs the schema, not the hooks.
+export const auth = createAuth(loadEnv())

package/templates/api/src/{auth → infra/auth}/auth.factory.ts

@@ -1,7 +1,11 @@
+import { cimd } from '@better-auth/cimd' // prumo:mcp
+import { fetchClientMetadataResource } from '@better-auth/cimd/node' // prumo:mcp
 import { expo } from '@better-auth/expo'
+import { mcp } from '@better-auth/mcp' // prumo:mcp
 import { type BetterAuthPlugin, betterAuth } from 'better-auth'
+import { jwt } from 'better-auth/plugins' // prumo:mcp
 import { Pool } from 'pg'
-import type { Env } from '@/config/env'
+import type { Env } from '@/infra/config/env'
 
 type NewUser = { id: string; name: string }
 
@@ -9,6 +13,15 @@ export type AuthHooks = {
   onUserCreated?: (user: NewUser) => Promise<void>
 }
 
+export const AUTH = Symbol('Auth')
+
+// prumo:mcp
+// The protected resource MCP clients ask a token for; access tokens carry it as their audience.
+export function mcpResource(env: Pick<Env, 'BETTER_AUTH_URL'>): string {
+  return `${env.BETTER_AUTH_URL}/api/mcp`
+}
+
+// prumo:end-mcp
 export function createAuth(
   env: Pick<
     Env,
@@ -23,6 +36,18 @@ export function createAuth(
   const mobile = env.MOBILE_APP_SCHEME
   const plugins: BetterAuthPlugin[] = mobile === undefined ? [] : [expo()]
 
+  // prumo:mcp
+  plugins.push(
+    jwt(),
+    mcp({
+      loginPage: `${env.WEB_ORIGIN}/sign-in`,
+      consentPage: `${env.WEB_ORIGIN}/consent`,
+      resource: mcpResource(env),
+    }),
+    cimd({ fetchClientMetadataResource, metadataProfile: 'mcp-2026-07-28' }),
+  )
+
+  // prumo:end-mcp
   return betterAuth({
     baseURL: env.BETTER_AUTH_URL,
     basePath: '/api/auth',

package/templates/api/src/infra/config/env.ts

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs'
+import { z } from 'zod'
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'test', 'production']),
+  PORT: z.coerce.number().int().min(1).max(65535),
+  DATABASE_URL: z.string().min(1),
+  AUTH_DATABASE_URL: z.string().min(1),
+  BETTER_AUTH_SECRET: z.string().min(32),
+  BETTER_AUTH_URL: z.string().min(1),
+  WEB_ORIGIN: z.string().min(1),
+  MOBILE_APP_SCHEME: z
+    .string()
+    .regex(/^[a-z][a-z0-9+.-]*$/)
+    .optional(),
+  LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug']),
+})
+
+export type Env = z.infer<typeof envSchema>
+
+export const ENV = Symbol('Env')
+
+export function validate(raw: Record<string, unknown>): Env {
+  const result = envSchema.safeParse(raw)
+
+  if (!result.success) {
+    const named = [...new Set(result.error.issues.map((issue) => issue.path.join('.')))].join(', ')
+    throw new Error(`Invalid environment: ${named}`)
+  }
+
+  loaded = result.data
+  return result.data
+}
+
+let loaded: Env | undefined
+
+export function loadEnv(): Env {
+  if (loaded !== undefined) {
+    return loaded
+  }
+
+  if (process.env.NODE_ENV !== 'production' && existsSync('.env')) {
+    process.loadEnvFile('.env')
+  }
+
+  return validate(process.env)
+}

package/templates/api/src/infra/database/mikroorm/entities/auth-user.schema.ts

@@ -0,0 +1,16 @@
+import { EntitySchema } from '@mikro-orm/core'
+
+// Better Auth owns auth.user. This maps only its id, so a foreign key into it is declared rather than
+// hand-written; schema diffing skips the table, and nothing reads or writes it through the ORM.
+export class AuthUser {
+  id: string
+}
+
+export const AuthUserSchema = new EntitySchema({
+  class: AuthUser,
+  schema: 'auth',
+  tableName: 'user',
+  properties: {
+    id: { type: 'uuid', primary: true },
+  },
+})

package/templates/api/src/infra/database/mikroorm/entities/profile.schema.ts

@@ -0,0 +1,28 @@
+import { EntitySchema } from '@mikro-orm/core'
+import { Profile } from '@/domain/users/entities/profile.entity'
+
+export const ProfileSchema = new EntitySchema({
+  class: Profile,
+  properties: {
+    id: { type: 'uuid', primary: true, defaultRaw: 'uuidv7()' },
+    userId: {
+      kind: 'm:1',
+      // EntitySchema cannot type a to-one relation held as its primary key on a string property.
+      entity: () => 'AuthUser' as never,
+      mapToPk: true,
+      fieldName: 'user_id',
+      unique: true,
+      deleteRule: 'restrict',
+    },
+    displayName: { type: 'text' },
+    locale: { type: 'text', default: 'en' },
+    timezone: { type: 'text', default: 'UTC' },
+    createdAt: { type: 'datetime', onCreate: () => new Date(), defaultRaw: 'now()' },
+    updatedAt: {
+      type: 'datetime',
+      onCreate: () => new Date(),
+      onUpdate: () => new Date(),
+      defaultRaw: 'now()',
+    },
+  },
+})

package/templates/api/src/{mikro-orm.config.ts → infra/database/mikroorm/mikro-orm.config.ts}

@@ -1,4 +1,4 @@
-import { loadEnv } from './config/env'
+import { loadEnv } from '@/infra/config/env'
 import { createOrmConfig } from './mikro-orm.factory'
 
 export default createOrmConfig(loadEnv())

package/templates/api/src/infra/database/mikroorm/mikro-orm.factory.ts

@@ -0,0 +1,17 @@
+import { Migrator } from '@mikro-orm/migrations'
+import { defineConfig } from '@mikro-orm/postgresql'
+import type { Env } from '@/infra/config/env'
+import { AuthUserSchema } from './entities/auth-user.schema'
+import { ProfileSchema } from './entities/profile.schema'
+
+export function createOrmConfig(env: Pick<Env, 'DATABASE_URL' | 'NODE_ENV'>) {
+  return defineConfig({
+    clientUrl: env.DATABASE_URL,
+    entities: [ProfileSchema, AuthUserSchema],
+    extensions: [Migrator],
+    migrations: { path: './migrations', snapshot: false },
+    // Better Auth migrates its own schema; without this, every generated migration drops it.
+    schemaGenerator: { ignoreSchema: ['auth'], skipTables: ['auth.user'] },
+    debug: env.NODE_ENV === 'development',
+  })
+}

package/templates/api/src/infra/database/mikroorm/repositories/mikroorm-profile.repository.ts

@@ -0,0 +1,17 @@
+import { EntityManager } from '@mikro-orm/postgresql'
+import { injectable } from 'tsyringe'
+import { Profile } from '@/domain/users/entities/profile.entity'
+import type { ProfileRepository } from '@/domain/users/repositories/profile.repository'
+
+@injectable()
+export class MikroOrmProfileRepository implements ProfileRepository {
+  constructor(private readonly em: EntityManager) {}
+
+  findByUserId(userId: string): Promise<Profile | null> {
+    return this.em.findOne(Profile, { userId })
+  }
+
+  async save(profile: Profile): Promise<void> {
+    await this.em.persist(profile).flush()
+  }
+}

package/templates/api/src/infra/database/mikroorm/transactions/mikroorm-transaction-manager.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from '@mikro-orm/postgresql'
+import { injectable } from 'tsyringe'
+import type { TransactionManager } from '@/domain/shared/transactions/transaction-manager'
+
+@injectable()
+export class MikroOrmTransactionManager implements TransactionManager {
+  constructor(private readonly em: EntityManager) {}
+
+  // Inside the callback the global EntityManager resolves to the transaction's fork, so every
+  // repository that injected it joins the transaction without being handed anything.
+  run<T>(work: () => Promise<T>): Promise<T> {
+    return this.em.transactional(() => work())
+  }
+}

package/templates/api/src/infra/di/index.ts

@@ -0,0 +1,32 @@
+import { EntityManager, MikroORM } from '@mikro-orm/postgresql'
+import { type DependencyContainer, container as root } from 'tsyringe'
+import { TRANSACTION_MANAGER } from '@/domain/shared/transactions/transaction-manager'
+import { CreateProfileUseCase } from '@/domain/users/use-cases/create-profile.use-case'
+import { AUTH, createAuth } from '@/infra/auth/auth.factory'
+import { ENV, type Env } from '@/infra/config/env'
+import { MikroOrmTransactionManager } from '@/infra/database/mikroorm/transactions/mikroorm-transaction-manager'
+import { registerUsers } from './users.di'
+
+export type Dependencies = { env: Env; orm: MikroORM }
+
+export function createContainer({ env, orm }: Dependencies): DependencyContainer {
+  const container = root.createChildContainer()
+
+  container.register(ENV, { useValue: env })
+  container.register(MikroORM, { useValue: orm })
+  // The global EntityManager: inside a request it resolves to that request's fork by itself.
+  container.register(EntityManager, { useValue: orm.em })
+  container.register(TRANSACTION_MANAGER, { useClass: MikroOrmTransactionManager })
+
+  registerUsers(container)
+
+  container.register(AUTH, {
+    useValue: createAuth(env, {
+      onUserCreated: async (user) => {
+        await container.resolve(CreateProfileUseCase).execute(user.id, user.name)
+      },
+    }),
+  })
+
+  return container
+}

package/templates/api/src/infra/di/users.di.ts

@@ -0,0 +1,7 @@
+import type { DependencyContainer } from 'tsyringe'
+import { PROFILE_REPOSITORY } from '@/domain/users/repositories/profile.repository'
+import { MikroOrmProfileRepository } from '@/infra/database/mikroorm/repositories/mikroorm-profile.repository'
+
+export function registerUsers(container: DependencyContainer): void {
+  container.register(PROFILE_REPOSITORY, { useClass: MikroOrmProfileRepository })
+}

package/templates/api/src/infra/http/app.ts

@@ -0,0 +1,99 @@
+import { randomUUID } from 'node:crypto'
+import cors from '@fastify/cors'
+import swagger from '@fastify/swagger'
+import swaggerUi from '@fastify/swagger-ui'
+import { EntityManager } from '@mikro-orm/postgresql'
+import Fastify, { type FastifyInstance } from 'fastify'
+import {
+  jsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler,
+} from 'fastify-type-provider-zod'
+import type { DependencyContainer } from 'tsyringe'
+import { ENV, type Env } from '@/infra/config/env'
+import { authController } from '@/infra/http/controllers/auth.controller'
+import { healthController } from '@/infra/http/controllers/health.controller'
+import { mcpController } from '@/infra/http/controllers/mcp.controller' // prumo:mcp
+import { usersController } from '@/infra/http/controllers/users.controller'
+import { registerErrorHandler } from '@/infra/http/errors/error-handler'
+import { registerAuthHook } from '@/infra/http/hooks/auth.hook'
+import { registerRequestContext } from '@/infra/http/hooks/request-context.hook'
+
+const DOCS = '/api/docs'
+const VERSIONED = '/api/v'
+
+function logger(env: Env) {
+  if (env.NODE_ENV === 'test') {
+    return false
+  }
+
+  return {
+    level: env.LOG_LEVEL,
+    redact: ['req.headers.authorization', 'req.headers.cookie', 'res.headers["set-cookie"]'],
+    transport: env.NODE_ENV === 'development' ? { target: 'pino-pretty' } : undefined,
+  }
+}
+
+function requireResponseSchemas(app: FastifyInstance): void {
+  // Without a response schema Fastify falls back to JSON.stringify, and every column of the entity leaves.
+  app.addHook('onRoute', (route) => {
+    if (route.url.startsWith(VERSIONED) && route.schema?.response === undefined) {
+      throw new Error(`${String(route.method)} ${route.url} declares no response schema`)
+    }
+  })
+}
+
+async function registerDocs(app: FastifyInstance): Promise<void> {
+  // The UI's own routes are declared by the plugin, which cannot be told they are public.
+  app.addHook('onRoute', (route) => {
+    if (route.url.startsWith(DOCS)) {
+      route.config = { ...route.config, public: true }
+    }
+  })
+
+  await app.register(swagger, {
+    openapi: { info: { title: 'API', version: '1' } },
+    transform: jsonSchemaTransform,
+  })
+  await app.register(swaggerUi, { routePrefix: DOCS })
+}
+
+export async function buildApp(container: DependencyContainer): Promise<FastifyInstance> {
+  const env = container.resolve<Env>(ENV)
+  const app = Fastify({
+    logger: logger(env),
+    requestIdHeader: 'x-request-id',
+    genReqId: () => randomUUID(),
+  })
+
+  app.decorate('container', container)
+  app.setValidatorCompiler(validatorCompiler)
+  app.setSerializerCompiler(serializerCompiler)
+
+  registerErrorHandler(app)
+  requireResponseSchemas(app)
+  registerRequestContext(app, container.resolve(EntityManager))
+
+  await app.register(cors, {
+    origin: env.WEB_ORIGIN,
+    credentials: true,
+    // Without a list, only the CORS-safelisted GET, HEAD and POST pass a preflight.
+    methods: ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'],
+    exposedHeaders: ['X-Request-Id'],
+  })
+
+  if (env.NODE_ENV !== 'production') {
+    await registerDocs(app)
+  }
+
+  registerAuthHook(app)
+
+  await app.register(authController)
+  await app.register(healthController, { prefix: '/api/health' })
+  await app.register(usersController, { prefix: '/api/v1/users' })
+  // prumo:mcp
+  await app.register(mcpController, { prefix: '/api/mcp' })
+  // prumo:end-mcp
+
+  return app
+}

package/templates/api/src/infra/http/controllers/auth.controller.ts

@@ -0,0 +1,36 @@
+import type { FastifyInstance } from 'fastify'
+import { AUTH, type Auth } from '@/infra/auth/auth.factory'
+import { sendFetchResponse, toFetchRequest } from '@/infra/http/fetch-bridge'
+
+export async function authController(fastify: FastifyInstance): Promise<void> {
+  const auth = fastify.container.resolve<Auth>(AUTH)
+  const routes = { config: { public: true }, schema: { hide: true } } as const
+
+  // prumo:mcp
+  // OAuth's token endpoint takes a form. It is kept as text and handed to Better Auth as sent.
+  fastify.addContentTypeParser(
+    'application/x-www-form-urlencoded',
+    { parseAs: 'string' },
+    (_request, body, done) => done(null, body),
+  )
+  // prumo:end-mcp
+
+  fastify.route({
+    ...routes,
+    method: ['GET', 'POST'],
+    url: '/api/auth/*',
+    handler: async (request, reply) =>
+      sendFetchResponse(reply, await auth.handler(toFetchRequest(request))),
+  })
+
+  // prumo:mcp
+  // OAuth discovery lives at the root, outside Better Auth's base path, and still reaches its handler.
+  fastify.route({
+    ...routes,
+    method: 'GET',
+    url: '/.well-known/*',
+    handler: async (request, reply) =>
+      sendFetchResponse(reply, await auth.handler(toFetchRequest(request))),
+  })
+  // prumo:end-mcp
+}

package/templates/api/src/infra/http/controllers/health.controller.ts

@@ -0,0 +1,19 @@
+import { MikroORM } from '@mikro-orm/postgresql'
+import type { FastifyInstance } from 'fastify'
+
+export async function healthController(fastify: FastifyInstance): Promise<void> {
+  const orm = fastify.container.resolve(MikroORM)
+  const quiet = { config: { public: true }, logLevel: 'silent' } as const
+
+  fastify.get('/live', quiet, async () => ({ status: 'ok' }))
+
+  fastify.get('/ready', quiet, async (_request, reply) => {
+    const database = await orm.checkConnection()
+
+    if (!database.ok) {
+      return reply.code(503).send({ status: 'error', error: { database: { status: 'down' } } })
+    }
+
+    return { status: 'ok', info: { database: { status: 'up' } } }
+  })
+}

package/templates/api/src/infra/http/controllers/mcp.controller.ts

@@ -0,0 +1,40 @@
+import { requireMcpAuth } from '@better-auth/mcp'
+import type { AuthInfo } from '@modelcontextprotocol/server'
+import type { FastifyInstance } from 'fastify'
+import { AUTH, type Auth, mcpResource } from '@/infra/auth/auth.factory'
+import { ENV, type Env } from '@/infra/config/env'
+import { sendFetchResponse, toFetchRequest } from '@/infra/http/fetch-bridge'
+import { createMcpServerHandler } from '@/infra/mcp/mcp.server'
+
+type AccessTokenClaims = Parameters<Parameters<typeof requireMcpAuth>[1]>[1]
+
+function authInfoOf(request: Request, claims: AccessTokenClaims): AuthInfo {
+  const scope = typeof claims.scope === 'string' ? claims.scope : ''
+  const clientId = claims.azp ?? claims.client_id
+
+  return {
+    token: request.headers.get('authorization')?.replace(/^\w+\s+/, '') ?? '',
+    clientId: typeof clientId === 'string' ? clientId : '',
+    scopes: scope.split(' ').filter(Boolean),
+    ...(claims.exp === undefined ? {} : { expiresAt: claims.exp }),
+    extra: { userId: claims.sub },
+  }
+}
+
+// The route answers a bearer access token, never a session cookie, so the session hook stands aside.
+export async function mcpController(fastify: FastifyInstance): Promise<void> {
+  const auth = fastify.container.resolve<Auth>(AUTH)
+  const env = fastify.container.resolve<Env>(ENV)
+  const mcp = createMcpServerHandler(fastify.container)
+  const handle = requireMcpAuth(
+    auth,
+    (request, claims) => mcp.fetch(request, { authInfo: authInfoOf(request, claims) }),
+    { resource: mcpResource(env) },
+  )
+
+  fastify.addHook('onClose', () => mcp.close())
+
+  fastify.post('/', { config: { public: true }, schema: { hide: true } }, async (request, reply) =>
+    sendFetchResponse(reply, await handle(toFetchRequest(request))),
+  )
+}

package/templates/api/src/infra/http/controllers/users.controller.ts

@@ -0,0 +1,35 @@
+import type { FastifyInstance } from 'fastify'
+import type { ZodTypeProvider } from 'fastify-type-provider-zod'
+import { profileResponseSchema } from '@/domain/users/dto/profile-response.dto'
+import { updateProfileSchema } from '@/domain/users/dto/update-profile.dto'
+import { FindProfileUseCase } from '@/domain/users/use-cases/find-profile.use-case'
+import { UpdateProfileUseCase } from '@/domain/users/use-cases/update-profile.use-case'
+import { currentUser } from '@/infra/http/hooks/auth.hook'
+
+export async function usersController(fastify: FastifyInstance): Promise<void> {
+  const app = fastify.withTypeProvider<ZodTypeProvider>()
+
+  app.get(
+    '/me',
+    { schema: { tags: ['users'], response: { 200: profileResponseSchema } } },
+    async (request) => {
+      return app.container.resolve(FindProfileUseCase).execute(currentUser(request).id)
+    },
+  )
+
+  app.patch(
+    '/me',
+    {
+      schema: {
+        tags: ['users'],
+        body: updateProfileSchema,
+        response: { 200: profileResponseSchema },
+      },
+    },
+    async (request) => {
+      return app.container
+        .resolve(UpdateProfileUseCase)
+        .execute(currentUser(request).id, request.body)
+    },
+  )
+}

package/templates/api/src/infra/http/errors/error-handler.ts

@@ -0,0 +1,116 @@
+import type { FastifyError, FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
+import { hasZodFastifySchemaValidationErrors } from 'fastify-type-provider-zod'
+import { DomainError, type DomainErrorKind } from '@/domain/shared/errors/domain-error'
+
+type FieldErrors = Record<string, string[]>
+
+type ProblemDocument = {
+  type: string
+  title: string
+  status: number
+  detail: string
+  instance: string
+  requestId: string
+  errors?: FieldErrors
+}
+
+const STATUS_OF: Record<DomainErrorKind, number> = {
+  not_found: 404,
+  conflict: 409,
+  invalid: 422,
+  forbidden: 403,
+  unauthorized: 401,
+}
+
+const TITLES: Record<number, string> = {
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  403: 'Forbidden',
+  404: 'Not Found',
+  409: 'Conflict',
+  413: 'Payload Too Large',
+  415: 'Unsupported Media Type',
+  422: 'Unprocessable Entity',
+  500: 'Internal Server Error',
+  503: 'Service Unavailable',
+}
+
+function fieldOf(instancePath: string, key?: string): string {
+  return [...instancePath.split('/').filter(Boolean), ...(key === undefined ? [] : [key])].join('.')
+}
+
+function fieldErrors(error: FastifyError): FieldErrors | undefined {
+  if (!hasZodFastifySchemaValidationErrors(error)) {
+    return undefined
+  }
+
+  const fields: FieldErrors = {}
+  const add = (field: string, message: string) => {
+    fields[field] = [...(fields[field] ?? []), message]
+  }
+
+  for (const issue of error.validation) {
+    if (issue.keyword === 'unrecognized_keys') {
+      for (const key of (issue.params as { keys: string[] }).keys) {
+        add(fieldOf(issue.instancePath, key), 'Unrecognized key')
+      }
+    } else {
+      add(fieldOf(issue.instancePath), issue.message ?? 'Invalid value')
+    }
+  }
+
+  return fields
+}
+
+export function statusOf(error: FastifyError): number {
+  if (error instanceof DomainError) {
+    return STATUS_OF[error.kind]
+  }
+
+  return typeof error.statusCode === 'number' ? error.statusCode : 500
+}
+
+function detailOf(error: FastifyError, status: number, errors: FieldErrors | undefined): string {
+  if (errors !== undefined) {
+    return 'Validation failed'
+  }
+
+  return status < 500 ? error.message : 'An unexpected error occurred.'
+}
+
+function send(
+  request: FastifyRequest,
+  reply: FastifyReply,
+  problem: Omit<ProblemDocument, 'type' | 'title' | 'instance' | 'requestId'>,
+) {
+  const document: ProblemDocument = {
+    type: 'about:blank',
+    title: TITLES[problem.status] ?? 'Error',
+    instance: request.url,
+    requestId: request.id,
+    ...problem,
+  }
+
+  return reply.code(problem.status).type('application/problem+json').send(document)
+}
+
+export function registerErrorHandler(app: FastifyInstance): void {
+  app.setErrorHandler((error: FastifyError, request, reply) => {
+    const status = statusOf(error)
+    const errors = fieldErrors(error)
+
+    if (status >= 500) {
+      request.log.error(error)
+    }
+
+    return send(request, reply, {
+      status,
+      detail: detailOf(error, status, errors),
+      ...(errors === undefined ? {} : { errors }),
+    })
+  })
+
+  app.setNotFoundHandler((request, reply) =>
+    send(request, reply, { status: 404, detail: `Cannot ${request.method} ${request.url}` }),
+  )
+}

package/templates/api/src/infra/http/errors/http-error.ts

@@ -0,0 +1,8 @@
+export class HttpError extends Error {
+  constructor(
+    readonly statusCode: number,
+    message: string,
+  ) {
+    super(message)
+  }
+}