fastify-ata 0.2.21 → 0.2.23

package/bench-realtime.js

@@ -0,0 +1,131 @@
+'use strict'
+
+// Real-time Fastify simulation: actual HTTP requests with autocannon
+// Shows: startup time + request throughput + latency
+
+const { writeFileSync, unlinkSync } = require('fs')
+const { fork, execSync } = require('child_process')
+const path = require('path')
+
+const ROUTES = 50
+const DURATION = 5 // seconds
+const CONNECTIONS = 50
+
+function makeRoutes(count) {
+  return Array.from({ length: count }, (_, i) => ({
+    path: `/api/v1/resource${i}`,
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer', minimum: 1 },
+          name: { type: 'string', minLength: 1, maxLength: 100 },
+          email: { type: 'string', format: 'email' },
+          age: { type: 'integer', minimum: 0, maximum: 150 },
+          active: { type: 'boolean' },
+          role: { enum: ['admin', 'user', 'moderator'] },
+        },
+        required: ['id', 'name', 'email', 'active', 'role'],
+      },
+    },
+  }))
+}
+
+const routes = makeRoutes(ROUTES)
+const payload = JSON.stringify({
+  id: 42, name: 'Mert', email: 'mert@example.com',
+  age: 26, active: true, role: 'admin'
+})
+
+function serverScript(useAta) {
+  return `
+'use strict'
+const t0 = process.hrtime.bigint()
+const fastify = require('fastify')()
+${useAta ? "fastify.register(require('./index'))" : ''}
+const routes = ${JSON.stringify(routes)}
+for (const r of routes) {
+  fastify.post(r.path, { schema: r.schema }, (req, reply) => {
+    reply.send({ ok: true, id: req.body.id })
+  })
+}
+fastify.listen({ port: 0 }).then(() => {
+  const startupMs = Number(process.hrtime.bigint() - t0) / 1e6
+  const port = fastify.server.address().port
+  process.send({ port, startupMs })
+})
+`
+}
+
+async function runTest(label, useAta) {
+  const scriptPath = path.join(__dirname, '_realtime_server.js')
+  writeFileSync(scriptPath, serverScript(useAta))
+
+  const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
+  const { port, startupMs } = await new Promise(resolve => {
+    child.on('message', msg => resolve(msg))
+  })
+
+  // Pick a random route for each request
+  const targetRoute = routes[Math.floor(Math.random() * routes.length)].path
+  const escaped = payload.replace(/'/g, "'\\''")
+
+  let result
+  try {
+    const raw = execSync(
+      `npx autocannon -c ${CONNECTIONS} -d ${DURATION} -j http://localhost:${port}${targetRoute} -m POST -H "content-type: application/json" -b '${escaped}'`,
+      { cwd: __dirname, timeout: 30000 }
+    ).toString()
+    result = JSON.parse(raw)
+  } catch (e) {
+    child.kill()
+    try { unlinkSync(scriptPath) } catch {}
+    return null
+  }
+
+  child.kill()
+  try { unlinkSync(scriptPath) } catch {}
+
+  return {
+    label,
+    startupMs,
+    reqPerSec: result.requests.average,
+    latencyAvg: result.latency.average,
+    latencyP99: result.latency.p99,
+    throughputMB: (result.throughput.average / 1024 / 1024).toFixed(1),
+    errors: result.errors,
+    timeouts: result.timeouts,
+  }
+}
+
+async function main() {
+  console.log('\n' + '='.repeat(60))
+  console.log('  Real-Time Fastify Simulation')
+  console.log(`  ${ROUTES} routes, ${CONNECTIONS} connections, ${DURATION}s duration`)
+  console.log('  POST with 6-field validated body')
+  console.log('='.repeat(60) + '\n')
+
+  const ata = await runTest('fastify-ata', true)
+  const ajv = await runTest('fastify (ajv)', false)
+
+  if (!ata || !ajv) { console.log('Benchmark failed'); return }
+
+  console.log('                    fastify-ata     fastify (ajv)')
+  console.log('  ─────────────────────────────────────────────────')
+  console.log(`  Startup           ${ata.startupMs.toFixed(1).padStart(8)} ms     ${ajv.startupMs.toFixed(1).padStart(8)} ms`)
+  console.log(`  Requests/sec      ${ata.reqPerSec.toLocaleString().padStart(8)}         ${ajv.reqPerSec.toLocaleString().padStart(8)}`)
+  console.log(`  Latency (avg)     ${ata.latencyAvg.toFixed(2).padStart(8)} ms     ${ajv.latencyAvg.toFixed(2).padStart(8)} ms`)
+  console.log(`  Latency (p99)     ${ata.latencyP99.toFixed(2).padStart(8)} ms     ${ajv.latencyP99.toFixed(2).padStart(8)} ms`)
+  console.log(`  Throughput        ${ata.throughputMB.padStart(8)} MB/s    ${ajv.throughputMB.padStart(8)} MB/s`)
+  console.log(`  Errors            ${String(ata.errors).padStart(8)}         ${String(ajv.errors).padStart(8)}`)
+  console.log(`  Timeouts          ${String(ata.timeouts).padStart(8)}         ${String(ajv.timeouts).padStart(8)}`)
+  console.log()
+
+  const startupRatio = ajv.startupMs / ata.startupMs
+  const rpsRatio = ata.reqPerSec / ajv.reqPerSec
+  console.log(`  Startup: ata ${startupRatio.toFixed(1)}x faster`)
+  console.log(`  Throughput: ata ${rpsRatio.toFixed(2)}x ${rpsRatio >= 1 ? 'faster' : 'slower'}`)
+  console.log()
+}
+
+main().catch(err => { console.error(err); process.exit(1) })

package/bench-startup.js

@@ -1,168 +1,100 @@
 'use strict'
 
-const { execSync } = require('child_process')
-const { writeFileSync, unlinkSync, mkdirSync, rmSync } = require('fs')
+// Matteo's scenario: Fastify startup time with N routes
+// This is what he cares about most
+
+const { writeFileSync, unlinkSync } = require('fs')
 const path = require('path')
 
-// Generate N route schemas
-function makeSchemas(n) {
-  const schemas = []
-  for (let i = 0; i < n; i++) {
-    schemas.push({
-      type: 'object',
-      properties: {
-        id: { type: 'integer', minimum: 1 },
-        name: { type: 'string', minLength: 1 },
-        email: { type: 'string', format: 'email' },
-        active: { type: 'boolean' },
-        [`field_${i}`]: { type: 'string' },
+function makeRouteSchemas(count) {
+  const routes = []
+  for (let i = 0; i < count; i++) {
+    routes.push({
+      path: `/api/v1/resource${i}`,
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            id: { type: 'integer', minimum: 1 },
+            name: { type: 'string', minLength: 1, maxLength: 100 },
+            email: { type: 'string', format: 'email' },
+            [`field_${i}`]: { type: 'string' },
+            active: { type: 'boolean' },
+          },
+          required: ['id', 'name', 'email'],
+        },
+        querystring: {
+          type: 'object',
+          properties: {
+            page: { type: 'integer', minimum: 1 },
+            limit: { type: 'integer', minimum: 1, maximum: 100 },
+          },
+        },
       },
-      required: ['id', 'name', 'email', 'active'],
     })
   }
-  return schemas
+  return routes
 }
 
-function serverScript(mode, n) {
-  const schemas = makeSchemas(n)
-
-  if (mode === 'ajv-normal') {
-    return `
+function serverScript(useAta, routeCount) {
+  const routes = makeRouteSchemas(routeCount)
+  return `
 'use strict'
-const start = performance.now()
+const t0 = process.hrtime.bigint()
 const fastify = require('fastify')()
-const schemas = ${JSON.stringify(schemas)}
-schemas.forEach((s, i) => {
-  fastify.post('/route' + i, { schema: { body: s } }, (req, reply) => reply.send({ ok: true }))
-})
-fastify.ready().then(() => {
-  const ms = performance.now() - start
-  process.send({ ms })
-  process.exit()
-})
-`
-  }
-
-  if (mode === 'ata-normal') {
-    return `
-'use strict'
-const start = performance.now()
-const fastify = require('fastify')()
-fastify.register(require('./index'))
-const schemas = ${JSON.stringify(schemas)}
-schemas.forEach((s, i) => {
-  fastify.post('/route' + i, { schema: { body: s } }, (req, reply) => reply.send({ ok: true }))
-})
-fastify.ready().then(() => {
-  const ms = performance.now() - start
-  process.send({ ms })
-  process.exit()
-})
-`
-  }
-
-  if (mode === 'ata-standalone') {
-    return `
-'use strict'
-const start = performance.now()
-const fastify = require('fastify')()
-const { Validator } = require('ata-validator')
-const schemas = ${JSON.stringify(schemas)}
-const cache = new WeakMap()
-fastify.setValidatorCompiler(({ schema }) => {
-  let v = cache.get(schema)
-  if (!v) {
-    const idx = schemas.indexOf(schema)
-    if (idx >= 0) {
-      try {
-        const mod = require('./standalone/s' + idx + '.js')
-        v = Validator.fromStandalone(mod, schema)
-      } catch {
-        v = new Validator(schema)
-      }
-    } else {
-      v = new Validator(schema)
-    }
-    cache.set(schema, v)
-  }
-  return (data) => {
-    const r = v.validate(data)
-    if (r.valid) return { value: data }
-    const err = new Error(r.errors.map(e => e.message).join(', '))
-    err.statusCode = 400
-    err.validation = r.errors.map(e => ({ message: e.message, instancePath: e.path || '' }))
-    return { error: err }
-  }
-})
-schemas.forEach((s, i) => {
-  fastify.post('/route' + i, { schema: { body: s } }, (req, reply) => reply.send({ ok: true }))
-})
+${useAta ? "fastify.register(require('./index'))" : ''}
+const routes = ${JSON.stringify(routes)}
+for (const r of routes) {
+  fastify.post(r.path, { schema: r.schema }, (req, reply) => {
+    reply.send({ ok: true })
+  })
+}
 fastify.ready().then(() => {
-  const ms = performance.now() - start
-  process.send({ ms })
-  process.exit()
+  const dt = Number(process.hrtime.bigint() - t0) / 1e6
+  process.send({ startupMs: dt })
+  process.exit(0)
 })
 `
-  }
 }
 
-async function bench(label, mode, n) {
-  const scriptPath = path.join(__dirname, '_startup_server.js')
-  writeFileSync(scriptPath, serverScript(mode, n))
-
-  // Pre-build standalone files if needed
-  if (mode === 'ata-standalone') {
-    const { Validator } = require('ata-validator')
-    const schemas = makeSchemas(n)
-    const dir = path.join(__dirname, 'standalone')
-    mkdirSync(dir, { recursive: true })
-    schemas.forEach((s, i) => {
-      const v = new Validator(s)
-      const src = v.toStandalone()
-      if (src) writeFileSync(path.join(dir, `s${i}.js`), src)
-    })
-  }
-
-  const runs = 5
+async function measureStartup(useAta, routeCount, runs) {
+  const scriptPath = path.join(__dirname, '_startup_bench.js')
   const times = []
+
   for (let r = 0; r < runs; r++) {
+    writeFileSync(scriptPath, serverScript(useAta, routeCount))
     const { fork } = require('child_process')
+    const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
     const ms = await new Promise((resolve, reject) => {
-      const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
-      child.on('message', (msg) => resolve(msg.ms))
+      child.on('message', msg => resolve(msg.startupMs))
       child.on('error', reject)
-      setTimeout(() => { child.kill(); reject(new Error('timeout')); }, 10000)
+      setTimeout(() => { child.kill(); reject(new Error('timeout')) }, 10000)
     })
     times.push(ms)
   }
 
-  try { unlinkSync(path.join(__dirname, '_startup_server.js')) } catch {}
-
+  try { unlinkSync(scriptPath) } catch {}
   times.sort((a, b) => a - b)
-  const median = times[Math.floor(times.length / 2)]
-  console.log(`  ${label.padEnd(30)} ${median.toFixed(1)}ms (median of ${runs})`)
-  return median
+  return times[Math.floor(times.length / 2)]
 }
 
 async function main() {
   console.log('\n==============================================')
-  console.log('  Fastify Startup Benchmark')
-  console.log('  Time from process start to app.ready()')
+  console.log('  Fastify Startup Benchmark (cold start)')
+  console.log('  Median of 5 runs, process-isolated')
   console.log('==============================================\n')
 
-  for (const n of [10, 50, 100]) {
-    console.log(`--- ${n} routes ---`)
-    const ajv = await bench('fastify + ajv (default)', 'ajv-normal', n)
-    const ata = await bench('fastify + ata (normal)', 'ata-normal', n)
-    const standalone = await bench('fastify + ata (standalone)', 'ata-standalone', n)
-    console.log(`  ajv default: ${ajv.toFixed(1)}ms`)
-    console.log(`  ata normal:  ${ata.toFixed(1)}ms (${(ajv/ata).toFixed(1)}x vs ajv)`)
-    console.log(`  ata standalone: ${standalone.toFixed(1)}ms (${(ajv/standalone).toFixed(1)}x vs ajv)`)
+  for (const count of [5, 10, 25, 50, 100]) {
+    console.log(`--- ${count} routes (body + querystring schemas) ---`)
+
+    const ata = await measureStartup(true, count, 5)
+    const ajv = await measureStartup(false, count, 5)
+
+    console.log(`  ata: ${ata.toFixed(1).padStart(8)} ms`)
+    console.log(`  ajv: ${ajv.toFixed(1).padStart(8)} ms`)
+    console.log(`  >>> ata ${(ajv / ata).toFixed(1)}x faster startup`)
     console.log()
   }
-
-  // Cleanup
-  try { rmSync(path.join(__dirname, 'standalone'), { recursive: true }) } catch {}
 }
 
-main().catch(console.error)
+main().catch(err => { console.error(err); process.exit(1) })

package/bench-turbo.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const { execSync } = require('child_process')
+const { writeFileSync, unlinkSync } = require('fs')
+const path = require('path')
+
+const schema = {
+  body: {
+    type: 'object',
+    properties: {
+      users: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'integer', minimum: 1 },
+            name: { type: 'string', minLength: 1 },
+            email: { type: 'string', format: 'email' },
+            age: { type: 'integer', minimum: 0, maximum: 150 },
+            active: { type: 'boolean' },
+            role: { enum: ['admin', 'user', 'moderator'] },
+          },
+          required: ['id', 'name', 'email', 'active', 'role'],
+        },
+      },
+      metadata: {
+        type: 'object',
+        properties: {
+          total: { type: 'integer' },
+          page: { type: 'integer', minimum: 1 },
+        },
+        required: ['total', 'page'],
+      },
+    },
+    required: ['users', 'metadata'],
+  },
+}
+
+function makePayload(n) {
+  const users = []
+  for (let i = 0; i < n; i++) {
+    users.push({
+      id: i + 1,
+      name: `User ${i}`,
+      email: `user${i}@example.com`,
+      age: 25,
+      active: true,
+      role: 'user',
+    })
+  }
+  return JSON.stringify({ users, metadata: { total: n, page: 1 } })
+}
+
+function serverScript(turbo) {
+  return `
+'use strict'
+const fastify = require('fastify')()
+fastify.register(require('./index'), { turbo: ${turbo} })
+const schema = ${JSON.stringify(schema)}
+fastify.post('/users', { schema }, (req, reply) => {
+  reply.send({ ok: true, count: req.body.users.length })
+})
+fastify.listen({ port: 0 }).then(() => {
+  process.send({ port: fastify.server.address().port })
+})
+`
+}
+
+async function bench(label, turbo, payload) {
+  const scriptPath = path.join(__dirname, '_bench_turbo_server.js')
+  writeFileSync(scriptPath, serverScript(turbo))
+
+  const { fork } = require('child_process')
+  const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
+  const port = await new Promise((resolve) => {
+    child.on('message', (msg) => resolve(msg.port))
+  })
+
+  const escaped = payload.replace(/'/g, "'\\''")
+  const result = execSync(
+    `npx autocannon -c 10 -d 5 -j http://localhost:${port}/users -m POST -H "content-type: application/json" -b '${escaped}'`,
+    { cwd: __dirname, timeout: 30000 },
+  ).toString()
+
+  child.kill()
+  try { unlinkSync(scriptPath) } catch {}
+
+  const parsed = JSON.parse(result)
+  return parsed.requests.average
+}
+
+async function main() {
+  console.log('\n==============================================')
+  console.log('  Turbo Mode Benchmark: normal vs turbo')
+  console.log('  10 connections, 5 seconds, real HTTP')
+  console.log('==============================================\n')
+
+  for (const count of [1, 10, 50, 100]) {
+    const payload = makePayload(count)
+    console.log(`--- ${count} users (${(payload.length / 1024).toFixed(1)} KB) ---`)
+
+    const normal = await bench('normal', false, payload)
+    const turbo = await bench('turbo', true, payload)
+
+    console.log(`  normal: ${normal.toLocaleString().padStart(10)} req/sec`)
+    console.log(`  turbo:  ${turbo.toLocaleString().padStart(10)} req/sec`)
+
+    const ratio = turbo / normal
+    if (ratio >= 1) console.log(`  >>> turbo ${ratio.toFixed(2)}x faster`)
+    else console.log(`  >>> normal ${(1 / ratio).toFixed(2)}x faster`)
+    console.log()
+  }
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/index.d.ts

@@ -1,5 +1,16 @@
 import { FastifyPluginCallback } from 'fastify'
 
-declare const fastifyAta: FastifyPluginCallback<{}>
+interface FastifyAtaOptions {
+  coerceTypes?: boolean
+  removeAdditional?: boolean
+  /**
+   * Enable turbo mode: overrides the JSON content-type parser to receive
+   * the raw Buffer and uses simdjson-backed validateJSON for validation
+   * instead of V8's JSON.parse path. Incompatible with coerceTypes.
+   */
+  turbo?: boolean
+}
+
+declare const fastifyAta: FastifyPluginCallback<FastifyAtaOptions>
 
 export = fastifyAta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "Fastify plugin for ata-validator — beats ajv on every valid-path benchmark. 2.7x faster validate(obj), 151x faster compilation, simdjson + multi-core.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -26,8 +26,8 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^0.8.0",
-    "fastify-ata": "^0.2.16",
+    "ata-validator": "^0.11.0",
+    "fastify-ata": "^0.2.21",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/profile-fastify.mjs

@@ -0,0 +1,87 @@
+'use strict'
+
+// Profile validation overhead in Fastify context
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+
+const { Validator } = require('ata-validator')
+
+// Simulate what Fastify does: JSON.parse + validate
+const schema = {
+  type: 'object',
+  properties: {
+    users: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer', minimum: 1 },
+          name: { type: 'string', minLength: 1 },
+          email: { type: 'string', format: 'email' },
+          age: { type: 'integer', minimum: 0, maximum: 150 },
+          active: { type: 'boolean' },
+          role: { enum: ['admin', 'user', 'moderator'] },
+        },
+        required: ['id', 'name', 'email', 'active', 'role'],
+      },
+    },
+    metadata: {
+      type: 'object',
+      properties: {
+        total: { type: 'integer' },
+        page: { type: 'integer', minimum: 1 },
+      },
+      required: ['total', 'page'],
+    },
+  },
+  required: ['users', 'metadata'],
+}
+
+function makePayload(n) {
+  const users = []
+  for (let i = 0; i < n; i++) {
+    users.push({ id: i+1, name: `User ${i}`, email: `u${i}@x.com`, age: 25, active: true, role: 'user' })
+  }
+  return JSON.stringify({ users, metadata: { total: n, page: 1 } })
+}
+
+const v = new Validator(schema)
+const payloads = [1, 10, 50, 100].map(n => ({ n, json: makePayload(n) }))
+
+// Warmup
+for (const p of payloads) {
+  for (let i = 0; i < 1000; i++) {
+    const obj = JSON.parse(p.json)
+    v.validate(obj)
+  }
+}
+
+console.log('Breakdown: JSON.parse vs validate vs total\n')
+
+const N = 100000
+for (const p of payloads) {
+  // JSON.parse only
+  let t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) JSON.parse(p.json)
+  const dtParse = Number(process.hrtime.bigint() - t) / 1e6
+
+  // validate only (pre-parsed)
+  const obj = JSON.parse(p.json)
+  t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) v.validate(obj)
+  const dtValidate = Number(process.hrtime.bigint() - t) / 1e6
+
+  // parse + validate
+  t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) { const o = JSON.parse(p.json); v.validate(o) }
+  const dtTotal = Number(process.hrtime.bigint() - t) / 1e6
+
+  const parsePct = (dtParse / dtTotal * 100).toFixed(0)
+  const valPct = (dtValidate / dtTotal * 100).toFixed(0)
+
+  console.log(`${p.n} users (${(p.json.length/1024).toFixed(1)}KB):`)
+  console.log(`  JSON.parse: ${(dtParse/N*1000).toFixed(1)} us (${parsePct}%)`)
+  console.log(`  validate:   ${(dtValidate/N*1000).toFixed(1)} us (${valPct}%)`)
+  console.log(`  total:      ${(dtTotal/N*1000).toFixed(1)} us`)
+  console.log()
+}

