fastify-ata 0.8.0 → 0.9.1

package/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node: [20, 22, 24]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test

package/.github/workflows/release.yml

@@ -0,0 +1,45 @@
+name: Release
+
+# Publishing a GitHub release publishes the same version to npm via trusted
+# publishing (OIDC). No tokens: the trusted publisher for this repo and
+# workflow must be configured on npmjs.com for the package.
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm install
+      - run: npm test
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm install -g npm@latest
+      - name: Refuse a version that does not match the tag
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG="$(node -p "require('./package.json').version")"
+          if [ "$TAG" != "$PKG" ]; then
+            echo "tag $TAG does not match package.json $PKG" >&2
+            exit 1
+          fi
+      - run: npm install
+      - run: npm publish

package/compat/COMPATIBILITY.md

@@ -12,7 +12,7 @@ The preload swaps the single `require('@fastify/ajv-compiler')` inside Fastify's
 
 ## Current score
 
-**181 of 187 tests pass** (Fastify v5.8.4 checkout, ata-validator 1.2.0, fastify-ata main).
+**182 of 188 tests pass** (Fastify v5.8.5 checkout, ata-validator 1.3.0, fastify-ata main).
 
 Everything Fastify's suite asserts about validation behavior passes: type checks and coercion (including the `array` coercion mode), defaults, `removeAdditional`, required and enum handling, cross-schema `$ref` through `addSchema`, draft-07 `$id` anchors, `nullable`, `oneOf`/`anyOf` branching, custom error messages via `errorMessage`, `$merge`/`$patch` keywords, fail-fast startup errors for unresolvable references, encapsulation scoping, error shape (exact default error object layout, mutable for plugins like ajv-i18n), the error paths in `validation-error-handling`, and shared-schema `$ref` into `/definitions` across the validator AND the serializer (ata never mutates caller-provided schema objects, so fast-json-stringify sees them untouched).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Fastify plugin for ata-validator. Runtime-competitive with the default, 24x faster serverless cold start, Standard Schema V1.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^1.2.0",
+    "ata-validator": "^1.7.1",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/bench-realtime.js

@@ -1,131 +0,0 @@
-'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-turbo.js

@@ -1,118 +0,0 @@
-'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/profile-fastify.mjs

@@ -1,87 +0,0 @@
-'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()
-}