fastify-ata 0.5.0 → 0.6.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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "fastify-ata",
-  "version": "0.5.0",
+  "version": "0.6.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": "^0.20.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/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) })