adapt-schemas 1.2.1 → 2.0.1

package/README.md

@@ -1,6 +1,6 @@
 # adapt-schemas
 
-A standalone JSON Schema library for the Adapt framework stack. Load schemas from plugin folders via glob patterns, validate JSON data, and extract defaults including `_globals` from course schemas.
+A standalone JSON Schema library for the Adapt framework stack. Load schemas from plugin folders via glob patterns and validate JSON data with automatic defaults application via AJV.
 
 ## Installation
 
@@ -23,13 +23,10 @@ await library.loadSchemas('**/schema/*.schema.json', {
   ignore: ['**/node_modules/**']
 })
 
-// Validate data against a schema
+// Validate data against a schema (defaults are applied automatically)
 const validatedData = await library.validate('course', {
   title: 'My Course'
 })
-
-// Get _globals defaults from the course schema
-const globals = await library.getGlobalsDefaults('course')
 ```
 
 ## API Reference
@@ -110,22 +107,6 @@ const validated = await library.validate('course', inputData, {
 })
 ```
 
-##### `getSchemaDefaults(schemaName)`
-Returns all defaults as a structured object.
-
-```javascript
-const defaults = await library.getSchemaDefaults('course')
-// { title: 'Untitled', _globals: { ... } }
-```
-
-##### `getGlobalsDefaults(schemaName)`
-Extracts `_globals` defaults from a schema.
-
-```javascript
-const globals = await library.getGlobalsDefaults('course')
-// { _accessibility: { _isEnabled: true, ... }, _extensions: { ... } }
-```
-
 ##### `getSchemaNames()`
 Returns list of all registered schema names.
 

package/lib/Schema.js

