use exported Schema class where possible

Author: bkeepers

lib/constant.js

@@ -1,19 +1,25 @@
-import { schema } from './schemas'
+import { v4 as uuidv4 } from 'uuid'
+import { Schema } from './schemas'
 
 // Public: A constant value like a "string", number (1, 3.5), or boolean (true, false).
 //
 // Implements the same interface as Expression
 export class Constant {
-  constructor (value) {
+  constructor (value, id = uuidv4()) {
     this.value = value
+    this.id = id
+  }
+
+  clone (value, id = this.id) {
+    return new Constant(value, id)
   }
 
   get args () {
     return [this.value]
   }
 
   get schema () {
-    return schema.resolve('#/definitions/constant')
+    return Schema.resolve('#/definitions/constant')
   }
 
   validate (schema = this.schema) {

lib/expression.js

@@ -1,6 +1,6 @@
 import { v4 as uuidv4 } from 'uuid'
 import { Constant } from './constant'
-import { schema } from './schemas'
+import { Schema } from './schemas'
 
 function toArray (arg) {
   if (Array.isArray(arg)) {
@@ -48,7 +48,7 @@ export class Expression {
   }
 
   get schema () {
-    return schema.resolve('#')
+    return Schema.resolve('#')
   }
 
   validate (schema = this.schema) {

lib/index.js

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

test/constant.test.js

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

test/schemas.test.js

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'vitest'
-import { examples, schema, Expression } from '../lib'
+import { examples, Schema, Expression } from '../lib'
 
 describe('schema.json', () => {
   for (const [name, example] of Object.entries(examples)) {
@@ -36,38 +36,39 @@ describe('schema.json', () => {
 
   describe('resolve', () => {
     test('returns a schema', () => {
-      const ref = schema.resolve('#/definitions/constant')
+      const ref = Schema.resolve('#/definitions/constant')
       expect(ref.title).toEqual('Constant')
       expect(ref.validate(true)).toEqual({ valid: true, errors: null })
     })
 
     test('resolves refs', () => {
-      expect(schema.resolve('#/definitions/function/properties/Any').title).toEqual('Any')
-      expect(schema.definitions.function.properties.Any.title).toEqual('Any')
+      expect(Schema.resolve('#/definitions/function/properties/Any').title).toEqual('Any')
+      expect(Schema.resolve('#').definitions.function.properties.Any.title).toEqual('Any')
     })
   })
 
   describe('resolveAnyOf', () => {
     test('returns nested anyOf', () => {
-      expect(schema.resolveAnyOf()).toHaveLength(4)
+      const ref = Schema.resolve('#')
+      expect(ref.resolveAnyOf()).toHaveLength(4)
     })
 
     test('returns array of schemas', () => {
-      const ref = schema.resolve('#/definitions/constant')
+      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")
+      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")
+      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)