fastify-ata 0.5.0 → 0.7.0

package/README.md

@@ -75,6 +75,33 @@ app.post('/user', {
 
 `ata-validator` falls back to a pure-JS engine where the native addon is not available (Cloudflare Workers, browsers, Bun), so fastify-ata runs in those environments too.
 
+### Chainable authoring (TypeBox-style)
+
+If you prefer a chainable builder over JSON Schema literals, `ata-validator/t` emits the same plain JSON Schema under the hood, so route schemas, the type provider, and the AOT path all keep working without an adapter. The migration from TypeBox is one import rename:
+
+```ts
+import Fastify from 'fastify'
+import fastifyAta from 'fastify-ata'
+import { t } from 'ata-validator/t'
+
+const app = Fastify().withTypeProvider<fastifyAta.AtaTypeProvider>()
+await app.register(fastifyAta)
+
+const Body = t.object({
+  name: t.string({ minLength: 1 }),
+  age: t.integer({ minimum: 0 }),
+  email: t.optional(t.string({ format: 'email' })),
+  role: t.union([t.literal('admin'), t.literal('user')]),
+})
+
+app.post('/users', { schema: { body: Body } }, (req, reply) => {
+  req.body.name    // string
+  req.body.email   // string | undefined
+  req.body.role    // 'admin' | 'user'
+  reply.send({ ok: true })
+})
+```
+
 ## Options
 
 ```js
@@ -96,6 +123,48 @@ Off by default to keep the ajv-compatible message shape.
 
 `abortEarly` replaces the error list with a shared stub. Good for public endpoints where only the accept/reject decision reaches the caller. On a 10-property schema the invalid path drops from roughly 15 ns/op to 3.7 ns/op.
 
+## Two ways to plug in
+
+### Plugin (encapsulated)
+
+`fastify.register(fastifyAta)` sets the validator compiler in the context it is registered into. Register it on the root instance and it applies everywhere; register it inside a plugin and only that subtree uses ata, while the rest of the app keeps the default validator. Use this when you want ata for some routes and the default for others, or when you are adding ata to an existing app without touching the server construction.
+
+### Global default (full replacement)
+
+If you want ata to be the validator for the whole server, pass the compiler factory at construction time instead. This is the same `schemaController.compilersFactory.buildValidator` hook that `@fastify/ajv-compiler` and [`joi-compiler`](https://github.com/Eomm/joi-compiler) use, so the default ajv validator is never built.
+
+```js
+const Fastify = require('fastify')
+const AtaCompiler = require('fastify-ata/compiler')
+
+const app = Fastify({
+  schemaController: { compilersFactory: { buildValidator: AtaCompiler() } },
+})
+
+app.post('/user', {
+  schema: {
+    body: {
+      type: 'object',
+      properties: { name: { type: 'string' }, age: { type: 'integer' } },
+      required: ['name'],
+    },
+  },
+}, (req, reply) => reply.send({ ok: true }))
+```
+
+The factory mirrors `@fastify/ajv-compiler`: it defaults to Fastify's own ajv behavior (`coerceTypes: 'array'`, `removeAdditional: true`, first error only) and reads `addSchema` registrations for cross-schema `$ref`. Override through `customOptions`:
+
+```js
+buildValidator: AtaCompiler() // defaults match Fastify's ajv
+// per-instance overrides are read from ajv.customOptions, e.g.:
+const app = Fastify({
+  ajv: { customOptions: { coerceTypes: false, allErrors: true } },
+  schemaController: { compilersFactory: { buildValidator: AtaCompiler() } },
+})
+```
+
+Note on memory: this replaces the ajv *validator*, so it is never instantiated. The `ajv` module itself can still be pulled into the process by Fastify's serializer (`fast-json-stringify` uses it to check serialization schemas), independent of which validator you choose. Replacing the validator removes ajv from the request validation path, not necessarily from the module graph.
+
 ## Standalone Mode (Pre-compiled)
 
 Drop-in replacement for `@fastify/ajv-compiler/standalone`. Same API.

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "fastify-ata",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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",
   "scripts": {
-    "test": "node test.js && node test-pretty-errors.js && node test-standalone.js && node test-compiler.js && node test-type-provider.js && tsc -p tsconfig.types.json"
+    "test": "node test.js && node test-pretty-errors.js && node test-standalone.js && node test-compiler.js && node test-type-provider.js && node test-t-builder.js && tsc -p tsconfig.types.json"
   },
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^0.18.0",
+    "ata-validator": "^1.0.0",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },
@@ -34,6 +34,8 @@
     "fastify": ">=4.0.0"
   },
   "devDependencies": {
+    "@fastify/type-provider-typebox": "^6.1.0",
+    "@sinclair/typebox": "^0.34.49",
     "@types/node": "^25.9.1",
     "autocannon": "^8.0.0",
     "fastify": "^5.8.4",

package/standalone.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { Validator } = require('ata-validator')
+const { toStandaloneModule } = require('ata-validator/build')
 
 // Fastify schemaController compatible standalone compiler.
 // Same API as @fastify/ajv-compiler/standalone — drop-in replacement.
@@ -31,12 +32,15 @@ function StandaloneValidator(options = { readMode: true }) {
     return function wrapper() {
       return function buildValidatorFunction(opts) {
         const mod = options.restoreFunction(opts)
-        // mod is either a function (standalone) or { boolFn, hybridFactory, errFn }
+        // mod is a function (standalone), a { validate, isValid } module
+        // (toStandaloneModule output), or a legacy { boolFn, hybridFactory,
+        // errFn } artifact from the pre-1.0 instance toStandalone().
         if (typeof mod === 'function') {
-          // Direct function — just wrap for Fastify
           return wrapValidator(mod)
         }
-        // Module from toStandalone() — restore via fromStandalone
+        if (typeof mod.validate === 'function') {
+          return wrapValidator(mod.validate)
+        }
         if (mod.boolFn || mod.hybridFactory) {
           const v = Validator.fromStandalone(mod, opts.schema)
           return wrapValidator((data) => v.validate(data))
@@ -52,7 +56,8 @@ function StandaloneValidator(options = { readMode: true }) {
   return function wrapper() {
     return function buildValidatorFunction(opts) {
       const v = new Validator(opts.schema)
-      const standalone = v.toStandalone()
+      // CJS so the stored file works with a plain require() in restoreFunction.
+      const standalone = toStandaloneModule(v, { format: 'cjs' })
 
       if (standalone) {
         options.storeFunction(opts, standalone)

package/test-t-builder.js

@@ -0,0 +1,82 @@
+'use strict'
+
+// Verify that route schemas authored with `ata-validator/t` flow through
+// fastify-ata exactly like plain JSON Schema literals do. The builder is a
+// pure emitter (no runtime adapter), so the validator compiler should not
+// notice the difference; this test pins that invariant so a future bump
+// of ata-validator cannot silently break the TypeBox-style migration path.
+
+const fastify = require('fastify')
+const fastifyAta = require('./index')
+const { t } = require('ata-validator/t')
+
+let pass = 0
+let fail = 0
+const assert = (cond, msg) => {
+  if (cond) { pass++; console.log(`  PASS  ${msg}`) }
+  else { fail++; console.log(`  FAIL  ${msg}`) }
+}
+
+async function run () {
+  console.log('\nfastify-ata + ata-validator/t\n')
+
+  const app = fastify()
+  await app.register(fastifyAta)
+
+  const Body = t.object({
+    name: t.string({ minLength: 1 }),
+    age: t.integer({ minimum: 0 }),
+    email: t.optional(t.string({ format: 'email' })),
+    role: t.union([t.literal('admin'), t.literal('user')]),
+  })
+
+  app.post('/users', { schema: { body: Body } }, (req, reply) => {
+    reply.send({ ok: true, name: req.body.name, role: req.body.role })
+  })
+
+  await app.ready()
+  assert(true, 'route with t-builder schema registers')
+
+  const ok = await app.inject({
+    method: 'POST',
+    url: '/users',
+    payload: { name: 'Mert', age: 30, role: 'admin' },
+  })
+  assert(ok.statusCode === 200, 'valid body returns 200')
+  assert(JSON.parse(ok.payload).name === 'Mert', 'request body reachable in handler')
+
+  const optionalOk = await app.inject({
+    method: 'POST',
+    url: '/users',
+    payload: { name: 'Mert', age: 30, email: 'm@example.com', role: 'user' },
+  })
+  assert(optionalOk.statusCode === 200, 'optional field accepted when present')
+
+  const missingRequired = await app.inject({
+    method: 'POST',
+    url: '/users',
+    payload: { age: 30, role: 'user' },
+  })
+  assert(missingRequired.statusCode === 400, 'missing required field rejected')
+
+  const wrongUnion = await app.inject({
+    method: 'POST',
+    url: '/users',
+    payload: { name: 'Mert', age: 30, role: 'superuser' },
+  })
+  assert(wrongUnion.statusCode === 400, 'value outside union rejected')
+
+  const negativeAge = await app.inject({
+    method: 'POST',
+    url: '/users',
+    payload: { name: 'Mert', age: -1, role: 'user' },
+  })
+  assert(negativeAge.statusCode === 400, 'numeric bound rejected')
+
+  await app.close()
+
+  console.log(`\n${pass} passed, ${fail} failed`)
+  process.exit(fail > 0 ? 1 : 0)
+}
+
+run().catch((e) => { console.error(e); process.exit(1) })