fastify-ata 0.4.0 → 0.4.2

package/README.md

@@ -44,6 +44,37 @@ fastify.listen({ port: 3000 })
 
 All your existing JSON Schema route definitions work as-is.
 
+## TypeScript
+
+Write plain JSON Schema and get typed route handlers, no builder DSL. Add the `AtaTypeProvider` and author schemas with `defineSchema`:
+
+```ts
+import Fastify from 'fastify'
+import fastifyAta from 'fastify-ata'
+import { defineSchema } from 'ata-validator'
+
+const app = Fastify().withTypeProvider<fastifyAta.AtaTypeProvider>()
+await app.register(fastifyAta)
+
+app.post('/user', {
+  schema: {
+    body: defineSchema({
+      type: 'object',
+      properties: { name: { type: 'string' }, age: { type: 'integer' } },
+      required: ['name'],
+    }),
+  },
+}, (req, reply) => {
+  req.body.name // string
+  req.body.age  // number | undefined
+  reply.send({ ok: true })
+})
+```
+
+`defineSchema` preserves the schema's literal types, so `request.body`, `request.query`, `request.params`, and `request.headers` are inferred from the schema. Same idea as `@fastify/type-provider-typebox`, from plain JSON Schema.
+
+`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.
+
 ## Options
 
 ```js
@@ -51,9 +82,18 @@ fastify.register(fastifyAta, {
   coerceTypes: true,       // convert "42" -> 42 for integer fields
   removeAdditional: true,  // strip properties not in schema
   abortEarly: true,        // skip detailed error collection (faster invalid path)
+  prettyErrors: true,      // 400 message carries the ATA code + a did-you-mean
 })
 ```
 
+With `prettyErrors`, a failed request returns a compiler-style message instead of the plain ajv text:
+
+```
+body must have required property 'name' [ATA7001] (did you mean `name` instead of `nme`?)
+```
+
+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.
 
 ## Standalone Mode (Pre-compiled)

package/index.js

@@ -31,7 +31,10 @@ function fastifyAta(fastify, opts, done) {
   fastify.setValidatorCompiler(({ schema }) => {
     let validator = cache.get(schema)
     if (!validator) {
-      validator = new Validator(schema, validatorOpts)
+      // Pass schemas registered via `fastify.addSchema` so cross-schema `$ref`
+      // (e.g. `{ $ref: 'shared#' }`) resolves. Compilers run at ready() time,
+      // after every addSchema, so getSchemas() returns the full bucket.
+      validator = new Validator(schema, { ...validatorOpts, schemas: fastify.getSchemas() })
       cache.set(schema, validator)
     }
     const validate = (data) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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": "^0.17.0",
+    "ata-validator": "^0.17.5",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/test.js

@@ -459,6 +459,31 @@ async function run() {
   await tApp.close()
   */
 
+  // Cross-schema $ref via addSchema: the plugin must pass external schemas to ata,
+  // and ata must resolve both external $id refs and draft-07 #anchor refs.
+  const refApp = fastify()
+  await refApp.register(fastifyAta)
+  refApp.addSchema({ $id: 'http://foo/test', type: 'object', properties: { id: { type: 'number' } } })
+  refApp.post('/ref', {
+    schema: {
+      body: {
+        $id: 'http://foo/user',
+        type: 'object',
+        definitions: { address: { $id: '#address', type: 'object', properties: { city: { type: 'string' } }, required: ['city'] } },
+        required: ['address'],
+        properties: { test: { $ref: 'http://foo/test#' }, address: { $ref: '#address' } },
+      },
+    },
+  }, (req, reply) => reply.send({ ok: true }))
+  await refApp.ready()
+  const refGood = await refApp.inject({ method: 'POST', url: '/ref', payload: { test: { id: 1 }, address: { city: 'x' } } })
+  const refBadExt = await refApp.inject({ method: 'POST', url: '/ref', payload: { test: { id: 'no' }, address: { city: 'x' } } })
+  const refBadLocal = await refApp.inject({ method: 'POST', url: '/ref', payload: { test: { id: 1 }, address: {} } })
+  assert(refGood.statusCode === 200, 'cross-schema $ref: valid request accepted')
+  assert(refBadExt.statusCode === 400 && !/cannot resolve/.test(refBadExt.payload), 'cross-schema $ref: external $id ref enforced')
+  assert(refBadLocal.statusCode === 400 && !/cannot resolve/.test(refBadLocal.payload), 'cross-schema $ref: local #anchor enforced')
+  await refApp.close()
+
   console.log(`\n${pass}/${pass + fail} tests passed\n`)
   process.exit(fail > 0 ? 1 : 0)
 }