fastify-ata 0.2.7 → 0.2.9

package/README.md

@@ -91,15 +91,16 @@ Works with Fastify v5's Standard Schema support, tRPC, TanStack Form, Drizzle OR
 | **Serverless cold start** (50 schemas) | 7.7ms | 96ms | **12.5x faster** |
 | **ReDoS protection** (catastrophic pattern) | 0.3ms | 765ms | **immune** |
 | **Batch NDJSON** (10K items, multi-core) | 13.4M/sec | 5.1M/sec | **2.6x faster** |
-| **validate(obj)** valid (micro) | 15M ops/sec | 8.5M ops/sec | **1.8x faster** |
-| **Schema compilation** | 125K ops/sec | 831 ops/sec | **151x faster** |
+| **validate(obj)** valid (isolated) | 76M ops/sec | 8M ops/sec | **9.5x faster** |
+| **validate(obj)** invalid (isolated) | 34M ops/sec | 8M ops/sec | **4.3x faster** |
+| **Schema compilation** | 113K ops/sec | 818 ops/sec | **138x faster** |
 
 ### Things only ata can do
 
 - **RE2 regex engine** — linear-time guaranteed, immune to ReDoS attacks
 - **Multi-core parallel validation** — NDJSON batch at 12.5M items/sec
 - **Standard Schema V1** — native support, ajv doesn't have it
-- **151x faster compilation** — serverless cold starts, dynamic schemas
+- **138x faster compilation** — serverless cold starts, dynamic schemas
 
 ## License
 

package/bench-standalone-vs.js

