Add parent to expressions, refactor

- Adds `class Function extends Expression`
- `class Constant extends Expresson`

Author: bkeepers

lib/constant.js

@@ -1,43 +1,66 @@
 import { v4 as uuidv4 } from 'uuid'
-import { Constant } from './constant'
 import { Schema } from './schemas'
 
-function toArray (arg) {
-  if (Array.isArray(arg)) return arg
-  if (arg === null) return []
-  return [arg]
-}
-
-// Simple model to transform this: `{ All: [{ Boolean: [true] }]`
-// into this: `{ id: uuidv4(), name: 'All', args: [{ id: uuidv4(), name: 'Boolean', args: [true] }] }`
 export class Expression {
-  static build (expression, schema = undefined) {
-    if (expression instanceof Expression || expression instanceof Constant) {
-      return expression
+  static build (expression, attrs = {}) {
+    if (expression instanceof Function || expression instanceof Constant) {
+      return expression.clone(attrs)
     }
 
     if (['number', 'string', 'boolean'].includes(typeof expression) || expression === null) {
-      return new Constant(expression, { schema })
+      return new Constant({ value: expression, ...attrs })
     } else if (typeof expression === 'object') {
       if (Object.keys(expression).length !== 1) {
         throw new TypeError(`Invalid expression: ${JSON.stringify(expression)}`)
       }
       const name = Object.keys(expression)[0]
-      return new Expression({ name, args: expression[name] })
+      return new Function({ name, args: expression[name] })
     } else {
       throw new TypeError(`Invalid expression: ${JSON.stringify(expression)}`)
     }
   }
 
-  constructor ({ name, args, id = uuidv4() }) {
+  constructor ({ id = uuidv4(), parent = undefined }) {
     this.id = id
-    this.name = name
-    this.schema = Schema.resolve(`${name}.schema.json`)
-    this.args = toArray(args).map((arg, i) => Expression.build(arg, this.schema.arrayItem(i)))
+    this.parent = parent
+  }
+
+  clone (attrs = {}) {
+    return new this.constructor(Object.assign({}, this, attrs))
+  }
+
+  matches (schema) {
+    return this.validate(schema).valid
+  }
+
+  add (expression) {
+    if (this.schema.type !== 'array' || this.schema.maxItems) {
+      return Expression.build({ All: [this, expression] })
+    } else {
+      return this.clone({ args: [...this.args, expression] })
+    }
+  }
+
+  get parents () {
+    return this.parent ? [this.parent, ...this.parent.parents] : []
   }
 
-  clone ({ id = this.id, name = this.name, args = this.args } = {}) {
-    return new Expression({ id, name, args })
+  get depth () {
+    return this.parents.length
+  }
+}
+
+// Public: A function like "All", "Any", "Equal", "Duration", etc.
+export class Function extends Expression {
+  constructor ({ name, args, ...attrs }) {
+    super(attrs)
+
+    this.name = name
+    this.schema = Schema.resolve(`${name}.schema.json`)
+    this.args = toArray(args).map((arg, i) => Expression.build(arg, {
+      schema: this.schema.arrayItem(i),
+      parent: this
+    }))
   }
 
   get value () {
@@ -47,16 +70,27 @@ export class Expression {
   validate (schema = this.schema) {
     return schema.validate(this.args.map(arg => arg.value))
   }
+}
 
-  matches (schema) {
-    return this.validate(schema).valid
+// Public: A constant value like a "string", number (1, 3.5), or boolean (true, false).
+export class Constant extends Expression {
+  constructor ({ value, schema = Schema.resolve('#'), ...attrs }) {
+    super(attrs)
+    this.value = value
+    this.schema = schema
   }
 
-  add (expression) {
-    if (this.schema.maxItems) {
-      return Expression.build({ All: [this, expression] })
-    } else {
-      return this.clone({ args: [...this.args, expression] })
-    }
+  get args () {
+    return [this.value]
+  }
+
+  validate (schema = this.schema) {
+    return schema.validate(this.value)
   }
 }
+
+function toArray (arg) {
+  if (Array.isArray(arg)) return arg
+  if (arg === null) return []
+  return [arg]
+}

lib/expression.js

@@ -1,4 +1,3 @@
 export { Schema, schemas, BaseURI } from './schemas'
-export { Expression } from './expression'
-export { Constant } from './constant'
+export { Expression, Function, Constant } from './expression'
 export { default as examples } from '../examples'

lib/index.js

@@ -4,49 +4,49 @@ import { Constant, Schema } from '../lib'
 describe('Constant', () => {
   describe('schema', () => {
     test('defaults to expression schema', () => {
-      expect(new Constant('string').schema.title).toEqual('Expression')
+      expect(new Constant({ value: 'string' }).schema.title).toEqual('Expression')
     })
 
     test('uses provided schema', () => {
       const schema = Schema.resolve('#/definitions/number')
-      const number = new Constant(42, { schema })
+      const number = new Constant({ value: 42, schema })
       expect(number.schema).toEqual(schema)
-      expect(number.clone(99).schema).toEqual(schema)
+      expect(number.clone({ value: 99 }).schema).toEqual(schema)
     })
   })
 
   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)
+      expect(new Constant({ value: true }).validate().valid).toBe(true)
+      expect(new Constant({ value: false }).validate().valid).toBe(true)
+      expect(new Constant({ value: 'string' }).validate().valid).toBe(true)
+      expect(new Constant({ value: 42 }).validate().valid).toBe(true)
+      expect(new Constant({ value: 3.14 }).validate().valid).toBe(true)
     })
 
     test('returns false for invalid value', () => {
-      expect(new Constant(['array']).validate().valid).toBe(false)
+      expect(new Constant({ value: ['array'] }).validate().valid).toBe(false)
     })
 
     test('uses provided schema', () => {
       const schema = Schema.resolve('#/definitions/number')
-      expect(new Constant(42, { schema }).validate().valid).toBe(true)
-      expect(new Constant(42).validate(schema).valid).toBe(true)
+      expect(new Constant({ value: 42, schema }).validate().valid).toBe(true)
+      expect(new Constant({ value: 42 }).validate(schema).valid).toBe(true)
 
-      expect(new Constant('nope', { schema }).validate().valid).toBe(false)
-      expect(new Constant('nope').validate(schema).valid).toBe(false)
+      expect(new Constant({ value: 'nope', schema }).validate().valid).toBe(false)
+      expect(new Constant({ value: 'nope' }).validate(schema).valid).toBe(false)
     })
   })
 
   describe('matches', () => {
     test('returns true for matching validator', () => {
       const schema = Schema.resolve('#/definitions/constant/anyOf/0')
-      expect(new Constant('string').matches(schema)).toBe(true)
+      expect(new Constant({ value: 'string' }).matches(schema)).toBe(true)
     })
 
     test('returns false for different schema', () => {
       const schema = Schema.resolve('#/definitions/constant/anyOf/0')
-      expect(new Constant(true).matches(schema)).toBe(false)
+      expect(new Constant({ value: true }).matches(schema)).toBe(false)
     })
   })
 })

test/constant.test.js

@@ -1,13 +1,15 @@
 import { describe, test, expect } from 'vitest'
-import { Expression, Constant, Schema } from '../lib'
+import { Expression, Function, Constant, Schema } from '../lib'
 
 describe('Expression', () => {
   describe('build', () => {
     test('builds an expression from an object', () => {
       const expression = Expression.build({ All: [true] })
+      expect(expression).toBeInstanceOf(Function)
       expect(expression.name).toEqual('All')
       expect(expression.args[0]).toBeInstanceOf(Constant)
-      expect(expression.args[0].value).toEqual(true)
+      expect(expression.args[0].value).toBe(true)
+      expect(expression.args[0].parent).toBe(expression)
       expect(expression.value).toEqual({ All: [true] })
     })
 
@@ -56,36 +58,6 @@ describe('Expression', () => {
     })
   })
 
-  describe('clone', () => {
-    test('returns new expression', () => {
-      const expression = Expression.build({ All: [true] })
-      const clone = expression.clone()
-      expect(clone).not.toBe(expression)
-      expect(clone.name).toEqual(expression.name)
-      expect(clone.args).toEqual(expression.args)
-      expect(clone.id).toEqual(expression.id)
-    })
-
-    test('builds args', () => {
-      const expression = Expression.build({ All: [] })
-      const clone = expression.clone({ args: [true] })
-      expect(clone.args[0]).toBeInstanceOf(Constant)
-      expect(clone.value).toEqual({ All: [true] })
-    })
-  })
-
-  describe('validate', () => {
-    test('passes for valid expression', () => {
-      const expression = Expression.build({ All: [true] })
-      expect(expression.validate().valid).toBe(true)
-    })
-
-    test('fails for invalid expression', () => {
-      const expression = Expression.build({ Duration: [] })
-      expect(expression.validate().valid).toBe(false)
-    })
-  })
-
   describe('add', () => {
     test('Any returns new expression with added arg', () => {
       const expression = Expression.build({ Any: [] }).add(true)
@@ -101,5 +73,10 @@ describe('Expression', () => {
       const expression = Expression.build({ Equal: [1, 1] }).add(false)
       expect(expression.value).toEqual({ All: [{ Equal: [1, 1] }, false] })
     })
+
+    test('Constant returns new expression wrapped in All', () => {
+      const expression = Expression.build(true).add(false)
+      expect(expression.value).toEqual({ All: [true, false] })
+    })
   })
 })

test/expression.test.js

@@ -0,0 +1,37 @@
+import { describe, test, expect } from 'vitest'
+import { Expression, Function, Constant } from '../lib'
+
+describe('Function', () => {
+  describe('clone', () => {
+    test('returns new expression', () => {
+      const expression = Expression.build({ All: [true] })
+      const clone = expression.clone()
+      expect(clone).not.toBe(expression)
+      expect(clone).toBeInstanceOf(Function)
+      expect(clone.name).toEqual(expression.name)
+      expect(clone.args).toEqual(expression.args)
+      expect(clone.id).toEqual(expression.id)
+      expect(clone.args[0].parent).toBe(clone)
+      expect(clone.args[0].depth).toBe(1)
+    })
+
+    test('builds args', () => {
+      const expression = Expression.build({ All: [] })
+      const clone = expression.clone({ args: [true] })
+      expect(clone.args[0]).toBeInstanceOf(Constant)
+      expect(clone.value).toEqual({ All: [true] })
+    })
+  })
+
+  describe('validate', () => {
+    test('passes for valid expression', () => {
+      const expression = Expression.build({ All: [true] })
+      expect(expression.validate().valid).toBe(true)
+    })
+
+    test('fails for invalid expression', () => {
+      const expression = Expression.build({ Duration: [] })
+      expect(expression.validate().valid).toBe(false)
+    })
+  })
+})