TypeBox: статична типізація на чистому JSON Schema для High-Load API

+-------------------------------------------------------------------------+
|                  АРХІТЕКТУРА ЄДИНОГО ДЖЕРЕЛА TYPEBOX                    |
|                  const UserSchema = Type.Object({ ... })                |
+-------------------------------------------------------------------------+
|                                    |                                    |
|      +-----------------------------+-----------------------------+      |
|      |                             |                             |      |
|      v                             v                             v      |
| [ TypeScript Type ]      [ Чистий JSON Schema ]       [ Специфікація ]  |
| type User =              {                            [   OpenAPI    ]  |
|   Static<typeof Schema>    "type": "object",          Автоматична       |
| Строга типізація IDE       "properties": { ... }      генерація Swagger |
|                            }                          документації      |
|                                    |                                    |
|                    +---------------+---------------+                    |
|                    |                               |                    |
|                    v                               v                    |
|          [ JIT Валідатор: Ajv ]        [ Серіалізатор Fastify ]         |
|          Компіляція схеми у V8         fast-json-stringify:             |
|          машинний код (100k+ RPS)      Блискавична відповідь клієнту    |
+-------------------------------------------------------------------------+

import { Type, Static } from '@sinclair/typebox';

// Перелік статусів замовлення
export const OrderStatusSchema = Type.Union([
  Type.Literal('PENDING'),
  Type.Literal('PROCESSING'),
  Type.Literal('COMPLETED'),
  Type.Literal('CANCELLED'),
]);

// Схема позиції замовлення
export const OrderItemSchema = Type.Object({
  productId: Type.String({ format: 'uuid' }),
  sku: Type.String({ minLength: 3, maxLength: 20 }),
  quantity: Type.Integer({ minimum: 1, maximum: 100 }),
  unitPriceCents: Type.Integer({ minimum: 0 }),
});

// Головна схема створення замовлення
export const CreateOrderSchema = Type.Object({
  customerId: Type.String({ format: 'uuid' }),
  items: Type.Array(OrderItemSchema, { minItems: 1, maxItems: 50 }),
  discountCode: Type.Optional(Type.String({ pattern: '^[A-Z0-9]{4,12}$' })),
  shippingAddress: Type.Object({
    country: Type.String({ minLength: 2, maxLength: 2 }), // ISO-3166-1 alpha-2
    city: Type.String({ minLength: 1 }),
    postalCode: Type.String({ minLength: 3, maxLength: 10 }),
    streetAddress: Type.String({ minLength: 5 }),
  }),
  metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
});

// Статичний інференс чистих TypeScript-типів
export type OrderStatus = Static<typeof OrderStatusSchema>;
export type OrderItem = Static<typeof OrderItemSchema>;
export type CreateOrderPayload = Static<typeof CreateOrderSchema>;

// Демонстрація: у рантаймі CreateOrderSchema — це ЧИСТИЙ ОБ'ЄКТ JSON SCHEMA!
console.log(JSON.stringify(CreateOrderSchema, null, 2));
/*
Виведе стандартний JSON Schema:
{
  "type": "object",
  "properties": {
    "customerId": { "type": "string", "format": "uuid" },
    "items": {
      "type": "array",
      "items": { ... },
      "minItems": 1
    },
    ...
  },
  "required": ["customerId", "items", "shippingAddress"]
}
*/

import { TypeCompiler } from '@sinclair/typebox/compiler';
import { CreateOrderSchema, CreateOrderPayload } from './order-schema';

// КОМПІЛЯЦІЯ ВИКОНУЄТЬСЯ СТРОГО ОДИН РАЗ ПРИ СТАРТІ СЕРВЕРА
export const CompiledOrderValidator = TypeCompiler.Compile(CreateOrderSchema);

export function validateOrderPayload(rawInput: unknown): {
  isValid: boolean;
  data?: CreateOrderPayload;
  errors?: string[];
} {
  // 1. Ультрашвидка перевірка в машинному коді V8 (Check)
  const isValid = CompiledOrderValidator.Check(rawInput);

  if (!isValid) {
    // 2. Якщо дані невалідні, вилучаємо деталі через генератор Errors
    const errors: string[] = [];
    for (const error of CompiledOrderValidator.Errors(rawInput)) {
      errors.push(`${error.path}: ${error.message} (отримано: ${JSON.stringify(error.value)})`);
    }

    return {
      isValid: false,
      errors,
    };
  }

  // 3. Дані валідні, повертаємо зі строгою типізацією
  return {
    isValid: true,
    data: rawInput as CreateOrderPayload,
  };
}

import Fastify from 'fastify';
import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
import fastifySwagger from '@fastify/swagger';
import fastifySwaggerUi from '@fastify/swagger-ui';
import { CreateOrderSchema, CreateOrderPayload } from './order-schema';
import { Type } from '@sinclair/typebox';

// Ініціалізація сервера Fastify із провайдером типів TypeBox
const server = Fastify({
  logger: true,
}).withTypeProvider<TypeBoxTypeProvider>();

// Реєстрація OpenAPI Swagger (напряму споживає схеми TypeBox!)
async function bootstrap() {
  await server.register(fastifySwagger, {
    openapi: {
      info: {
        title: 'High-Load Orders API',
        version: '1.0.0',
      },
    },
  });

  await server.register(fastifySwaggerUi, {
    routePrefix: '/docs',
  });

  // Реєстрація ендпоінта з подвійною схемою: вхідна валідація + fast-json-stringify для виводу
  server.post(
    '/api/v1/orders',
    {
      schema: {
        summary: 'Створення нового замовлення',
        body: CreateOrderSchema,
        response: {
          201: Type.Object({
            orderId: Type.String({ format: 'uuid' }),
            status: Type.Literal('CREATED'),
            totalCents: Type.Integer(),
          }),
          400: Type.Object({
            statusCode: Type.Integer(),
            error: Type.String(),
            message: Type.String(),
          }),
        },
      },
    },
    async (request, reply) => {
      // request.body СТРОГО типізований як CreateOrderPayload завдяки TypeBoxTypeProvider!
      const { customerId, items } = request.body;

      const totalCents = items.reduce((sum, item) => sum + item.unitPriceCents * item.quantity, 0);
      const generatedOrderId = crypto.randomUUID();

      // Відповідь серіалізується через fast-json-stringify зі схемою 201
      return reply.status(201).send({
        orderId: generatedOrderId,
        status: 'CREATED',
        totalCents,
      });
    }
  );

  await server.listen({ port: 8080, host: '0.0.0.0' });
  console.log('High-Load Fastify сервер запущено на http://localhost:8080/docs');
}

bootstrap().catch(console.error);