@@ -0,0 +1,219 @@
+'use strict'
+
+// Matteo's benchmark: @fastify/ajv-compiler standalone vs ata standalone
+// Exactly the approach from https://backend.cafe/how-to-unlock-the-fastest-fastify-server-startup
+
+const { fork } = require('child_process')
+const { writeFileSync, mkdirSync, rmSync, existsSync, unlinkSync } = require('fs')
+const path = require('path')
+
+function makeRoutes(n) {
+  // Realistic: 5 schema types reused across routes (like a real API)
+  const bases = [
+    { type: 'object', properties: { id: { type: 'integer', minimum: 1 }, name: { type: 'string', minLength: 1 }, email: { type: 'string', format: 'email' }, active: { type: 'boolean' } }, required: ['id', 'name', 'email', 'active'] },
+    { type: 'object', properties: { id: { type: 'integer', minimum: 1 }, title: { type: 'string', minLength: 1 }, price: { type: 'number', minimum: 0 }, inStock: { type: 'boolean' } }, required: ['id', 'title', 'price'] },
+    { type: 'object', properties: { orderId: { type: 'string' }, userId: { type: 'integer' }, total: { type: 'number', minimum: 0 }, status: { type: 'string' } }, required: ['orderId', 'userId', 'total'] },
+    { type: 'object', properties: { query: { type: 'string', minLength: 1 }, page: { type: 'integer', minimum: 1 }, limit: { type: 'integer', minimum: 1, maximum: 100 } }, required: ['query'] },
+    { type: 'object', properties: { token: { type: 'string', minLength: 10 }, action: { type: 'string' }, timestamp: { type: 'integer' } }, required: ['token', 'action'] },
+  ]
+  return Array.from({ length: n }, (_, i) => ({
+    url: '/route' + i,
+    schema: bases[i % bases.length],
+  }))
+}
+
+// ============================================================
+// 1. ajv default (no standalone)
+// ============================================================
+function ajvDefaultScript(routes) {
+  return `
+'use strict'
+const start = performance.now()
+const fastify = require('fastify')()
+const routes = ${JSON.stringify(routes)}
+routes.forEach(r => {
+  fastify.post(r.url, { schema: { body: r.schema } }, (req, reply) => reply.send({ ok: true }))
+})
+fastify.ready().then(() => {
+  process.send({ ms: performance.now() - start })
+  process.exit()
+})
+`
+}
+
+// ============================================================
+// 2. ajv standalone (blog post approach)
+// ============================================================
+function ajvStandaloneBuildScript(routes, dir) {
+  return `
+'use strict'
+const fastify = require('fastify')
+const fs = require('fs')
+const path = require('path')
+const { StandaloneValidator } = require('@fastify/ajv-compiler')
+const sanitize = require('sanitize-filename')
+
+function generateFileName(routeOpts) {
+  return path.join('${dir}', 'gen-' + routeOpts.method + '-' + (routeOpts.httpPart || routeOpts.httpStatus) + '-' + sanitize(routeOpts.url) + '.js')
+}
+
+const app = fastify({
+  jsonShorthand: false,
+  schemaController: {
+    compilersFactory: {
+      buildValidator: StandaloneValidator({
+        readMode: false,
+        storeFunction(routeOpts, code) { fs.writeFileSync(generateFileName(routeOpts), code) }
+      })
+    }
+  }
+})
+
+const routes = ${JSON.stringify(routes)}
+routes.forEach(r => {
+  app.post(r.url, { schema: { body: r.schema } }, (req, reply) => reply.send({ ok: true }))
+})
+app.ready().then(() => { process.send({ done: true }); process.exit() })
+`
+}
+
+function ajvStandaloneReadScript(routes, dir) {
+  return `
+'use strict'
+const start = performance.now()
+const fastify = require('fastify')
+const path = require('path')
+const { StandaloneValidator } = require('@fastify/ajv-compiler')
+const sanitize = require('sanitize-filename')
+
+function generateFileName(routeOpts) {
+  return path.join('${dir}', 'gen-' + routeOpts.method + '-' + (routeOpts.httpPart || routeOpts.httpStatus) + '-' + sanitize(routeOpts.url) + '.js')
+}
+
+const app = fastify({
+  jsonShorthand: false,
+  schemaController: {
+    compilersFactory: {
+      buildValidator: StandaloneValidator({
+        readMode: true,
+        restoreFunction(routeOpts) { return require(generateFileName(routeOpts)) }
+      })
+    }
+  }
+})
+
+const routes = ${JSON.stringify(routes)}
+routes.forEach(r => {
+  app.post(r.url, { schema: { body: r.schema } }, (req, reply) => reply.send({ ok: true }))
+})
+app.ready().then(() => {
+  process.send({ ms: performance.now() - start })
+  process.exit()
+})
+`
+}
+
+// ============================================================
+// 3. ata compact standalone
+// ============================================================
+function ataStandaloneScript(routes, bundlePath) {
+  return `
+'use strict'
+const start = performance.now()
+const fastify = require('fastify')()
+const fns = require('${bundlePath}')
+const routes = ${JSON.stringify(routes)}
+const map = new WeakMap()
+routes.forEach((r, i) => map.set(r.schema, fns[i]))
+fastify.setValidatorCompiler(({ schema }) => {
+  const fn = map.get(schema)
+  return (data) => {
+    const r = fn(data)
+    if (r.valid) return { value: data }
+    const e = new Error(r.errors.map(e => e.message).join(', '))
+    e.statusCode = 400
+    e.validation = r.errors
+    return { error: e }
+  }
+})
+routes.forEach(r => {
+  fastify.post(r.url, { schema: { body: r.schema } }, (req, reply) => reply.send({ ok: true }))
+})
+fastify.ready().then(() => {
+  process.send({ ms: performance.now() - start })
+  process.exit()
+})
+`
+}
+
+async function runScript(script, timeout = 15000) {
+  const f = path.join(__dirname, '_bench_tmp.js')
+  writeFileSync(f, script)
+  const ms = await new Promise((resolve) => {
+    const c = fork(f, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
+    c.on('message', m => resolve(m.ms || m.done ? m.ms : -1))
+    setTimeout(() => { c.kill(); resolve(-1) }, timeout)
+  })
+  try { unlinkSync(f) } catch {}
+  return ms
+}
+
+async function main() {
+  // Install sanitize-filename if needed
+  try { require('sanitize-filename') } catch {
+    require('child_process').execSync('npm install sanitize-filename', { cwd: __dirname, stdio: 'pipe' })
+  }
+
+  console.log('\n=======================================================')
+  console.log('  Fastify Startup: ajv default vs ajv standalone vs ata')
+  console.log('  Measures: process start → app.ready()')
+  console.log('  Blog post: backend.cafe/how-to-unlock-the-fastest-fastify-server-startup')
+  console.log('=======================================================\n')
+
+  for (const n of [50, 100, 200, 500]) {
+    const routes = makeRoutes(n)
+    console.log(`--- ${n} routes (5 schema types) ---`)
+
+    // 1. ajv default
+    const times1 = []
+    for (let r = 0; r < 3; r++) times1.push(await runScript(ajvDefaultScript(routes)))
+    times1.sort((a, b) => a - b)
+    const ajvDefault = times1[1]
+
+    // 2. ajv standalone — build phase
+    const ajvDir = path.resolve(__dirname, '_ajv_standalone')
+    mkdirSync(ajvDir, { recursive: true })
+    await runScript(ajvStandaloneBuildScript(routes, ajvDir), 30000)
+
+    // 2b. ajv standalone — read phase (benchmark this)
+    const times2 = []
+    for (let r = 0; r < 3; r++) times2.push(await runScript(ajvStandaloneReadScript(routes, ajvDir)))
+    times2.sort((a, b) => a - b)
+    const ajvStandalone = times2[1]
+    try { rmSync(ajvDir, { recursive: true }) } catch {}
+
+    // 3. ata compact standalone — build phase
+    const { Validator } = require('ata-validator')
+    const schemas = routes.map(r => r.schema)
+    const bundlePath = path.resolve(__dirname, '_ata_bundle.js')
+    writeFileSync(bundlePath, Validator.bundleCompact(schemas))
+
+    // 3b. ata standalone — read phase (benchmark this)
+    const times3 = []
+    for (let r = 0; r < 3; r++) times3.push(await runScript(ataStandaloneScript(routes, bundlePath)))
+    times3.sort((a, b) => a - b)
+    const ataStandalone = times3[1]
+    try { unlinkSync(bundlePath) } catch {}
+
+    console.log(`  ajv default:    ${ajvDefault.toFixed(0)}ms`)
+    console.log(`  ajv standalone: ${ajvStandalone >= 0 ? ajvStandalone.toFixed(0) + 'ms' : 'FAILED'}`)
+    console.log(`  ata compact:    ${ataStandalone.toFixed(0)}ms`)
+    if (ajvStandalone > 0) {
+      console.log(`  ata vs ajv standalone: ${(ajvStandalone / ataStandalone).toFixed(1)}x faster`)
+    }
+    console.log(`  ata vs ajv default:    ${(ajvDefault / ataStandalone).toFixed(1)}x faster`)
+    console.log()
+  }
+}
+
+main().catch(console.error)

package/bench-startup.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const { execSync } = require('child_process')
+const { writeFileSync, unlinkSync, mkdirSync, rmSync } = 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' },
+      },
+      required: ['id', 'name', 'email', 'active'],
+    })
+  }
+  return schemas
+}
+
+function serverScript(mode, n) {
+  const schemas = makeSchemas(n)
+
+  if (mode === 'ajv-normal') {
+    return `
+'use strict'
+const start = performance.now()
+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 }))
+})
+fastify.ready().then(() => {
+  const ms = performance.now() - start
+  process.send({ ms })
+  process.exit()
+})
+`
+  }
+}
+
+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
+  const times = []
+  for (let r = 0; r < runs; r++) {
+    const { fork } = require('child_process')
+    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('error', reject)
+      setTimeout(() => { child.kill(); reject(new Error('timeout')); }, 10000)
+    })
+    times.push(ms)
+  }
+
+  try { unlinkSync(path.join(__dirname, '_startup_server.js')) } 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
+}
+
+async function main() {
+  console.log('\n==============================================')
+  console.log('  Fastify Startup Benchmark')
+  console.log('  Time from process start to app.ready()')
+  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)`)
+    console.log()
+  }
+
+  // Cleanup
+  try { rmSync(path.join(__dirname, 'standalone'), { recursive: true }) } catch {}
+}
+
+main().catch(console.error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "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,9 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^0.4.7",
-    "fastify-plugin": "^5.1.0"
+    "ata-validator": "^0.4.9",
+    "fastify-plugin": "^5.1.0",
+    "sanitize-filename": "^1.6.4"
   },
   "peerDependencies": {
     "fastify": ">=4.0.0"