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

+-------------------------------------------------------------------------+
|                  ІНТЕРПРЕТАТОР ZOD v3 (Tree-Walking)                    |
+-------------------------------------------------------------------------+
|  Вхідний JSON => [ ZodObject ]                                          |
|                        |                                                |
|                        +---> [ new ParseContext() ] (Алокація купи)     |
|                        +---> Цикл Object.keys(input)                    |
|                        +---> Виклик ZodString.parse() для кожного поля  |
|                        +---> [ new Set() / Array.push(issues) ]         |
|                        +---> Клонування результату { ...output }        |
|  => Високий оверхед CPU, тисячі алокацій на запит, паузи збирача сміття |
+-------------------------------------------------------------------------+
|                                                                         |
|                  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)),
    },
  ];
}