adapt-schemas 2.1.0 → 3.1.0

package/README.md

@@ -15,16 +15,16 @@ import Schemas from 'adapt-schemas'
 
 // Create and initialize the library
 const library = new Schemas()
-await library.init()
+library.init()
 
 // Load schemas from plugin directories
-await library.loadSchemas('**/schema/*.schema.json', {
+library.loadSchemas('**/schema/*.schema.json', {
   cwd: './plugins',
   ignore: ['**/node_modules/**']
 })
 
 // Validate data against a schema (defaults are applied automatically)
-const validatedData = await library.validate('course', {
+const validatedData = library.validate('course', {
   title: 'My Course'
 })
 ```
@@ -50,20 +50,20 @@ const library = new Schemas({
 Initializes the library and loads the base schema.
 
 ```javascript
-await library.init()
+library.init()
 ```
 
 ##### `loadSchemas(patterns, options)`
 Loads schemas from directories matching glob patterns.
 
 ```javascript
-await library.loadSchemas('**/schema/*.schema.json', {
+library.loadSchemas('**/schema/*.schema.json', {
   cwd: './plugins',           // Base directory for patterns
   ignore: ['**/excluded/**']  // Patterns to exclude
 })
 
 // Multiple patterns
-await library.loadSchemas([
+library.loadSchemas([
   'core/**/schema/*.schema.json',
   'plugins/**/schema/*.schema.json'
 ], { ignore: ['**/node_modules/**'] })
@@ -73,7 +73,7 @@ await library.loadSchemas([
 Registers a single schema file.
 
 ```javascript
-await library.registerSchema('/path/to/schema.json', {
+library.registerSchema('/path/to/schema.json', {
   replace: false  // Replace existing schema with same name
 })
 ```
@@ -82,7 +82,7 @@ await library.registerSchema('/path/to/schema.json', {
 Retrieves and builds a schema by name.
 
 ```javascript
-const schema = await library.getSchema('course', {
+const schema = library.getSchema('course', {
   useCache: true,        // Use cached build if available
   compile: true,         // Compile the schema
   applyExtensions: true  // Apply $patch extensions
@@ -93,7 +93,7 @@ const schema = await library.getSchema('course', {
 Returns the built schema object.
 
 ```javascript
-const schemaObj = await library.getBuiltSchema('course')
+const schemaObj = library.getBuiltSchema('course')
 console.log(schemaObj.properties)
 ```
 
@@ -101,7 +101,7 @@ console.log(schemaObj.properties)
 Validates data against a named schema.
 
 ```javascript
-const validated = await library.validate('course', inputData, {
+const validated = library.validate('course', inputData, {
   useDefaults: true,     // Apply schema defaults (default: true)
   ignoreRequired: false  // Ignore required field errors
 })
@@ -269,7 +269,7 @@ The library throws `SchemaError` with the following codes:
 import { SchemaError } from 'adapt-schemas'
 
 try {
-  await library.validate('course', data)
+  library.validate('course', data)
 } catch (e) {
   if (e instanceof SchemaError) {
     console.log(e.code)    // 'VALIDATION_FAILED'

package/lib/Schema.js

@@ -1,6 +1,6 @@
 import _ from 'lodash'
 import { EventEmitter } from 'events'
-import fs from 'fs/promises'
+import fs from 'fs'
 import SchemaError from './SchemaError.js'
 import xss from 'xss'
 
@@ -114,38 +114,38 @@ class Schema extends EventEmitter {
 
   /**
    * Determines whether the current schema build is valid using last modification timestamp
-   * @returns {Promise<boolean>}
+   * @returns {boolean}
    */
-  async isBuildValid () {
+  isBuildValid () {
     if (!this.built) return false
 
     let schema = this
     while (schema) {
-      const { mtimeMs } = await fs.stat(schema.filePath)
+      const { mtimeMs } = fs.statSync(schema.filePath)
       if (mtimeMs > this.lastBuildTime) return false
-      schema = await schema.getParent()
+      schema = schema.getParent()
     }
     return true
   }
 
   /**
    * Returns the parent schema if $merge is defined (or the base schema if a root schema)
-   * @returns {Promise<Schema|undefined>}
+   * @returns {Schema|undefined}
    */
-  async getParent () {
+  getParent () {
     if (this.name === BASE_SCHEMA_NAME) return undefined
 
     const parentRef = this.raw?.$merge?.source?.$ref ?? BASE_SCHEMA_NAME
-    return await this.schemaLibrary.getSchema(parentRef)
+    return this.schemaLibrary.getSchema(parentRef)
   }
 
   /**
    * Loads the schema file
-   * @returns {Promise<Schema>} This instance
+   * @returns {Schema} This instance
    */
-  async load () {
+  load () {
     try {
-      const content = await fs.readFile(this.filePath, 'utf-8')
+      const content = fs.readFileSync(this.filePath, 'utf-8')
       this.raw = JSON.parse(content)
       this.name = this.raw.$anchor
     } catch (e) {
@@ -177,54 +177,42 @@ class Schema extends EventEmitter {
    * @param {boolean} options.compile Compile the schema (default: true)
    * @param {boolean} options.applyExtensions Apply extension schemas (default: true)
    * @param {function} options.extensionFilter Filter function for extensions
-   * @returns {Promise<Schema>}
+   * @returns {Schema} This instance
    */
-  async build (options = {}) {
-    if (options.useCache !== false && this.enableCache && await this.isBuildValid()) {
+  build (options = {}) {
+    if (options.useCache !== false && this.enableCache && this.isBuildValid()) {
       return this
     }
 
-    if (this.isBuilding) {
-      return new Promise(resolve => this._buildCallbacks.push(() => resolve(this)))
-    }
-
-    this.isBuilding = true
-
     const { applyExtensions, extensionFilter } = options
 
     let built = _.cloneDeep(this.raw)
-    let parent = await this.getParent()
+    let parent = this.getParent()
 
     while (parent) {
-      const parentBuilt = _.cloneDeep((await parent.build({ ...options, compile: false })).built)
+      const parentBuilt = _.cloneDeep((parent.build({ ...options, compile: false })).built)
       built = this.patch(parentBuilt, built, { strict: false })
-      parent = await parent.getParent()
+      parent = parent.getParent()
     }
 
     if (this.extensions.length) {
-      await Promise.all(this.extensions.map(async s => {
+      this.extensions.forEach(s => {
         const applyPatch = typeof extensionFilter === 'function' ? extensionFilter(s) : applyExtensions !== false
-        if (applyPatch) {
-          const extSchema = await this.schemaLibrary.getSchema(s)
-          this.patch(built, extSchema.raw, { extendAnnotations: false })
-        }
-      }))
+        if (!applyPatch) return
+        const extSchema = this.schemaLibrary.getSchema(s)
+        this.patch(built, extSchema.raw, { extendAnnotations: false })
+      })
     }
 
     this.built = built
 
     if (options.compile !== false) {
-      this.compiledWithDefaults = await this.validatorWithDefaults.compileAsync(built)
-      this.compiled = await this.validator.compileAsync(built)
+      this.compiledWithDefaults = this.validatorWithDefaults.compile(built)
+      this.compiled = this.validator.compile(built)
     }
 
-    this.isBuilding = false
     this.lastBuildTime = Date.now()
 
-    // Notify waiting callbacks
-    this._buildCallbacks.forEach(cb => cb())
-    this._buildCallbacks = []
-
     this.emit('built', this)
     return this
   }
@@ -284,10 +272,11 @@ class Schema extends EventEmitter {
    * @param {Object} options
    * @param {boolean} options.useDefaults Apply schema defaults (default: true)
    * @param {boolean} options.ignoreRequired Ignore required field errors
+   * @param {boolean} options.ignoreErrors Ignore all validation errors (implies ignoreRequired)
    * @returns {Object} The validated data
    */
   validate (dataToValidate, options = {}) {
-    const opts = _.defaults(options, { useDefaults: true, ignoreRequired: false })
+    const opts = _.defaults(options, { useDefaults: true, ignoreRequired: false, ignoreErrors: false })
     const data = _.cloneDeep(dataToValidate)
     let compiled = opts.useDefaults ? this.compiledWithDefaults : this.compiled
 
@@ -299,17 +288,19 @@ class Schema extends EventEmitter {
 
     compiled(data)
 
-    const errors = compiled.errors && compiled.errors
-      .filter(e => e.keyword === 'required' ? !opts.ignoreRequired : true)
-      .map(e => e.instancePath ? `${e.instancePath} ${e.message}` : e.message)
-      .join(', ')
+    if (!opts.ignoreErrors) {
+      const errors = compiled.errors && compiled.errors
+        .filter(e => e.keyword === 'required' ? !opts.ignoreRequired : true)
+        .map(e => e.instancePath ? `${e.instancePath} ${e.message}` : e.message)
+        .join(', ')
 
-    if (errors?.length) {
-      throw new SchemaError('VALIDATION_FAILED', `Validation failed for schema: ${this.name} with errors: ${errors}`, {
-        schemaName: this.name,
-        errors,
-        data
-      })
+      if (errors?.length) {
+        throw new SchemaError('VALIDATION_FAILED', `Validation failed for schema: ${this.name} with errors: ${errors}`, {
+          schemaName: this.name,
+          errors,
+          data
+        })
+      }
     }
 
     return data

package/lib/Schemas.js

@@ -2,13 +2,13 @@ import _ from 'lodash'
 import Ajv from 'ajv/dist/2020.js'
 import { EventEmitter } from 'events'
 import { fileURLToPath } from 'url'
-import { glob } from 'glob'
 import Keywords from './Keywords.js'
 import path from 'path'
 import safeRegex from 'safe-regex'
 import Schema from './Schema.js'
 import SchemaError from './SchemaError.js'
 import XSSDefaults from './XSSDefaults.js'
+import { globSync } from 'fs'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const BASE_SCHEMA_PATH = '../schema/base.schema.json'
@@ -61,7 +61,7 @@ class Schemas extends EventEmitter {
       addUsedSchema: false,
       allErrors: true,
       allowUnionTypes: true,
-      loadSchema: async (uri) => (await this.getSchema(uri, { compile: false })).built,
+      loadSchema: (uri) => (this.getSchema(uri, { compile: false })).built,
       removeAdditional: 'all',
       strict: false,
       verbose: true,
@@ -95,12 +95,12 @@ class Schemas extends EventEmitter {
 
   /**
    * Initializes the schema library by loading the base schema
-   * @returns {Promise<SchemaLibrary>}
+   * @returns {Schemas}
    */
-  async init () {
+  init () {
     if (this._initialized) return this
 
-    await this.resetSchemaRegistry()
+    this.resetSchemaRegistry()
     this._initialized = true
     this.emit('initialized')
     return this
@@ -108,11 +108,10 @@ class Schemas extends EventEmitter {
 
   /**
    * Empties the schema registry (with the exception of the base schema)
-   * @returns {Promise<void>}
    */
-  async resetSchemaRegistry () {
+  resetSchemaRegistry () {
     this.schemas = {
-      base: await this.createSchema(path.resolve(__dirname, BASE_SCHEMA_PATH), { enableCache: true })
+      base: this.createSchema(path.resolve(__dirname, BASE_SCHEMA_PATH), { enableCache: true })
     }
     this.emit('reset')
   }
@@ -161,33 +160,36 @@ class Schemas extends EventEmitter {
    * @param {Object} options Glob options
    * @param {string[]} options.ignore Patterns to exclude
    * @param {string} options.cwd Base directory for glob patterns
-   * @returns {Promise<void>}
    */
-  async loadSchemas (patterns, options = {}) {
+  loadSchemas (patterns, options = {}) {
     if (!this._initialized) {
-      await this.init()
+      this.init()
     }
 
     const globOptions = {
       cwd: options.cwd || process.cwd(),
-      absolute: true,
-      ignore: options.ignore || []
+      exclude: options.ignore || []
     }
 
     const patternList = Array.isArray(patterns) ? patterns : [patterns]
     const allFiles = []
 
     for (const pattern of patternList) {
-      const files = await glob(pattern, globOptions)
-      allFiles.push(...files)
+      const files = globSync(pattern, globOptions)
+      allFiles.push(...files.map(f => path.resolve(globOptions.cwd, f)))
     }
 
     // Deduplicate files
     const uniqueFiles = [...new Set(allFiles)]
 
-    const results = await Promise.allSettled(
-      uniqueFiles.map(f => this.registerSchema(f))
-    )
+    const results = uniqueFiles.map(f => {
+      try {
+        this.registerSchema(f)
+      } catch (err) {
+        return { status: 'rejected', reason: err }
+      }
+      return { status: 'fulfilled' }
+    })
 
     results
       .filter(r => r.status === 'rejected')
@@ -201,14 +203,14 @@ class Schemas extends EventEmitter {
    * @param {string} filePath Path to the schema file
    * @param {Object} options Extra options
    * @param {boolean} options.replace Replace existing schema with same name
-   * @returns {Promise<Schema>}
+   * @returns {Schema}
    */
-  async registerSchema (filePath, options = {}) {
+  registerSchema (filePath, options = {}) {
     if (!_.isString(filePath)) {
       throw new SchemaError('INVALID_PARAMS', 'filePath must be a string', { params: ['filePath'] })
     }
 
-    const schema = await this.createSchema(filePath, options)
+    const schema = this.createSchema(filePath, options)
 
     if (this.schemas[schema.name]) {
       if (options.replace) {
@@ -251,9 +253,9 @@ class Schemas extends EventEmitter {
    * Creates a new Schema instance
    * @param {string} filePath Path to the schema file
    * @param {Object} options Options passed to Schema constructor
-   * @returns {Promise<Schema>}
+   * @returns {Schema}
    */
-  async createSchema (filePath, options = {}) {
+  createSchema (filePath, options = {}) {
     const schema = new Schema({
       enableCache: options.enableCache ?? this.options.enableCache,
       filePath,
@@ -296,9 +298,9 @@ class Schemas extends EventEmitter {
    * @param {boolean} options.compile Compile the schema (default: true)
    * @param {boolean} options.applyExtensions Apply extension schemas (default: true)
    * @param {function} options.extensionFilter Filter function for extensions
-   * @returns {Promise<Schema>}
+   * @returns {Schema}
    */
-  async getSchema (schemaName, options = {}) {
+  getSchema (schemaName, options = {}) {
     const schema = this.schemas[schemaName]
     if (!schema) {
       throw new SchemaError('MISSING_SCHEMA', `Schema '${schemaName}' not found`, { schemaName })
@@ -311,10 +313,10 @@ class Schemas extends EventEmitter {
    * @param {string} schemaName The schema name
    * @param {Object} data The data to validate
    * @param {Object} options Validation options
-   * @returns {Promise<Object>} The validated data with defaults applied
+   * @returns {Object} The validated data with defaults applied
    */
-  async validate (schemaName, data, options = {}) {
-    const schema = await this.getSchema(schemaName)
+  validate (schemaName, data, options = {}) {
+    const schema = this.getSchema(schemaName)
     return schema.validate(data, options)
   }
 
@@ -322,10 +324,10 @@ class Schemas extends EventEmitter {
    * Returns the built schema object
    * @param {string} schemaName The schema name
    * @param {Object} options Build options
-   * @returns {Promise<Object>} The built schema object
+   * @returns {Object} The built schema object
    */
-  async getBuiltSchema (schemaName, options = {}) {
-    const schema = await this.getSchema(schemaName)
+  getBuiltSchema (schemaName, options = {}) {
+    const schema = this.getSchema(schemaName)
     return schema.built
   }
 

package/package.json

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

package/test.js

@@ -165,6 +165,63 @@ async function setupTestSchemas () {
     }
   }
 
+  // Create a config extension that mimics adapt-contrib-languagePicker
+  const languagePickerConfigSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'languagePicker-config',
+    $patch: {
+      source: { $ref: 'config' },
+      with: {
+        properties: {
+          _languagePicker: {
+            type: 'object',
+            default: {},
+            properties: {
+              _isEnabled: { type: 'boolean', default: false },
+              _showOnCourseLoad: { type: 'boolean', default: true },
+              _languagePickerIconClass: { type: 'string', default: 'icon-language-2' },
+              _restoreStateOnLanguageChange: { type: 'boolean', default: false },
+              _classes: { type: 'string', default: '' },
+              _display: {
+                type: 'object',
+                // deliberately no default: {} — tests Case 3
+                properties: {
+                  _iconClass: { type: 'string', default: 'icon-default' },
+                  _position: { type: 'string', default: 'left' }
+                }
+              },
+              _languages: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    _language: { type: 'string', default: '' },
+                    _direction: { type: 'string', default: 'ltr' },
+                    _isDisabled: { type: 'boolean', default: false },
+                    displayName: { type: 'string', default: '' },
+                    _buttons: {
+                      type: 'object',
+                      default: {},
+                      properties: {
+                        yes: { type: 'string', default: 'Yes' },
+                        no: { type: 'string', default: 'No' }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  await fs.writeFile(
+    path.join(testSchemaDir, 'languagePicker-config.schema.json'),
+    JSON.stringify(languagePickerConfigSchema, null, 2)
+  )
+
   // Create a patch schema that extends course
   const coursePatchSchema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -413,6 +470,110 @@ async function runTests () {
     }
     console.log('')
 
+    // Test 14: ignoreErrors applies defaults without throwing on invalid data
+    console.log('Test 14: ignoreErrors applies defaults without throwing')
+    const invalidData = await library.validate('course', {
+      title: 12345 // wrong type — would normally throw
+    }, { ignoreErrors: true })
+    const defaultApplied = invalidData.description === ''
+    const invalidPreserved = invalidData.title === 12345
+    console.log(`  ✓ Default description applied despite type error: ${defaultApplied}`)
+    console.log(`  ✓ Invalid title value preserved: ${invalidPreserved}`)
+    if (!defaultApplied || !invalidPreserved) {
+      throw new Error('ignoreErrors did not apply defaults or preserve existing data')
+    }
+
+    // Verify it would throw without ignoreErrors
+    try {
+      await library.validate('course', { title: 12345 })
+      throw new Error('Should have thrown without ignoreErrors')
+    } catch (e) {
+      if (e.code !== 'VALIDATION_FAILED') throw e
+      console.log('  ✓ Same data throws without ignoreErrors: true')
+    }
+    console.log('')
+
+    // Test 15: ignoreErrors with missing required fields
+    console.log('Test 15: ignoreErrors ignores required field errors')
+    const missingRequired = await library.validate('course', {
+      description: 'No title provided'
+    }, { useDefaults: false, ignoreErrors: true })
+    const descPreserved = missingRequired.description === 'No title provided'
+    console.log(`  ✓ Data returned despite missing required "title": ${descPreserved}`)
+    if (!descPreserved) {
+      throw new Error('ignoreErrors did not return data with missing required fields')
+    }
+    console.log('')
+
+    // Test 16: Issue #30 Case 1 — Partially populated object missing sibling defaults
+    console.log('Test 16: Issue #30 Case 1 — Partially populated plugin config')
+    const partialConfig = await library.validate('config', {
+      _languagePicker: {
+        _isEnabled: true,
+        _languages: [
+          {
+            _language: 'en',
+            _direction: 'ltr',
+            displayName: 'English'
+          }
+        ]
+      }
+    }, { ignoreErrors: true })
+    const lp = partialConfig._languagePicker
+    const case1Checks = [
+      ['_isEnabled preserved', lp._isEnabled === true],
+      ['_showOnCourseLoad defaulted to true', lp._showOnCourseLoad === true],
+      ['_languagePickerIconClass defaulted', lp._languagePickerIconClass === 'icon-language-2'],
+      ['_restoreStateOnLanguageChange defaulted', lp._restoreStateOnLanguageChange === false],
+      ['_classes defaulted to empty string', lp._classes === ''],
+      ['_languages[0]._isDisabled defaulted', lp._languages[0]._isDisabled === false],
+      ['_languages[0]._buttons defaulted', lp._languages[0]._buttons?.yes === 'Yes'],
+      ['_languages[0]._buttons.no defaulted', lp._languages[0]._buttons?.no === 'No']
+    ]
+    case1Checks.forEach(([desc, ok]) => console.log(`  ${ok ? '✓' : '✗'} ${desc}: ${ok}`))
+    const case1Failed = case1Checks.filter(([, ok]) => !ok)
+    if (case1Failed.length) {
+      throw new Error(`Case 1 failures: ${case1Failed.map(([d]) => d).join(', ')}`)
+    }
+    console.log('')
+
+    // Test 17: Issue #30 Case 2 — Plugin object entirely absent
+    console.log('Test 17: Issue #30 Case 2 — Plugin object entirely absent')
+    const emptyConfig = await library.validate('config', {}, { ignoreErrors: true })
+    const lp2 = emptyConfig._languagePicker
+    const case2Checks = [
+      ['_languagePicker created from default: {}', lp2 !== undefined],
+      ['_isEnabled defaulted to false', lp2?._isEnabled === false],
+      ['_showOnCourseLoad defaulted to true', lp2?._showOnCourseLoad === true],
+      ['_languagePickerIconClass defaulted', lp2?._languagePickerIconClass === 'icon-language-2']
+    ]
+    case2Checks.forEach(([desc, ok]) => console.log(`  ${ok ? '✓' : '✗'} ${desc}: ${ok}`))
+    const case2Failed = case2Checks.filter(([, ok]) => !ok)
+    if (case2Failed.length) {
+      throw new Error(`Case 2 failures: ${case2Failed.map(([d]) => d).join(', ')}`)
+    }
+    console.log('')
+
+    // Test 18: Issue #30 Case 3 — Nested object without default: {}
+    console.log('Test 18: Issue #30 Case 3 — Nested object without default: {}')
+    const noNestedDefault = await library.validate('config', {
+      _languagePicker: { _isEnabled: true }
+    }, { ignoreErrors: true })
+    const lp3 = noNestedDefault._languagePicker
+    // _display has no default: {} so it should NOT be created by AJV
+    const displayMissing = lp3._display === undefined
+    console.log(`  ✓ _display not created (no default: {}): ${displayMissing}`)
+    if (!displayMissing) {
+      console.log(`    Note: _display was unexpectedly created: ${JSON.stringify(lp3._display)}`)
+    }
+    // But sibling defaults should still apply
+    const siblingsApplied = lp3._showOnCourseLoad === true && lp3._languagePickerIconClass === 'icon-language-2'
+    console.log(`  ✓ Sibling defaults still applied: ${siblingsApplied}`)
+    if (!siblingsApplied) {
+      throw new Error('Sibling defaults not applied when nested object has no default')
+    }
+    console.log('')
+
     console.log('=== All tests passed! ===')
   } finally {
     if (!hasSpecifiedPath) {