Add simple schema class to browse and validate schemas

Author: bkeepers

lib/constant.js

@@ -1,4 +1,4 @@
-import { useValidator } from './validate'
+import { schema } from './schemas'
 
 // Public: A constant value like a "string", number (1, 3.5), or boolean (true, false).
 //
@@ -12,20 +12,15 @@ export class Constant {
     return [this.value]
   }
 
-  get schema () {
-    return { type: typeof this.value }
+  get validator () {
+    return schema.get('#/definitions/constant')
   }
 
-  validate(schema = this.schema) {
-    const validator = useValidator()
-    const data = this.value
-    const valid = validator.validate(schema, data)
-    const errors = validator.errors
-    return { valid, errors, data }
+  validate (validator = this.validator) {
+    return schema.validate(this.value, validator)
   }
 
-  matches(schema) {
-    const { valid } = this.validate(schema)
-    return valid
+  matches (localSchema) {
+    return this.validate(localSchema).valid
   }
 }

lib/explorer.js

@@ -1,7 +1,16 @@
 import { v4 as uuidv4 } from 'uuid'
 import { Constant } from './constant'
-import explorer from './explorer'
-import { useValidator } from './validate'
+import { schema } from './schemas'
+
+function toArray (arg) {
+  if (Array.isArray(arg)) {
+    return arg
+  } else if (arg === null) {
+    return []
+  } else {
+    return [arg]
+  }
+}
 
 // Simple model to transform this: `{ All: [{ Boolean: [true] }]`
 // into this: `{ id: uuidv4(), name: 'All', args: [{ id: uuidv4(), name: 'Boolean', args: [true] }] }`
@@ -12,11 +21,17 @@ export class Expression {
     }
 
     if (typeof expression === 'object') {
+      if (Object.keys(expression).length !== 1) {
+        throw new TypeError(`Invalid expression: ${JSON.stringify(expression)}`)
+      }
       const name = Object.keys(expression)[0]
-      const args = expression[name].map(Expression.build)
+      const args = toArray(expression[name]).map(Expression.build)
+
       return new Expression({ name, args })
-    } else {
+    } else if (['number', 'string', 'boolean'].includes(typeof expression)) {
       return new Constant(expression)
+    } else {
+      throw new TypeError(`Invalid expression: ${JSON.stringify(expression)}`)
     }
   }
 
@@ -32,20 +47,15 @@ export class Expression {
     return { [this.name]: this.args.map(arg => arg.value) }
   }
 
-  get schema () {
-    return explorer.functions[this.name]
+  get validator () {
+    return schema.get('#')
   }
 
-  validate(schema = this.schema) {
-    const validator = useValidator()
-    const data = this.value
-    const valid = validator.validate(schema, data)
-    const errors = validator.errors
-    return { valid, errors, data }
+  validate (validator = this.validator) {
+    return schema.validate(this.value, validator)
   }
 
-  matches(schema) {
-    const { valid } = this.validate(schema)
-    return valid
+  matches (localSchema) {
+    return this.validate(localSchema).valid
   }
 }

lib/expression.js

@@ -1,6 +1,4 @@
-export { default as schemas, BaseURI } from '../schemas'
+export { schema, schemas, BaseURI } from './schemas'
 export { default as examples } from '../examples'
-export { default as explorer } from './explorer'
-export { default as validate } from './validate'
 export { Expression } from './expression'
 export { Constant } from './constant'

lib/index.js

@@ -0,0 +1,32 @@
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+
+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
+
+class Schema {
+  constructor (schemas, baseURI) {
+    this.baseURI = baseURI
+
+    this.ajv = new Ajv({
+      schemas,
+      useDefaults: true,
+      allErrors: true,
+      strict: true
+    })
+    addFormats(this.ajv)
+  }
+
+  get (ref, baseURI = this.baseURI) {
+    return this.ajv.getSchema(new URL(ref, baseURI).href)
+  }
+
+  validate (data, validator = this.get('#')) {
+    const valid = validator(data, schema)
+    const errors = validator.errors
+    return { valid, errors }
+  }
+}
+
+export const schema = new Schema(schemas, BaseURI)

lib/schemas.js

@@ -21,7 +21,6 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "json-pointer": "^0.6.2",
     "uuid": "^9.0.0"
   },
   "devDependencies": {

lib/validate.js

@@ -1,18 +1,13 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://www.flippercloud.io/expressions/schema.json",
-  "title": "Flipper Expressions",
-  "description": "TODO",
-  "$ref": "#/definitions/expression",
+  "title": "Expression",
+  "description": "An expression can be a Constant or a Function",
+  "anyOf": [
+    { "$ref": "#/definitions/constant" },
+    { "$ref": "#/definitions/function" }
+  ],
   "definitions": {
-    "expression": {
-      "title": "Expression",
-      "description": "An expression can be a Function or a Constant",
-      "anyOf": [
-        { "$ref": "#/definitions/constant" },
-        { "$ref": "#/definitions/function" }
-      ]
-    },
     "constant": {
       "title": "Constant",
       "description": "A constant value can be a string, number or boolean",
@@ -78,21 +73,21 @@
     "arguments-n": {
       "description": "An array of expressions",
       "type": "array",
-      "items": { "$ref": "#/definitions/expression" },
+      "items": { "$ref": "#" },
       "minItems": 0
     },
     "arguments-two": {
       "title": "Comparison",
       "description": "An array with exactly two expressions",
       "type": "array",
-      "items": { "$ref": "#/definitions/expression" },
+      "items": { "$ref": "#" },
       "minItems": 2,
       "maxItems": 2
     },
     "argument": {
       "description": "An array with exactly one expression",
       "type": "array",
-      "items": { "$ref": "#/definitions/expression" },
+      "items": { "$ref": "#" },
       "minItems": 1,
       "maxItems": 1
     }

package.json

@@ -1,34 +1,32 @@
 import { describe, test, expect } from 'vitest'
-import { Constant } from '../lib'
+import { Constant, schema } from '../lib'
 
 describe('Constant', () => {
-  describe('schema', () => {
-    test('returns `{ type: "string" }` for string value', () => {
-      expect(new Constant('string').schema).toEqual({ type: 'string' })
-    })
-
-    test('returns `{ type: "boolean" }` for boolean value', () => {
-      expect(new Constant(true).schema).toEqual({ type: 'boolean' })
-    })
-
-    test('returns `{ type: "number" }` for number value', () => {
-      expect(new Constant(42).schema).toEqual({ type: 'number' })
+  describe('validator', () => {
+    test('returns Constant validator', () => {
+      expect(new Constant('string').validator.schema.title).toEqual('Constant')
     })
   })
 
   describe('validate', () => {
     test('returns true for valid value', () => {
       expect(new Constant(true).validate().valid).toBe(true)
+      expect(new Constant(false).validate().valid).toBe(true)
+      expect(new Constant('string').validate().valid).toBe(true)
+      expect(new Constant(42).validate().valid).toBe(true)
+      expect(new Constant(3.14).validate().valid).toBe(true)
     })
   })
 
   describe('matches', () => {
-    test('returns true matching schema', () => {
-      expect(new Constant(true).matches({ type: 'boolean' })).toBe(true)
+    test('returns true for matching validator', () => {
+      const validator = schema.get('#/definitions/constant/anyOf/0')
+      expect(new Constant('string').matches(validator)).toBe(true)
     })
 
     test('returns false for different schema', () => {
-      expect(new Constant('string').matches({ type: 'boolean' })).toBe(false)
+      const validator = schema.get('#/definitions/constant/anyOf/0')
+      expect(new Constant(true).matches(validator)).toBe(false)
     })
   })
 })