fastify-ata 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert Can Altin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# fastify-ata
+
+Fastify plugin for [ata-validator](https://ata-validator.com) — JSON Schema validation powered by simdjson.
+
+Replaces the default ajv validator compiler with ata-validator for **120x faster schema compilation**.
+
+## Install
+
+```bash
+npm install fastify-ata
+```
+
+## Usage
+
+```js
+const fastify = require('fastify')()
+const fastifyAta = require('fastify-ata')
+
+fastify.register(fastifyAta)
+
+fastify.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 })
+})
+
+fastify.listen({ port: 3000 })
+```
+
+That's it. All your existing JSON Schema route definitions work as-is.
+
+## What it does
+
+- Registers a custom `validatorCompiler` using ata-validator
+- Caches compiled schemas for reuse across routes
+- Returns Fastify-compatible validation errors on invalid requests (400)
+- Works with Fastify v4 and v5
+
+## Why
+
+| | ata-validator | ajv |
+|---|---|---|
+| Schema compilation | **120x faster** | baseline |
+| Engine | simdjson + RE2 + codegen | JS |
+| Spec compliance | 98.6% Draft 2020-12 | ~100% |
+| Standard Schema V1 | Yes | No |
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,5 @@
+import { FastifyPluginCallback } from 'fastify'
+
+declare const fastifyAta: FastifyPluginCallback<{}>
+
+export = fastifyAta

package/index.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const fp = require('fastify-plugin')
+const { Validator } = require('ata-validator')
+
+function fastifyAta(fastify, opts, done) {
+  const cache = new WeakMap()
+
+  fastify.setValidatorCompiler(({ schema }) => {
+    let validator = cache.get(schema)
+    if (!validator) {
+      validator = new Validator(schema)
+      cache.set(schema, validator)
+    }
+    return (data) => {
+      const result = validator.validate(data)
+      if (result.valid) {
+        return { value: data }
+      }
+      const err = new Error(result.errors.map(e => e.message).join(', '))
+      err.statusCode = 400
+      err.validation = result.errors.map(e => ({
+        message: e.message,
+        instancePath: e.path || '',
+        schemaPath: '',
+        keyword: '',
+        params: {},
+      }))
+      return { error: err }
+    }
+  })
+
+  done()
+}
+
+module.exports = fp(fastifyAta, {
+  fastify: '>=4.0.0',
+  name: 'fastify-ata',
+})

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "fastify-ata",
+  "version": "0.1.0",
+  "description": "Fastify plugin for ata-validator — JSON Schema validation powered by simdjson",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mertcanaltin/fastify-ata.git"
+  },
+  "keywords": [
+    "fastify",
+    "json-schema",
+    "validator",
+    "simdjson",
+    "ata-validator",
+    "standard-schema"
+  ],
+  "author": "Mert Can Altin <mertcanaltin01@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mertcanaltin/fastify-ata/issues"
+  },
+  "homepage": "https://github.com/mertcanaltin/fastify-ata#readme",
+  "dependencies": {
+    "ata-validator": "^0.2.0",
+    "fastify-plugin": "^5.1.0"
+  },
+  "peerDependencies": {
+    "fastify": ">=4.0.0"
+  },
+  "devDependencies": {
+    "fastify": "^5.8.4"
+  }
+}

package/test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const fastify = require('fastify')
+const fastifyAta = require('./index')
+
+let pass = 0
+let fail = 0
+
+function assert(cond, msg) {
+  if (cond) { pass++; console.log(`  PASS  ${msg}`) }
+  else { fail++; console.log(`  FAIL  ${msg}`) }
+}
+
+async function run() {
+  console.log('\nfastify-ata Tests\n')
+
+  // 1. Plugin registers without error
+  const app = fastify()
+  await app.register(fastifyAta)
+  assert(true, 'plugin registers')
+
+  // 2. Route with schema — valid request
+  app.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 app.ready()
+  assert(true, 'app.ready() with schema route')
+
+  // 3. Valid request
+  const r1 = await app.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { name: 'Mert', age: 26 },
+  })
+  assert(r1.statusCode === 200, `valid request returns 200 (got ${r1.statusCode})`)
+  assert(JSON.parse(r1.payload).ok === true, 'valid request body correct')
+
+  // 4. Invalid request — missing required
+  const r2 = await app.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { age: 26 },
+  })
+  assert(r2.statusCode === 400, `missing required returns 400 (got ${r2.statusCode})`)
+
+  // 5. Invalid request — wrong type
+  const r3 = await app.inject({
+    method: 'POST',
+    url: '/user',
+    payload: { name: 123 },
+  })
+  assert(r3.statusCode === 400, `wrong type returns 400 (got ${r3.statusCode})`)
+
+  // 6. Multiple routes with different schemas
+  const app2 = fastify()
+  await app2.register(fastifyAta)
+
+  app2.post('/a', {
+    schema: { body: { type: 'object', properties: { x: { type: 'integer' } }, required: ['x'] } },
+  }, (req, reply) => reply.send({ route: 'a' }))
+
+  app2.post('/b', {
+    schema: { body: { type: 'object', properties: { y: { type: 'string' } }, required: ['y'] } },
+  }, (req, reply) => reply.send({ route: 'b' }))
+
+  await app2.ready()
+
+  const ra = await app2.inject({ method: 'POST', url: '/a', payload: { x: 1 } })
+  const rb = await app2.inject({ method: 'POST', url: '/b', payload: { y: 'hello' } })
+  assert(ra.statusCode === 200, 'multi-route: /a valid')
+  assert(rb.statusCode === 200, 'multi-route: /b valid')
+
+  // 7. Schema caching — same schema reuses validator
+  const app3 = fastify()
+  await app3.register(fastifyAta)
+
+  const sharedSchema = { type: 'object', properties: { id: { type: 'integer' } }, required: ['id'] }
+  app3.post('/c', { schema: { body: sharedSchema } }, (req, reply) => reply.send({ ok: true }))
+  app3.post('/d', { schema: { body: sharedSchema } }, (req, reply) => reply.send({ ok: true }))
+
+  await app3.ready()
+  const rc = await app3.inject({ method: 'POST', url: '/c', payload: { id: 1 } })
+  const rd = await app3.inject({ method: 'POST', url: '/d', payload: { id: 2 } })
+  assert(rc.statusCode === 200 && rd.statusCode === 200, 'schema caching works')
+
+  // 8. Error message is descriptive
+  const errBody = JSON.parse(r2.payload)
+  assert(errBody.message && errBody.message.length > 0, `error message present: "${errBody.message}"`)
+
+  await app.close()
+  await app2.close()
+  await app3.close()
+
+  console.log(`\n${pass}/${pass + fail} tests passed\n`)
+  process.exit(fail > 0 ? 1 : 0)
+}
+
+run().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})