Add proxying back to schema to resolve refs

packages/expressions/lib/constant.js

@@ -12,15 +12,15 @@ export class Constant {
     return [this.value]
   }
 
-  get validator () {
-    return schema.get('#/definitions/constant')
+  get schema () {
+    return schema.resolve('#/definitions/constant')
   }
 
-  validate (validator = this.validator) {
-    return schema.validate(this.value, validator)
+  validate (schema = this.schema) {
+    return schema.validate(this.value)
   }
 
-  matches (localSchema) {
-    return this.validate(localSchema).valid
+  matches (schema = this.schema) {
+    return schema.validate(this.value).valid
   }
 }

packages/expressions/lib/expression.js

@@ -47,15 +47,15 @@ export class Expression {
     return { [this.name]: this.args.map(arg => arg.value) }
   }
 
-  get validator () {
-    return schema.get('#')
+  get schema () {
+    return schema.resolve('#')
   }
 
-  validate (validator = this.validator) {
-    return schema.validate(this.value, validator)
+  validate (schema = this.schema) {
+    return schema.validate(this.value)
   }
 
   matches (localSchema) {
-    return this.validate(localSchema).valid
+    return localSchema.validate(this.value).valid
   }
 }

packages/expressions/lib/schemas.js

@@ -1,32 +1,92 @@
 import Ajv from 'ajv'
 import addFormats from 'ajv-formats'
 
+// Load all schemas in schemas/*.json
 const modules = import.meta.glob('../schemas/*.json', { eager: true, import: 'default' })
 export const schemas = Object.values(modules)
 export const BaseURI = modules['../schemas/schema.json'].$id
 
+// Create a new Ajv validator instance with all schemas loaded
+const ajv = new Ajv({
+  schemas,
+  useDefaults: true,
+  allErrors: true,
+  strict: true
+})
+addFormats(ajv)
+
+// Proxy to resolve $refs in schema definitions
+const Dereference = {
+  get (target, property) {
+    const value = target[property]
+
+    if (Array.isArray(value)) {
+      // Schema definition returns an array for this property, return the array with all refs resolved
+      return value.map((item, i) => Schema.proxy(this.join(target.$id, `${property}/${i}`), item))
+    } else if (value !== null && typeof value === 'object') {
+      // Schema definition returns an object for this property, return the subschema and proxy it
+      return Schema.proxy(this.join(target.$id, property), value)
+    } else if (value !== undefined) {
+      // Schema definition returns a value for this property, just return it
+      return value
+    } else if (target.$ref) {
+      // Schema includes a ref, so delegate to it
+      return Schema.resolve(target.$ref, target.$id)[property]
+    }
+  },
+
+  join ($id, path) {
+    const url = new URL($id)
+    url.hash = [url.hash, path].join('/')
+    return url.toString()
+  }
+}
+
+// Delegate property access to the schema definition
+const DelegateToDefinition = {
+  get (target, property) {
+    return target[property] ?? target.definition[property]
+  },
+
+  has (target, property) {
+    return property in target || property in target.definition
+  }
+}
+
+// Class to browse schemas, resolve refs, and validate data
 class Schema {
-  constructor (schemas, baseURI) {
-    this.baseURI = baseURI
+  static resolve ($ref, $id = undefined) {
+    const { href } = new URL($ref, $id)
+    return this.proxy(href, ajv.getSchema(href).schema)
+  }
+
+  static proxy ($id, definition) {
+    return new Proxy(new Schema($id, definition), DelegateToDefinition)
+  }
+
+  constructor ($id, definition) {
+    this.definition = new Proxy({ $id, ...definition }, Dereference)
+  }
+
+  resolve ($ref = this.definition.$ref, $id = this.definition.$id) {
+    return Schema.resolve($ref, $id)
+  }
 
-    this.ajv = new Ajv({
-      schemas,
-      useDefaults: true,
-      allErrors: true,
-      strict: true
-    })
-    addFormats(this.ajv)
+  resolveAnyOf () {
+    return this.definition.anyOf?.map(ref => ref.resolveAnyOf())?.flat() || [this]
   }
 
-  get (ref, baseURI = this.baseURI) {
-    return this.ajv.getSchema(new URL(ref, baseURI).href)
+  arrayItem (index) {
+    const items = this.definition.items
+    return Array.isArray(items) ? items[index] : items
   }
 
-  validate (data, validator = this.get('#')) {
-    const valid = validator(data, schema)
+  validate (data) {
+    const validator = ajv.getSchema(this.definition.$id)
+    const valid = validator(data)
     const errors = validator.errors
     return { valid, errors }
   }
 }
 
-export const schema = new Schema(schemas, BaseURI)
+export const schema = Schema.resolve(BaseURI)

packages/expressions/schemas/Duration.schema.json

@@ -7,6 +7,7 @@
   "items": [
     { "$ref": "schema.json#/definitions/number" },
     {
+      "title": "Unit",
       "anyOf": [
         {
           "type": "string",

packages/expressions/schemas/schema.json

@@ -57,13 +57,15 @@
       "additionalProperties": false
     },
     "string": {
+      "title": "String",
       "description": "A constant string value or a function that returns a string",
       "anyOf": [
         { "type": "string" },
         { "$ref": "#/definitions/function" }
       ]
     },
     "number": {
+      "title": "Number",
       "description": "A constant numeric value or a function that returns a number",
       "anyOf": [
         { "type": "number" },

packages/expressions/test/constant.test.js

@@ -2,9 +2,9 @@ import { describe, test, expect } from 'vitest'
 import { Constant, schema } from '../lib'
 
 describe('Constant', () => {
-  describe('validator', () => {
-    test('returns Constant validator', () => {
-      expect(new Constant('string').validator.schema.title).toEqual('Constant')
+  describe('schema', () => {
+    test('returns Constant schema', () => {
+      expect(new Constant('string').schema.title).toEqual('Constant')
     })
   })
 
@@ -20,12 +20,12 @@ describe('Constant', () => {
 
   describe('matches', () => {
     test('returns true for matching validator', () => {
-      const validator = schema.get('#/definitions/constant/anyOf/0')
+      const validator = schema.resolve('#/definitions/constant/anyOf/0')
       expect(new Constant('string').matches(validator)).toBe(true)
     })
 
     test('returns false for different schema', () => {
-      const validator = schema.get('#/definitions/constant/anyOf/0')
+      const validator = schema.resolve('#/definitions/constant/anyOf/0')
       expect(new Constant(true).matches(validator)).toBe(false)
     })
   })

packages/expressions/test/schemas.test.js

@@ -34,15 +34,43 @@ describe('schema.json', () => {
     })
   }
 
-  describe('get', () => {
-    test('returns a validator', () => {
-      const ref = schema.get('#')
-      expect(ref.schema.title).toEqual('Expression')
+  describe('resolve', () => {
+    test('returns a schema', () => {
+      const ref = schema.resolve('#/definitions/constant')
+      expect(ref.title).toEqual('Constant')
+      expect(ref.validate(true)).toEqual({ valid: true, errors: null })
     })
 
     test('resolves refs', () => {
-      const ref = schema.get('#/definitions/function/properties/Any')
-      expect(ref.schema.title).toEqual('Any')
+      expect(schema.resolve('#/definitions/function/properties/Any').title).toEqual('Any')
+      expect(schema.definitions.function.properties.Any.title).toEqual('Any')
+    })
+  })
+
+  describe('resolveAnyOf', () => {
+    test('returns nested anyOf', () => {
+      expect(schema.resolveAnyOf()).toHaveLength(4)
+    })
+
+    test('returns array of schemas', () => {
+      const ref = schema.resolve('#/definitions/constant')
+      expect(ref.resolveAnyOf()).toHaveLength(3)
+      expect(ref.resolveAnyOf()).toEqual(ref.anyOf)
+    })
+  })
+
+  describe('arrayItem', () => {
+    test('returns schema for repeated array item', () => {
+      const any = schema.resolve("Any.schema.json")
+      expect(any.arrayItem(0).title).toEqual('Expression')
+      expect(any.arrayItem(99).title).toEqual('Expression')
+    })
+
+    test('returns schema for tuple', () => {
+      const duration = schema.resolve("Duration.schema.json")
+      expect(duration.arrayItem(0).title).toEqual('Number')
+      expect(duration.arrayItem(1).title).toEqual('Unit')
+      expect(duration.arrayItem(2)).toBe(undefined)
     })
   })
 })