The Complete Production SOP: Deploying Fastify High-Throughput JSON Schema Validation with TypeBox in Autonomous AI Agents

---
name: "fastify-schema-validation-typebox"
description: "Achieve maximum JSON serialization and validation throughput using Fastify and TypeBox."
metadata:
  author: "Fastify"
  version: "1.0.0"
  runtime_compatibility:
    - "codex"
    - "claude-code"
    - "cursor"
    - "windsurf"
triggers:
  - "fastify typebox schema"
  - "fast-json-stringify fastify"
  - "fastify swagger documentation"
permissions:
  fs_read: true
  fs_write: "workspace"
  shell_exec: false
  net_access: false
---

import Fastify from 'fastify';
import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
import swagger from '@fastify/swagger';
import swaggerUi from '@fastify/swagger-ui';

export const buildServer = async () => {
  const server = Fastify({
    logger: true
  }).withTypeProvider<TypeBoxTypeProvider>();

  await server.register(swagger, {
    openapi: {
      info: { title: 'High-Throughput API', version: '1.0.0' }
    }
  });

  await server.register(swaggerUi, {
    routePrefix: '/documentation'
  });

  return server;
};

import { FastifyPluginAsyncTypebox } from '@fastify/type-provider-typebox';
import { Type, Static } from '@sinclair/typebox';

export const CreateUserSchema = Type.Object({
  username: Type.String({ minLength: 3, maxLength: 32 }),
  email: Type.String({ format: 'email' }),
  roles: Type.Array(Type.Union([Type.Literal('admin'), Type.Literal('user')]), { default: ['user'] })
});
export type CreateUserType = Static<typeof CreateUserSchema>;

export const UserResponseSchema = Type.Object({
  id: Type.String({ format: 'uuid' }),
  username: Type.String(),
  email: Type.String(),
  roles: Type.Array(Type.String()),
  createdAt: Type.String({ format: 'date-time' })
});
export type UserResponseType = Static<typeof UserResponseSchema>;

export const userRoutes: FastifyPluginAsyncTypebox = async (fastify) => {
  fastify.post('/users', {
    schema: {
      summary: 'Register a new user',
      tags: ['Users'],
      body: CreateUserSchema,
      response: {
        201: UserResponseSchema
      }
    }
  }, async (request, reply) => {
    // request.body is fully typed as CreateUserType
    const { username, email, roles } = request.body;
    const newUser: UserResponseType = {
      id: crypto.randomUUID(),
      username,
      email,
      roles,
      createdAt: new Date().toISOString()
    };
    return reply.status(201).send(newUser);
  });
};

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { buildServer } from '../src/app';
import { userRoutes } from '../src/routes/users';

test('POST /users validates valid payload and filters properties', async () => {
  const server = await buildServer();
  await server.register(userRoutes);
  
  const response = await server.inject({
    method: 'POST',
    url: '/users',
    payload: {
      username: 'alice',
      email: '[email protected]',
      roles: ['user'],
      extraSecret: 'should-be-ignored'
    }
  });

  assert.equal(response.statusCode, 201);
  const body = response.json();
  assert.equal(body.username, 'alice');
  assert.equal(body.extraSecret, undefined);
  await server.close();
});