Zod v3 vs Zod v4 vs ArkType 2.0: JIT-компиляция схем и бенчмарки парсинга

+-------------------------------------------------------------------------+
|                  ИНТЕРПРЕТАТОР ZOD v3 (Tree-Walking)                    |
+-------------------------------------------------------------------------+
|  Входной JSON => [ ZodObject ]                                          |
|                        |                                                |
|                        +---> [ new ParseContext() ] (Аллокация кучи)    |
|                        +---> Цикл Object.keys(input)                    |
|                        +---> Вызов ZodString.parse() для каждого поля   |
|                        +---> [ new Set() / Array.push(issues) ]         |
|                        +---> Клонирование результата { ...output }      |
|  => Высокий оверхед CPU, тысячи аллокаций на запрос, GC Pauses          |
+-------------------------------------------------------------------------+
|                                                                         |
|                  JIT-КОМПИЛЯЦИЯ ARKTYPE 2.0 / ZOD v4                    |
+-------------------------------------------------------------------------+
|  Схема парсится ОДИН РАЗ при инициализации модуля:                      |
|  new Function("data", `                                                 |
|    if (typeof data !== "object" || data === null) return false;        |
|    if (typeof data.id !== "string") return false;                       |
|    if (typeof data.age !== "number" || data.age < 18) return false;    |
|    return true;                                                         |
|  `)                                                                     |
|                        |                                                |
|                        v                                                |
|  V8 TurboFan компилирует функцию напрямую в машинный код CPU!           |
|  => 0 лишних аллокаций объектов, плоские инструкции CMP, максимальный RPS|
+-------------------------------------------------------------------------+

import { z } from 'zod';
import { type } from 'arktype';

// 1. Схема на Zod v3: цепочечный объектно-ориентированный синтаксис
export const ZodUserSchema = z.object({
  id: z.string().uuid(),
  username: z.string().min(3).max(30),
  email: z.string().email(),
  age: z.number().int().min(18).max(120),
  role: z.enum(['admin', 'editor', 'viewer']),
  metadata: z.object({
    lastLoginIp: z.string().ip(),
    tags: z.array(z.string()).max(10),
  }),
});

// Статический инференс типа Zod
export type ZodUser = z.infer<typeof ZodUserSchema>;

// 2. Схема на ArkType 2.0: строковый синтаксис типов TypeScript с JIT-компиляцией
export const ArkUserSchema = type({
  id: 'string.uuid',
  username: '3 <= string <= 30',
  email: 'string.email',
  age: '18 <= integer <= 120',
  role: '"admin" | "editor" | "viewer"',
  metadata: {
    lastLoginIp: 'string.ip',
    tags: 'string[] <= 10',
  },
});

// Статический инференс типа ArkType (вычисляется мгновенно без нагрузки на tsc)
export type ArkUser = typeof ArkUserSchema.infer;

// Декомпилированное представление функции, создаваемой ArkType в V8
export function compiledJitValidator(data: unknown): { data?: unknown; problems?: string[] } {
  if (typeof data !== 'object' || data === null) {
    return { problems: ['Значение должно быть объектом'] };
  }

  const d = data as Record<string, unknown>;

  // Проверка id (UUID v4 regex)
  if (typeof d.id !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(d.id)) {
    return { problems: ['id должен быть валидным UUID v4'] };
  }

  // Проверка username (длина)
  const username = d.username;
  if (typeof username !== 'string' || username.length < 3 || username.length > 30) {
    return { problems: ['username должен иметь длину от 3 до 30 символов'] };
  }

  // Проверка age (integer)
  const age = d.age;
  if (typeof age !== 'number' || (age | 0) !== age || age < 18 || age > 120) {
    return { problems: ['age должен быть целым числом от 18 до 120'] };
  }

  // Проверка role
  const role = d.role;
  if (role !== 'admin' && role !== 'editor' && role !== 'viewer') {
    return { problems: ['role должен соответствовать объединению admin | editor | viewer'] };
  }

  // Никакого клонирования! Возврат исходной ссылки
  return { data: d };
}

import { ZodUserSchema } from './schema-definitions';
import { ArkUserSchema } from './schema-definitions';

// Валидный тестовый пейлоад
const validPayload = {
  id: "c8f1e4b2-3d5a-4e89-9a2c-1b4e6f8a9c0d",
  username: "senior_architect",
  email: "[email protected]",
  age: 32,
  role: "admin" as const,
  metadata: {
    lastLoginIp: "192.168.1.1",
    tags: ["typescript", "performance", "highload"],
  },
};

export interface BenchmarkMetrics {
  validatorName: string;
  operationsPerSecond: number;
  averageTimeNs: number;
  memoryAllocatedMb: number;
}

export function runPerformanceBenchmark(iterations: number = 100_000): BenchmarkMetrics[] {
  // ПРОГРЕВ V8 (Warm-up phase)
  for (let i = 0; i < 5000; i++) {
    ZodUserSchema.safeParse(validPayload);
    ArkUserSchema(validPayload);
  }

  // ТЕСТ 1: ZOD v3
  if (global.gc) global.gc();
  const memBeforeZod = process.memoryUsage().heapUsed;
  const startZod = performance.now();

  for (let i = 0; i < iterations; i++) {
    const result = ZodUserSchema.safeParse(validPayload);
    if (!result.success) throw new Error();
  }

  const durationZodMs = performance.now() - startZod;
  const memAfterZod = process.memoryUsage().heapUsed;

  // ТЕСТ 2: ARKTYPE 2.0 (JIT)
  if (global.gc) global.gc();
  const memBeforeArk = process.memoryUsage().heapUsed;
  const startArk = performance.now();

  for (let i = 0; i < iterations; i++) {
    const result = ArkUserSchema(validPayload);
    if (result instanceof type.errors) throw new Error();
  }

  const durationArkMs = performance.now() - startArk;
  const memAfterArk = process.memoryUsage().heapUsed;

  return [
    {
      validatorName: "Zod v3 (Tree-Walking)",
      operationsPerSecond: Math.round((iterations / durationZodMs) * 1000),
      averageTimeNs: Math.round((durationZodMs / iterations) * 1_000_000),
      memoryAllocatedMb: Number(((memAfterZod - memBeforeZod) / 1024 / 1024).toFixed(2)),
    },
    {
      validatorName: "ArkType 2.0 (JIT Engine)",
      operationsPerSecond: Math.round((iterations / durationArkMs) * 1000),
      averageTimeNs: Math.round((durationArkMs / iterations) * 1_000_000),
      memoryAllocatedMb: Number(((memAfterArk - memBeforeArk) / 1024 / 1024).toFixed(2)),
    },
  ];
}