fastify-ata 0.2.8 → 0.2.10

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.8",
+  "version": "0.2.10",
   "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"

package/standalone.js

@@ -0,0 +1,94 @@
+'use strict'
+
+const { Validator } = require('ata-validator')
+
+// Fastify schemaController compatible standalone compiler.
+// Same API as @fastify/ajv-compiler/standalone — drop-in replacement.
+//
+// WRITE mode (build phase):
+//   const { StandaloneValidator } = require('fastify-ata/standalone')
+//   buildValidator: StandaloneValidator({
+//     readMode: false,
+//     storeFunction(routeOpts, code) { fs.writeFileSync(fileName, code) }
+//   })
+//
+// READ mode (startup):
+//   buildValidator: StandaloneValidator({
+//     readMode: true,
+//     restoreFunction(routeOpts) { return require(fileName) }
+//   })
+
+function StandaloneValidator(options = { readMode: true }) {
+  if (options.readMode === true && !options.restoreFunction) {
+    throw new Error('You must provide a restoreFunction when readMode is true')
+  }
+  if (options.readMode !== true && !options.storeFunction) {
+    throw new Error('You must provide a storeFunction when readMode is false')
+  }
+
+  if (options.readMode === true) {
+    // READ MODE: load pre-compiled validator from file
+    return function wrapper() {
+      return function buildValidatorFunction(opts) {
+        const mod = options.restoreFunction(opts)
+        // mod is either a function (standalone) or { boolFn, hybridFactory, errFn }
+        if (typeof mod === 'function') {
+          // Direct function — just wrap for Fastify
+          return wrapValidator(mod)
+        }
+        // Module from toStandalone() — restore via fromStandalone
+        if (mod.boolFn || mod.hybridFactory) {
+          const v = Validator.fromStandalone(mod, opts.schema)
+          return wrapValidator((data) => v.validate(data))
+        }
+        // Fallback: compile fresh
+        const v = new Validator(opts.schema)
+        return wrapValidator((data) => v.validate(data))
+      }
+    }
+  }
+
+  // WRITE MODE: compile schema, generate standalone code, store to file
+  return function wrapper() {
+    return function buildValidatorFunction(opts) {
+      const v = new Validator(opts.schema)
+      const standalone = v.toStandalone()
+
+      if (standalone) {
+        options.storeFunction(opts, standalone)
+      }
+
+      return wrapValidator((data) => v.validate(data))
+    }
+  }
+}
+
+function wrapValidator(validateFn) {
+  // Fastify expects: return true on valid, return false on invalid.
+  // On invalid, validate.errors must contain ajv-compatible error objects.
+  function validate(data) {
+    const result = validateFn(data)
+    if (result && result.valid !== undefined) {
+      if (result.valid) {
+        validate.errors = null
+        return true
+      }
+      validate.errors = result.errors.map(e => ({
+        message: e.message,
+        instancePath: e.path || '',
+        schemaPath: '',
+        keyword: e.code || 'validation',
+        params: {},
+      }))
+      return false
+    }
+    // Boolean result
+    if (result) { validate.errors = null; return true }
+    validate.errors = [{ message: 'validation failed', instancePath: '', schemaPath: '', keyword: 'validation', params: {} }]
+    return false
+  }
+  validate.errors = null
+  return validate
+}
+
+module.exports = StandaloneValidator