package/test.js

@@ -189,10 +189,276 @@ async function run() {
   assert(errBody7.message.includes('email'), `nested: message mentions email: "${errBody7.message}"`)
   await app6.close()
 
+  // --- Fastify-realistic schema features ---
+
+  // 13. enum validation
+  const app7 = fastify()
+  await app7.register(fastifyAta)
+  app7.post('/enum', {
+    schema: { body: { type: 'object', properties: { role: { type: 'string', enum: ['admin', 'user', 'guest'] } }, required: ['role'] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app7.ready()
+  const re1 = await app7.inject({ method: 'POST', url: '/enum', payload: { role: 'admin' } })
+  const re2 = await app7.inject({ method: 'POST', url: '/enum', payload: { role: 'hacker' } })
+  assert(re1.statusCode === 200, 'enum: valid value accepted')
+  assert(re2.statusCode === 400, `enum: invalid value rejected (got ${re2.statusCode})`)
+  await app7.close()
+
+  // 14. additionalProperties: false
+  const app8 = fastify()
+  await app8.register(fastifyAta)
+  app8.post('/strict', {
+    schema: { body: { type: 'object', properties: { id: { type: 'integer' } }, additionalProperties: false } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app8.ready()
+  const rs1 = await app8.inject({ method: 'POST', url: '/strict', payload: { id: 1 } })
+  const rs2 = await app8.inject({ method: 'POST', url: '/strict', payload: { id: 1, extra: 'x' } })
+  assert(rs1.statusCode === 200, 'additionalProperties: valid accepted')
+  assert(rs2.statusCode === 400, `additionalProperties: extra rejected (got ${rs2.statusCode})`)
+  await app8.close()
+
+  // 15. array items validation
+  const app9 = fastify()
+  await app9.register(fastifyAta)
+  app9.post('/items', {
+    schema: { body: { type: 'object', properties: { tags: { type: 'array', items: { type: 'string' }, minItems: 1 } }, required: ['tags'] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app9.ready()
+  const ri1 = await app9.inject({ method: 'POST', url: '/items', payload: { tags: ['a', 'b'] } })
+  const ri2 = await app9.inject({ method: 'POST', url: '/items', payload: { tags: [] } })
+  const ri3 = await app9.inject({ method: 'POST', url: '/items', payload: { tags: ['a', 123] } })
+  assert(ri1.statusCode === 200, 'array items: valid accepted')
+  assert(ri2.statusCode === 400, `array items: empty rejected (got ${ri2.statusCode})`)
+  assert(ri3.statusCode === 400, `array items: wrong type rejected (got ${ri3.statusCode})`)
+  await app9.close()
+
+  // 16. allOf composition
+  const app10 = fastify()
+  await app10.register(fastifyAta)
+  app10.post('/allof', {
+    schema: { body: { allOf: [
+      { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] },
+      { type: 'object', properties: { b: { type: 'integer' } }, required: ['b'] },
+    ] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app10.ready()
+  const ra1 = await app10.inject({ method: 'POST', url: '/allof', payload: { a: 'x', b: 1 } })
+  const ra2 = await app10.inject({ method: 'POST', url: '/allof', payload: { a: 'x' } })
+  assert(ra1.statusCode === 200, 'allOf: both present accepted')
+  assert(ra2.statusCode === 400, `allOf: missing b rejected (got ${ra2.statusCode})`)
+  await app10.close()
+
+  // 17. anyOf composition
+  const app11 = fastify()
+  await app11.register(fastifyAta)
+  app11.post('/anyof', {
+    schema: { body: { anyOf: [{ type: 'string' }, { type: 'integer' }] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app11.ready()
+  const rao1 = await app11.inject({ method: 'POST', url: '/anyof', payload: '"hello"', headers: { 'content-type': 'application/json' } })
+  const rao2 = await app11.inject({ method: 'POST', url: '/anyof', payload: '42', headers: { 'content-type': 'application/json' } })
+  const rao3 = await app11.inject({ method: 'POST', url: '/anyof', payload: 'true', headers: { 'content-type': 'application/json' } })
+  assert(rao1.statusCode === 200, 'anyOf: string accepted')
+  assert(rao2.statusCode === 200, 'anyOf: integer accepted')
+  assert(rao3.statusCode === 400, `anyOf: boolean rejected (got ${rao3.statusCode})`)
+  await app11.close()
+
+  // 18. format validation (email)
+  const app12 = fastify()
+  await app12.register(fastifyAta)
+  app12.post('/format', {
+    schema: { body: { type: 'object', properties: { email: { type: 'string', format: 'email' } }, required: ['email'] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app12.ready()
+  const rf1 = await app12.inject({ method: 'POST', url: '/format', payload: { email: 'a@b.com' } })
+  const rf2 = await app12.inject({ method: 'POST', url: '/format', payload: { email: 'not-email' } })
+  assert(rf1.statusCode === 200, 'format: valid email accepted')
+  assert(rf2.statusCode === 400, `format: invalid email rejected (got ${rf2.statusCode})`)
+  await app12.close()
+
+  // 19. numeric constraints (minimum, maximum, exclusiveMinimum)
+  const app13 = fastify()
+  await app13.register(fastifyAta)
+  app13.post('/numeric', {
+    schema: { body: { type: 'object', properties: { age: { type: 'integer', minimum: 0, maximum: 150 }, score: { type: 'number', exclusiveMinimum: 0 } } } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app13.ready()
+  const rn1 = await app13.inject({ method: 'POST', url: '/numeric', payload: { age: 25, score: 0.1 } })
+  const rn2 = await app13.inject({ method: 'POST', url: '/numeric', payload: { age: -1 } })
+  const rn3 = await app13.inject({ method: 'POST', url: '/numeric', payload: { score: 0 } })
+  assert(rn1.statusCode === 200, 'numeric: valid accepted')
+  assert(rn2.statusCode === 400, `numeric: age < 0 rejected (got ${rn2.statusCode})`)
+  assert(rn3.statusCode === 400, `numeric: score = 0 rejected by exclusiveMinimum (got ${rn3.statusCode})`)
+  await app13.close()
+
+  // 20. $ref with $defs
+  const app14 = fastify()
+  await app14.register(fastifyAta)
+  app14.post('/ref', {
+    schema: { body: {
+      type: 'object',
+      properties: { address: { $ref: '#/$defs/Address' } },
+      $defs: { Address: { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] } },
+    } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app14.ready()
+  const rr1 = await app14.inject({ method: 'POST', url: '/ref', payload: { address: { city: 'Istanbul' } } })
+  const rr2 = await app14.inject({ method: 'POST', url: '/ref', payload: { address: {} } })
+  assert(rr1.statusCode === 200, '$ref: valid address accepted')
+  assert(rr2.statusCode === 400, `$ref: missing city rejected (got ${rr2.statusCode})`)
+  await app14.close()
+
+  // 21. querystring validation
+  const app15 = fastify()
+  await app15.register(fastifyAta)
+  app15.get('/search', {
+    schema: { querystring: { type: 'object', properties: { q: { type: 'string', minLength: 1 }, page: { type: 'string' } }, required: ['q'] } },
+  }, (req, reply) => reply.send({ q: req.query.q }))
+  await app15.ready()
+  const rq1 = await app15.inject({ method: 'GET', url: '/search?q=hello&page=1' })
+  const rq2 = await app15.inject({ method: 'GET', url: '/search' })
+  assert(rq1.statusCode === 200, 'querystring: valid accepted')
+  assert(rq2.statusCode === 400, `querystring: missing q rejected (got ${rq2.statusCode})`)
+  await app15.close()
+
+  // 22. params validation
+  const app16 = fastify()
+  await app16.register(fastifyAta)
+  app16.get('/users/:id', {
+    schema: { params: { type: 'object', properties: { id: { type: 'string', minLength: 1 } }, required: ['id'] } },
+  }, (req, reply) => reply.send({ id: req.params.id }))
+  await app16.ready()
+  const rp1 = await app16.inject({ method: 'GET', url: '/users/42' })
+  assert(rp1.statusCode === 200, 'params: valid id accepted')
+  await app16.close()
+
+  // 23. headers validation
+  const app17 = fastify()
+  await app17.register(fastifyAta)
+  app17.get('/auth', {
+    schema: { headers: { type: 'object', properties: { 'x-api-key': { type: 'string', minLength: 10 } }, required: ['x-api-key'] } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app17.ready()
+  const rh1 = await app17.inject({ method: 'GET', url: '/auth', headers: { 'x-api-key': 'abcdefghij' } })
+  const rh2 = await app17.inject({ method: 'GET', url: '/auth', headers: {} })
+  assert(rh1.statusCode === 200, 'headers: valid api key accepted')
+  assert(rh2.statusCode === 400, `headers: missing api key rejected (got ${rh2.statusCode})`)
+  await app17.close()
+
   await app.close()
   await app2.close()
   await app3.close()
 
+  /* Turbo mode tests removed - turbo mode deprecated */
+  /*
+
+  // 13. Turbo mode: plugin registers
+  const tApp = fastify()
+  await tApp.register(fastifyAta, { turbo: true })
+  tApp.post('/user', {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', minLength: 1 },
+          age: { type: 'integer', minimum: 0 },
+        },
+        required: ['name'],
+      },
+    },
+  }, (req, reply) => {
+    reply.send({ ok: true, name: req.body.name })
+  })
+  await tApp.ready()
+  assert(true, 'turbo: plugin registers')
+
+  // 14. Turbo: valid request
+  const t1 = await tApp.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { name: 'Mert', age: 26 },
+  })
+  assert(t1.statusCode === 200, `turbo: valid request returns 200 (got ${t1.statusCode})`)
+  assert(JSON.parse(t1.payload).name === 'Mert', 'turbo: valid request body correct')
+
+  // 15. Turbo: invalid request (missing required)
+  const t2 = await tApp.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { age: 26 },
+  })
+  assert(t2.statusCode === 400, `turbo: missing required returns 400 (got ${t2.statusCode})`)
+
+  // 16. Turbo: invalid request (wrong type)
+  const t3 = await tApp.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { name: 123 },
+  })
+  assert(t3.statusCode === 400, `turbo: wrong type returns 400 (got ${t3.statusCode})`)
+
+  // 17. Turbo: error message format
+  const tErr = JSON.parse(t2.payload)
+  assert(tErr.message && tErr.message.length > 0, `turbo: error message present: "${tErr.message}"`)
+
+  // 18. Turbo: malformed JSON body
+  const t4 = await tApp.inject({
+    method: 'POST',
+    url: '/user',
+    headers: { 'content-type': 'application/json' },
+    body: '{not valid json',
+  })
+  assert(t4.statusCode === 400, `turbo: malformed JSON returns 400 (got ${t4.statusCode})`)
+
+  // 19. Turbo: nested object validation
+  const tApp2 = fastify()
+  await tApp2.register(fastifyAta, { turbo: true })
+  tApp2.post('/nested', {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          user: {
+            type: 'object',
+            properties: { email: { type: 'string', format: 'email' } },
+            required: ['email'],
+          },
+        },
+      },
+    },
+  }, (req, reply) => reply.send({ ok: true }))
+  await tApp2.ready()
+  const t5 = await tApp2.inject({
+    method: 'POST',
+    url: '/nested',
+    payload: { user: {} },
+  })
+  assert(t5.statusCode === 400, `turbo: nested validation returns 400 (got ${t5.statusCode})`)
+  const tErr2 = JSON.parse(t5.payload)
+  assert(tErr2.message.includes('email'), `turbo: nested error mentions email: "${tErr2.message}"`)
+  await tApp2.close()
+
+  // 20. Turbo: multiple routes
+  const tApp3 = fastify()
+  await tApp3.register(fastifyAta, { turbo: true })
+  tApp3.post('/a', {
+    schema: { body: { type: 'object', properties: { x: { type: 'integer' } }, required: ['x'] } },
+  }, (req, reply) => reply.send({ route: 'a', x: req.body.x }))
+  tApp3.post('/b', {
+    schema: { body: { type: 'object', properties: { y: { type: 'string' } }, required: ['y'] } },
+  }, (req, reply) => reply.send({ route: 'b', y: req.body.y }))
+  await tApp3.ready()
+  const ta = await tApp3.inject({ method: 'POST', url: '/a', payload: { x: 42 } })
+  const tb = await tApp3.inject({ method: 'POST', url: '/b', payload: { y: 'hello' } })
+  assert(ta.statusCode === 200, 'turbo: multi-route /a valid')
+  assert(tb.statusCode === 200, 'turbo: multi-route /b valid')
+  assert(JSON.parse(ta.payload).x === 42, 'turbo: multi-route /a body correct')
+  assert(JSON.parse(tb.payload).y === 'hello', 'turbo: multi-route /b body correct')
+  await tApp3.close()
+
+  await tApp.close()
+  */
+
   console.log(`\n${pass}/${pass + fail} tests passed\n`)
   process.exit(fail > 0 ? 1 : 0)
 }