@@ -18,7 +18,7 @@ class Schema extends EventEmitter {
    * @param {Object} options.xssWhitelist XSS whitelist configuration
    * @param {SchemaLibrary} options.schemaLibrary Reference to the parent library
    */
-  constructor ({ enableCache, filePath, validator, xssWhitelist, schemaLibrary }) {
+  constructor ({ enableCache, filePath, validatorWithDefaults, validator, xssWhitelist, schemaLibrary }) {
     super()
 
     /**
@@ -28,11 +28,17 @@ class Schema extends EventEmitter {
     this.built = undefined
 
     /**
-     * The compiled schema validation function
+     * Compiled validation function
      * @type {function}
      */
     this.compiled = undefined
 
+    /**
+     * Compiled validation function with useDefaults enabled
+     * @type {function}
+     */
+    this.compiledWithDefaults = undefined
+
     /**
      * Whether caching is enabled for this schema
      * @type {boolean}
@@ -76,7 +82,13 @@ class Schema extends EventEmitter {
     this.name = undefined
 
     /**
-     * Reference to the Ajv validator instance
+     * Ajv instance with useDefaults enabled
+     * @type {Ajv}
+     */
+    this.validatorWithDefaults = validatorWithDefaults
+
+    /**
+     * Ajv instance without useDefaults
      * @type {Ajv}
      */
     this.validator = validator
@@ -143,8 +155,8 @@ class Schema extends EventEmitter {
       })
     }
 
-    if (this.validator.validateSchema(this.raw)?.errors) {
-      const errors = this.validator.errors
+    if (this.validatorWithDefaults.validateSchema(this.raw)?.errors) {
+      const errors = this.validatorWithDefaults.errors
         .map(e => e.instancePath ? `${e.instancePath} ${e.message}` : e.message)
 
       if (errors.length) {
@@ -202,6 +214,7 @@ class Schema extends EventEmitter {
     this.built = built
 
     if (options.compile !== false) {
+      this.compiledWithDefaults = await this.validatorWithDefaults.compileAsync(built)
       this.compiled = await this.validator.compileAsync(built)
     }
 
@@ -275,22 +288,24 @@ class Schema extends EventEmitter {
    */
   validate (dataToValidate, options = {}) {
     const opts = _.defaults(options, { useDefaults: true, ignoreRequired: false })
-    const data = _.defaults(_.cloneDeep(dataToValidate), opts.useDefaults ? this.getObjectDefaults() : {})
+    const data = _.cloneDeep(dataToValidate)
+    let compiled = opts.useDefaults ? this.compiledWithDefaults : this.compiled
 
-    if (!this.compiled) {
+    if (!compiled) {
       this.emit('warning', `No compiled function for ${this.name}, compiling now`)
-      this.validator.compile(this.built)
+      const v = opts.useDefaults ? this.validatorWithDefaults : this.validator
+      compiled = v.compile(this.built)
     }
 
-    this.compiled(data)
+    compiled(data)
 
-    const errors = this.compiled.errors && this.compiled.errors
+    const errors = compiled.errors && compiled.errors
       .filter(e => e.keyword === 'required' ? !opts.ignoreRequired : true)
       .map(e => e.instancePath ? `${e.instancePath} ${e.message}` : e.message)
-      .reduce((s, e) => `${s}${e}, `, '')
+      .join(', ')
 
     if (errors?.length) {
-      throw new SchemaError('VALIDATION_FAILED', `Validation failed for schema: ${this.name}`, {
+      throw new SchemaError('VALIDATION_FAILED', `Validation failed for schema: ${this.name} with errors: ${errors}`, {
         schemaName: this.name,
         errors,
         data
@@ -358,22 +373,6 @@ class Schema extends EventEmitter {
     }
   }
 
-  /**
-   * Returns all schema defaults as a correctly structured object
-   * @param {Object} schema Schema to extract defaults from
-   * @returns {Object} The defaults object
-   */
-  getObjectDefaults (schema) {
-    schema = schema ?? this.built
-    const props = schema.properties ?? schema.$merge?.with?.properties ?? schema.$patch?.with?.properties
-
-    return _.mapValues(props, s => {
-      return s.type === 'object' && s.properties
-        ? this.getObjectDefaults(s)
-        : s.default
-    })
-  }
-
   /**
    * Walks the built schema alongside data, returning fields matching a predicate.
    * @param {Object} data - The data object to walk

package/lib/Schemas.js

@@ -57,11 +57,7 @@ class Schemas extends EventEmitter {
       this.options.xssWhitelist
     )
 
-    /**
-     * Reference to the Ajv instance
-     * @type {Ajv}
-     */
-    this.validator = new Ajv({
+    const ajvOptions = {
       addUsedSchema: false,
       allErrors: true,
       allowUnionTypes: true,
@@ -70,7 +66,19 @@ class Schemas extends EventEmitter {
       strict: false,
       verbose: true,
       keywords: Keywords.all()
-    })
+    }
+
+    /**
+     * Ajv instance
+     * @type {Ajv}
+     */
+    this.validator = new Ajv({ ...ajvOptions })
+
+    /**
+     * Ajv instance with useDefaults enabled (applies schema defaults during validation)
+     * @type {Ajv}
+     */
+    this.validatorWithDefaults = new Ajv({ ...ajvOptions, useDefaults: true })
 
     this.addStringFormats({
       'date-time': /[A-Za-z0-9:+()]+/,
@@ -119,7 +127,9 @@ class Schemas extends EventEmitter {
       if (isUnsafe) {
         this.emit('warning', `Unsafe RegExp for format '${name}' (${re}), using default`)
       }
-      this.validator.addFormat(name, isUnsafe ? /.*/ : re)
+      const format = isUnsafe ? /.*/ : re
+      this.validatorWithDefaults.addFormat(name, format)
+      this.validator.addFormat(name, format)
     })
   }
 
@@ -131,13 +141,15 @@ class Schemas extends EventEmitter {
    */
   addKeyword (definition, options = {}) {
     try {
-      if (this.validator.getKeyword(definition.keyword)) {
-        if (options.override !== true) {
-          throw new SchemaError('KEYWORD_EXISTS', 'Keyword already exists')
+      for (const v of [this.validatorWithDefaults, this.validator]) {
+        if (v.getKeyword(definition.keyword)) {
+          if (options.override !== true) {
+            throw new SchemaError('KEYWORD_EXISTS', 'Keyword already exists')
+          }
+          v.removeKeyword(definition.keyword)
         }
-        this.validator.removeKeyword(definition.keyword)
+        v.addKeyword(definition)
       }
-      this.validator.addKeyword(definition)
     } catch (e) {
       this.emit('warning', `Failed to define keyword '${definition.keyword}', ${e}`)
     }
@@ -245,6 +257,7 @@ class Schemas extends EventEmitter {
     const schema = new Schema({
       enableCache: options.enableCache ?? this.options.enableCache,
       filePath,
+      validatorWithDefaults: this.validatorWithDefaults,
       validator: this.validator,
       xssWhitelist: this.xssWhitelist,
       schemaLibrary: this,
@@ -316,27 +329,6 @@ class Schemas extends EventEmitter {
     return schema.built
   }
 
-  /**
-   * Returns schema defaults as a structured object
-   * @param {string} schemaName The schema name
-   * @returns {Promise<Object>} The defaults object
-   */
-  async getSchemaDefaults (schemaName) {
-    const schema = await this.getSchema(schemaName)
-    return schema.getObjectDefaults()
-  }
-
-  /**
-   * Extracts _globals defaults from the course schema
-   * @param {string} schemaName Schema name (defaults to 'course')
-   * @returns {Promise<Object>} The _globals defaults
-   */
-  async getGlobalsDefaults (schemaName = 'course') {
-    const schema = await this.getSchema(schemaName)
-    const defaults = schema.getObjectDefaults()
-    return defaults._globals || {}
-  }
-
   /**
    * Returns list of all registered schema names
    * @returns {string[]}

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/cgkineo/adapt-schemas"
   },
-  "version": "1.2.1",
+  "version": "2.0.1",
   "description": "Standalone JSON Schema library for the Adapt framework",
   "type": "module",
   "main": "index.js",

package/test.js

@@ -119,6 +119,52 @@ async function setupTestSchemas () {
     }
   }
 
+  // Create a config schema with nested defaults (mimics trickle pattern)
+  const configSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'config',
+    $merge: {
+      source: { $ref: 'base' },
+      with: {
+        properties: {
+          _trickle: {
+            type: 'object',
+            properties: {
+              _isEnabled: {
+                type: 'boolean',
+                default: true
+              },
+              _scrollDuration: {
+                type: 'number',
+                default: 500
+              },
+              _button: {
+                type: 'object',
+                default: {},
+                properties: {
+                  _isEnabled: {
+                    type: 'boolean',
+                    default: true
+                  },
+                  _styleBeforeCompletion: {
+                    type: 'string',
+                    default: 'hidden'
+                  }
+                }
+              },
+              _completionOrder: {
+                type: 'array',
+                items: { type: 'number' },
+                default: [1, 2, 3]
+              }
+            },
+            required: ['_scrollDuration']
+          }
+        }
+      }
+    }
+  }
+
   // Create a patch schema that extends course
   const coursePatchSchema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -158,6 +204,10 @@ async function setupTestSchemas () {
     path.join(testSchemaDir, 'component.schema.json'),
     JSON.stringify(componentSchema, null, 2)
   )
+  await fs.writeFile(
+    path.join(testSchemaDir, 'config.schema.json'),
+    JSON.stringify(configSchema, null, 2)
+  )
   await fs.writeFile(
     path.join(testSchemaDir, 'course-extension.schema.json'),
     JSON.stringify(coursePatchSchema, null, 2)
@@ -196,26 +246,16 @@ async function runTests () {
     const courseBuilt = await library.getBuiltSchema('course')
     console.log(`  ✓ Course schema has properties: ${Object.keys(courseBuilt.properties).join(', ')}\n`)
 
-    // Test 4: Get defaults
-    console.log('Test 4: Get schema defaults')
-    const courseDefaults = await library.getSchemaDefaults('course')
-    console.log('  ✓ Course defaults:', JSON.stringify(courseDefaults, null, 4).split('\n').map(l => '    ' + l).join('\n'), '\n')
-
-    // Test 5: Get _globals defaults
-    console.log('Test 5: Get _globals defaults')
-    const globalsDefaults = await library.getGlobalsDefaults('course')
-    console.log('  ✓ _globals defaults:', JSON.stringify(globalsDefaults, null, 4).split('\n').map(l => '    ' + l).join('\n'), '\n')
-
-    // Test 6: Validate data
-    console.log('Test 6: Validate data')
+    // Test 4: Validate data
+    console.log('Test 4: Validate data')
     const validData = await library.validate('course', {
       title: 'My Course'
     })
     console.log(`  ✓ Validated data has title: "${validData.title}"`)
     console.log(`  ✓ Default description applied: "${validData.description}"\n`)
 
-    // Test 7: Validate with error (missing required field without defaults)
-    console.log('Test 7: Validation error handling')
+    // Test 5: Validate with error (missing required field without defaults)
+    console.log('Test 5: Validation error handling')
     try {
       await library.validate('course', {
         // Missing required title - disable defaults to trigger required error
@@ -227,8 +267,8 @@ async function runTests () {
       console.log(`  ✓ Error message: ${e.message}\n`)
     }
 
-    // Test 7b: Validate with type error
-    console.log('Test 7b: Type validation error')
+    // Test 5b: Validate with type error
+    console.log('Test 5b: Type validation error')
     try {
       await library.validate('course', {
         title: 12345 // Should be string, not number
@@ -238,16 +278,16 @@ async function runTests () {
       console.log(`  ✓ Caught type validation error: ${e.code}\n`)
     }
 
-    // Test 8: Schema inheritance
-    console.log('Test 8: Schema inheritance')
+    // Test 6: Schema inheritance
+    console.log('Test 6: Schema inheritance')
     const componentBuilt = await library.getBuiltSchema('component')
     const hasInheritedBody = componentBuilt.properties.body !== undefined
     const hasOwnComponent = componentBuilt.properties._component !== undefined
     console.log(`  ✓ Component has inherited 'body' property: ${hasInheritedBody}`)
     console.log(`  ✓ Component has own '_component' property: ${hasOwnComponent}\n`)
 
-    // Test 9: Schema info
-    console.log('Test 9: Schema info')
+    // Test 7: Schema info
+    console.log('Test 7: Schema info')
     const info = library.getSchemaInfo()
     console.log('  ✓ Schema info:')
     Object.entries(info).forEach(([name, details]) => {
@@ -255,8 +295,8 @@ async function runTests () {
     })
     console.log('')
 
-    // Test 10: Events
-    console.log('Test 10: Event handling')
+    // Test 8: Events
+    console.log('Test 8: Event handling')
     library.on('schemaRegistered', (name) => {
       console.log(`  ✓ Event received: schemaRegistered (${name})`)
     })
@@ -274,8 +314,8 @@ async function runTests () {
     await library.registerSchema(newSchemaPath)
     console.log('')
 
-    // Test 11: Schema.walk
-    console.log('Test 11: Schema.walk')
+    // Test 9: Schema.walk
+    console.log('Test 9: Schema.walk')
     const courseSchema = await library.getSchema('course')
     const walkData = {
       title: 'Test',
@@ -295,6 +335,84 @@ async function runTests () {
     console.log(`  ✓ Includes top-level field: ${hasTitle}`)
     console.log(`  ✓ Includes nested field: ${hasNested}\n`)
 
+    // Test 10: Deep defaults on partial nested objects
+    console.log('Test 10: Deep defaults on partial nested objects')
+    const configData = await library.validate('config', {
+      _trickle: { _isEnabled: false }
+    })
+    const hasScrollDuration = configData._trickle._scrollDuration === 500
+    const hasButtonDefaults = configData._trickle._button?._styleBeforeCompletion === 'hidden'
+    const preservedExplicit = configData._trickle._isEnabled === false
+    console.log(`  ✓ Nested default _scrollDuration applied: ${hasScrollDuration}`)
+    console.log(`  ✓ Deep nested _button defaults applied: ${hasButtonDefaults}`)
+    console.log(`  ✓ Explicitly set _isEnabled preserved: ${preservedExplicit}`)
+    if (!hasScrollDuration || !hasButtonDefaults || !preservedExplicit) {
+      throw new Error('Deep defaults not applied correctly to partial nested objects')
+    }
+    console.log('')
+
+    // Test 11: Array defaults replaced, not merged
+    console.log('Test 11: Array defaults are replaced, not merged')
+    const arrayData = await library.validate('config', {
+      _trickle: { _completionOrder: [10, 20] }
+    })
+    const arrayNotMerged = JSON.stringify(arrayData._trickle._completionOrder) === '[10,20]'
+    console.log(`  ✓ Array preserved as [10,20], not merged with default: ${arrayNotMerged}`)
+    if (!arrayNotMerged) {
+      throw new Error(`Array was merged with defaults: got ${JSON.stringify(arrayData._trickle._completionOrder)}, expected [10,20]`)
+    }
+
+    const arrayDefaultApplied = await library.validate('config', {
+      _trickle: { _isEnabled: false }
+    })
+    const defaultArrayApplied = JSON.stringify(arrayDefaultApplied._trickle._completionOrder) === '[1,2,3]'
+    console.log(`  ✓ Missing array gets default [1,2,3]: ${defaultArrayApplied}`)
+    if (!defaultArrayApplied) {
+      throw new Error(`Default array not applied: got ${JSON.stringify(arrayDefaultApplied._trickle._completionOrder)}`)
+    }
+    console.log('')
+
+    // Test 12: useDefaults: false produces no defaults
+    console.log('Test 12: useDefaults: false produces no defaults')
+    const noDefaultsData = await library.validate('content', {
+      body: 'Hello'
+    }, { useDefaults: false, ignoreRequired: true })
+    const noIsOptional = noDefaultsData._isOptional === undefined
+    console.log(`  ✓ _isOptional not filled in: ${noIsOptional}`)
+    if (!noIsOptional) {
+      throw new Error(`useDefaults: false still applied defaults: _isOptional = ${noDefaultsData._isOptional}`)
+    }
+
+    const withDefaultsData = await library.validate('content', {
+      body: 'Hello'
+    }, { useDefaults: true, ignoreRequired: true })
+    const hasIsOptional = withDefaultsData._isOptional === false
+    console.log(`  ✓ _isOptional filled in with useDefaults: true: ${hasIsOptional}`)
+    if (!hasIsOptional) {
+      throw new Error(`useDefaults: true did not apply defaults: _isOptional = ${withDefaultsData._isOptional}`)
+    }
+    console.log('')
+
+    // Test 13: Partial nested object with required+default field (issue #21)
+    console.log('Test 13: Required+default field in partial nested object (issue #21)')
+    try {
+      const issueData = await library.validate('config', {
+        _trickle: { _isEnabled: false }
+      })
+      const hasRequired = issueData._trickle._scrollDuration === 500
+      console.log('  ✓ Validation passed (did not throw): true')
+      console.log(`  ✓ Required+default _scrollDuration applied: ${hasRequired}`)
+      if (!hasRequired) {
+        throw new Error('Required+default field _scrollDuration was not applied')
+      }
+    } catch (e) {
+      if (e.code === 'VALIDATION_FAILED') {
+        throw new Error(`Issue #21 regression: validation failed on partial nested object: ${e.data?.errors || e.message}`)
+      }
+      throw e
+    }
+    console.log('')
+
     console.log('=== All tests passed! ===')
   } finally {
     if (!hasSpecifiedPath) {