fastify-ata 0.4.1 → 0.5.0

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.1",
+  "version": "0.5.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",
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^0.17.4",
+    "ata-validator": "^0.18.0",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/test-types.ts

@@ -36,3 +36,52 @@ app.get('/search', {
   void _q
   return { ok: true }
 })
+
+// anyOf body narrows to a union
+app.post('/event', {
+  schema: {
+    body: defineSchema({
+      anyOf: [
+        { type: 'object', properties: { kind: { const: 'a' }, n: { type: 'number' } }, required: ['kind', 'n'] },
+        { type: 'object', properties: { kind: { const: 'b' }, s: { type: 'string' } }, required: ['kind', 's'] },
+      ],
+    }),
+  },
+}, async (req) => {
+  const _exact: Expect<typeof req.body, { kind: 'a'; n: number } | { kind: 'b'; s: string }> = true
+  void _exact
+  return { ok: true }
+})
+
+// $ref body resolves the referenced $defs entry
+app.post('/place', {
+  schema: {
+    body: defineSchema({
+      $defs: { Point: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' } }, required: ['x', 'y'] } },
+      type: 'object',
+      properties: { at: { $ref: '#/$defs/Point' } },
+      required: ['at'],
+    }),
+  },
+}, async (req) => {
+  const _x: number = req.body.at.x
+  const _exact: Expect<typeof req.body, { at: { x: number; y: number } }> = true
+  void _x; void _exact
+  return { ok: true }
+})
+
+// allOf body narrows to an intersection
+app.post('/merged', {
+  schema: {
+    body: defineSchema({
+      allOf: [
+        { type: 'object', properties: { a: { type: 'number' } }, required: ['a'] },
+        { type: 'object', properties: { b: { type: 'string' } }, required: ['b'] },
+      ],
+    }),
+  },
+}, async (req) => {
+  const _exact: Expect<typeof req.body, { a: number; b: string }> = true
+  void _exact
+  return { ok: true }
+})

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)
 }