adapt-schemas 2.0.1 → 3.0.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
   }
@@ -379,22 +367,22 @@ class Schema extends EventEmitter {
    * @param {Function} predicate - `(schemaField) => boolean`
    * @param {Object} [schema] - Internal: schema properties to walk (defaults to built.properties)
    * @param {string} [parentPath=''] - Internal: the slash-delimited path accumulated so far
-   * @returns {Array<Object>} Array of `{ path, key, data, value }` matches
+   * @returns {Array<Object>} Array of `{ path, key, data, value, schemaField }` matches
    */
   walk (data, predicate, schema, parentPath = '') {
     schema = schema ?? this.built.properties
     const matches = []
-    for (const [key, val] of Object.entries(schema)) {
+    for (const [key, schemaField] of Object.entries(schema)) {
       if (data[key] === undefined) continue
       const currentPath = parentPath ? `${parentPath}/${key}` : key
-      if (val.properties) {
-        matches.push(...this.walk(data[key], predicate, val.properties, currentPath))
-      } else if (val?.items?.properties) {
+      if (schemaField.properties) {
+        matches.push(...this.walk(data[key], predicate, schemaField.properties, currentPath))
+      } else if (schemaField?.items?.properties) {
         data[key].forEach((item, i) => {
-          matches.push(...this.walk(item, predicate, val.items.properties, `${currentPath}/${i}`))
+          matches.push(...this.walk(item, predicate, schemaField.items.properties, `${currentPath}/${i}`))
         })
-      } else if (predicate(val)) {
-        matches.push({ path: currentPath, key, data, value: data[key] })
+      } else if (predicate(schemaField)) {
+        matches.push({ path: currentPath, key, data, value: data[key], schemaField })
       }
     }
     return matches

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.0.1",
+  "version": "3.0.0",
   "description": "Standalone JSON Schema library for the Adapt framework",
   "type": "module",
   "main": "index.js",