adapt-schemas 1.0.0 → 1.0.2

package/.github/workflows/releases.yml

@@ -0,0 +1,32 @@
+name: Release
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # to be able to publish a GitHub release
+      issues: write # to be able to comment on released issues
+      pull-requests: write # to be able to comment on released pull requests
+      id-token: write # to enable use of OIDC for trusted publishing and npm provenance
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 'lts/*'
+      - name: Update npm
+        run: npm install -g npm@latest
+      - name: Install dependencies
+        run: npm ci
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npx semantic-release

package/.github/workflows/standardjs.yml

@@ -0,0 +1,13 @@
+name: Standard.js
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npx standard

package/.github/workflows/tests.yml

@@ -0,0 +1,13 @@
+name: Tests
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/README.md

@@ -43,11 +43,7 @@ const library = new Schemas({
   enableCache: true,              // Enable schema build caching (default: true)
   xssWhitelist: {},               // Custom XSS whitelist tags/attributes
   xssWhitelistOverride: false,    // Replace defaults instead of extending
-  formatOverrides: {},            // Custom string format RegExp patterns
-  directoryReplacements: {        // Replacements for isDirectory keyword
-    '$ROOT': '/app',
-    '$DATA': '/app/data'
-  }
+  formatOverrides: {}             // Custom string format RegExp patterns
 })
 ```
 
@@ -153,7 +149,7 @@ Manually extends a schema with another.
 library.extendSchema('course', 'my-course-extension')
 ```
 
-##### `addKeyword(definition)`
+##### `addKeyword(definition, options)`
 Adds a custom AJV keyword.
 
 ```javascript
@@ -162,6 +158,20 @@ library.addKeyword({
   type: 'number',
   validate: (schema, data) => data > 0
 })
+
+// Override an existing keyword
+library.addKeyword({
+  keyword: 'isPositive',
+  type: 'number',
+  validate: (schema, data) => data >= 0
+}, { override: true })
+```
+
+##### `deregisterSchema(name)`
+Removes a schema from the registry.
+
+```javascript
+library.deregisterSchema('my-schema')
 ```
 
 ##### `addStringFormats(formats)`
@@ -257,7 +267,6 @@ The library includes these custom AJV keywords:
 | `isBytes` | Parses byte strings | `"1MB"` → `1048576` |
 | `isDate` | Parses date strings | `"2024-01-01"` → `Date` |
 | `isTimeMs` | Parses duration strings | `"7d"` → `604800000` |
-| `isDirectory` | Resolves path tokens | `"$ROOT/data"` → `"/app/data"` |
 | `isObjectId` | Marks ObjectId fields | No transformation |
 
 ## Error Handling
@@ -272,6 +281,7 @@ The library throws `SchemaError` with the following codes:
 | `INVALID_SCHEMA` | Schema fails JSON Schema validation |
 | `MISSING_SCHEMA` | Requested schema not found |
 | `VALIDATION_FAILED` | Data fails schema validation |
+| `KEYWORD_EXISTS` | Keyword already defined |
 | `MODIFY_PROTECTED_ATTR` | Attempt to modify internal/read-only field |
 
 ```javascript

package/index.js

@@ -1,7 +1,8 @@
-import Schemas, { SchemaError } from './lib/Schemas.js'
-import Schema from './lib/Schema.js'
 import Keywords from './lib/Keywords.js'
+import Schema from './lib/Schema.js'
+import SchemaError from './lib/SchemaError.js'
+import Schemas from './lib/Schemas.js'
 import XSSDefaults from './lib/XSSDefaults.js'
 
-export { Schemas, Schema, SchemaError, Keywords, XSSDefaults }
+export { Keywords, Schema, SchemaError, Schemas, XSSDefaults }
 export default Schemas

package/lib/Keywords.js

@@ -1,6 +1,5 @@
 import bytes from 'bytes'
 import ms from 'ms'
-import path from 'path'
 
 /**
  * Custom JSON schema keywords for AJV
@@ -8,16 +7,16 @@ import path from 'path'
 class Keywords {
   /**
    * Returns all custom keywords
-   * @param {Object} directoryReplacements Replacements for isDirectory (e.g. { '$ROOT': '/app' })
    * @returns {Object[]} Array of AJV keyword definitions
    */
-  static all(directoryReplacements = {}) {
+  static all () {
     const keywords = {
       /**
        * Parses byte string values (e.g., "1MB" -> 1048576)
        */
       isBytes: function () {
         return (value, { parentData, parentDataProperty }) => {
+          if (value === false) return false
           try {
             parentData[parentDataProperty] = bytes.parse(value)
             return true
@@ -32,6 +31,7 @@ class Keywords {
        */
       isDate: function () {
         return (value, { parentData, parentDataProperty }) => {
+          if (value === false) return false
           try {
             parentData[parentDataProperty] = new Date(value)
             return true
@@ -41,31 +41,12 @@ class Keywords {
         }
       },
 
-      /**
-       * Resolves directory path tokens ($ROOT, $DATA, $TEMP, etc.)
-       */
-      isDirectory: function () {
-        const doReplace = value => {
-          const replacements = Object.entries(directoryReplacements)
-          return replacements.reduce((m, [k, v]) => {
-            return m.startsWith(k) ? path.resolve(v, m.replace(k, '').slice(1)) : m
-          }, value)
-        }
-        return (value, { parentData, parentDataProperty }) => {
-          try {
-            parentData[parentDataProperty] = doReplace(value)
-          } catch (e) {
-            // Keep original value on error
-          }
-          return true
-        }
-      },
-
       /**
        * Parses time duration strings into milliseconds (e.g., "7d" -> 604800000)
        */
       isTimeMs: function () {
         return (value, { parentData, parentDataProperty }) => {
+          if (value === false) return false
           try {
             parentData[parentDataProperty] = ms(value)
             return true
@@ -78,8 +59,8 @@ class Keywords {
       /**
        * Marker for ObjectId fields (no transformation, just marks the field)
        */
-      isObjectId: function () {
-        return () => true
+      isObjectId: function (value) {
+        return () => value
       }
     }
 

package/lib/Schema.js

@@ -1,22 +1,11 @@
 import _ from 'lodash'
 import { EventEmitter } from 'events'
 import fs from 'fs/promises'
+import SchemaError from './SchemaError.js'
 import xss from 'xss'
 
 const BASE_SCHEMA_NAME = 'base'
 
-/**
- * Schema-specific error class
- */
-export class SchemaError extends Error {
-  constructor(code, message, data = {}) {
-    super(message)
-    this.code = code
-    this.data = data
-    this.name = 'SchemaError'
-  }
-}
-
 /**
  * Represents an individual JSON schema with validation and build capabilities
  */
@@ -29,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, validator, xssWhitelist, schemaLibrary }) {
     super()
 
     /**
@@ -115,7 +104,7 @@ class Schema extends EventEmitter {
    * Determines whether the current schema build is valid using last modification timestamp
    * @returns {Promise<boolean>}
    */
-  async isBuildValid() {
+  async isBuildValid () {
     if (!this.built) return false
 
     let schema = this
@@ -131,7 +120,7 @@ class Schema extends EventEmitter {
    * Returns the parent schema if $merge is defined (or the base schema if a root schema)
    * @returns {Promise<Schema|undefined>}
    */
-  async getParent() {
+  async getParent () {
     if (this.name === BASE_SCHEMA_NAME) return undefined
 
     const parentRef = this.raw?.$merge?.source?.$ref ?? BASE_SCHEMA_NAME
@@ -142,7 +131,7 @@ class Schema extends EventEmitter {
    * Loads the schema file
    * @returns {Promise<Schema>} This instance
    */
-  async load() {
+  async load () {
     try {
       const content = await fs.readFile(this.filePath, 'utf-8')
       this.raw = JSON.parse(content)
@@ -178,7 +167,7 @@ class Schema extends EventEmitter {
    * @param {function} options.extensionFilter Filter function for extensions
    * @returns {Promise<Schema>}
    */
-  async build(options = {}) {
+  async build (options = {}) {
     if (options.useCache !== false && this.enableCache && await this.isBuildValid()) {
       return this
     }
@@ -196,7 +185,7 @@ class Schema extends EventEmitter {
 
     while (parent) {
       const parentBuilt = _.cloneDeep((await parent.build({ ...options, compile: false })).built)
-      built = this.patch(parentBuilt, built, { strict: !parent.name == BASE_SCHEMA_NAME })
+      built = this.patch(parentBuilt, built, { strict: false })
       parent = await parent.getParent()
     }
 
@@ -237,7 +226,7 @@ class Schema extends EventEmitter {
    * @param {boolean} options.strict Require $patch or $merge
    * @returns {Object} The base schema
    */
-  patch(baseSchema, patchSchema, options = {}) {
+  patch (baseSchema, patchSchema, options = {}) {
     const opts = _.defaults(options, {
       extendAnnotations: patchSchema.$anchor !== BASE_SCHEMA_NAME,
       overwriteProperties: true,
@@ -284,7 +273,7 @@ class Schema extends EventEmitter {
    * @param {boolean} options.ignoreRequired Ignore required field errors
    * @returns {Object} The validated data
    */
-  validate(dataToValidate, options = {}) {
+  validate (dataToValidate, options = {}) {
     const opts = _.defaults(options, { useDefaults: true, ignoreRequired: false })
     const data = _.defaults(_.cloneDeep(dataToValidate), opts.useDefaults ? this.getObjectDefaults() : {})
 
@@ -322,7 +311,7 @@ class Schema extends EventEmitter {
    * @param {Object} schema Schema to use (defaults to built schema)
    * @returns {Object} The sanitised data
    */
-  sanitise(dataToSanitise, options = {}, schema) {
+  sanitise (dataToSanitise, options = {}, schema) {
     const opts = _.defaults(options, {
       isInternal: false,
       isReadOnly: false,
@@ -363,7 +352,7 @@ class Schema extends EventEmitter {
    * Adds an extension schema
    * @param {string} extSchemaName Extension schema name
    */
-  addExtension(extSchemaName) {
+  addExtension (extSchemaName) {
     if (!this.extensions.includes(extSchemaName)) {
       this.extensions.push(extSchemaName)
     }
@@ -374,7 +363,7 @@ class Schema extends EventEmitter {
    * @param {Object} schema Schema to extract defaults from
    * @returns {Object} The defaults object
    */
-  getObjectDefaults(schema) {
+  getObjectDefaults (schema) {
     schema = schema ?? this.built
     const props = schema.properties ?? schema.$merge?.with?.properties ?? schema.$patch?.with?.properties
 

package/lib/SchemaError.js

@@ -0,0 +1,13 @@
+/**
+ * Schema-specific error class
+ */
+class SchemaError extends Error {
+  constructor (code, message, data = {}) {
+    super(message)
+    this.code = code
+    this.data = data
+    this.name = 'SchemaError'
+  }
+}
+
+export default SchemaError

package/lib/Schemas.js

@@ -1,29 +1,18 @@
 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 { fileURLToPath } from 'url'
 import safeRegex from 'safe-regex'
 import Schema from './Schema.js'
-import Keywords from './Keywords.js'
+import SchemaError from './SchemaError.js'
 import XSSDefaults from './XSSDefaults.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const BASE_SCHEMA_PATH = '../schema/base.schema.json'
 
-/**
- * Schema library errors
- */
-export class SchemaError extends Error {
-  constructor(code, message, data = {}) {
-    super(message)
-    this.code = code
-    this.data = data
-    this.name = 'SchemaError'
-  }
-}
-
 /**
  * Standalone JSON Schema library for the Adapt framework
  */
@@ -35,17 +24,15 @@ class Schemas extends EventEmitter {
    * @param {Object} options.xssWhitelist Custom XSS whitelist tags/attributes
    * @param {Boolean} options.xssWhitelistOverride Replace default whitelist instead of extending
    * @param {Object} options.formatOverrides Custom string format RegExp patterns
-   * @param {Object} options.directoryReplacements Replacements for isDirectory keyword (e.g. { '$ROOT': '/app' })
    */
-  constructor(options = {}) {
+  constructor (options = {}) {
     super()
 
     this.options = _.defaults(options, {
       enableCache: true,
       xssWhitelist: {},
       xssWhitelistOverride: false,
-      formatOverrides: {},
-      directoryReplacements: {}
+      formatOverrides: {}
     })
 
     /**
@@ -82,7 +69,7 @@ class Schemas extends EventEmitter {
       removeAdditional: 'all',
       strict: false,
       verbose: true,
-      keywords: Keywords.all(this.options.directoryReplacements)
+      keywords: Keywords.all()
     })
 
     this.addStringFormats({
@@ -102,7 +89,7 @@ class Schemas extends EventEmitter {
    * Initializes the schema library by loading the base schema
    * @returns {Promise<SchemaLibrary>}
    */
-  async init() {
+  async init () {
     if (this._initialized) return this
 
     await this.resetSchemaRegistry()
@@ -115,7 +102,7 @@ class Schemas extends EventEmitter {
    * Empties the schema registry (with the exception of the base schema)
    * @returns {Promise<void>}
    */
-  async resetSchemaRegistry() {
+  async resetSchemaRegistry () {
     this.schemas = {
       base: await this.createSchema(path.resolve(__dirname, BASE_SCHEMA_PATH), { enableCache: true })
     }
@@ -126,7 +113,7 @@ class Schemas extends EventEmitter {
    * Adds string formats to the Ajv validator
    * @param {Object<string, RegExp>} formats
    */
-  addStringFormats(formats) {
+  addStringFormats (formats) {
     Object.entries(formats).forEach(([name, re]) => {
       const isUnsafe = !safeRegex(re)
       if (isUnsafe) {
@@ -139,9 +126,17 @@ class Schemas extends EventEmitter {
   /**
    * Adds a new keyword to be used in JSON schemas
    * @param {Object} definition AJV keyword definition
+   * @param {Object} options Configuration options
+   * @param {Boolean} options.override Whether an existing keyword should be overridden
    */
-  addKeyword(definition) {
+  addKeyword (definition, options = {}) {
     try {
+      if (this.validator.getKeyword(definition.keyword)) {
+        if (options.override !== true) {
+          throw new SchemaError('KEYWORD_EXISTS', 'Keyword already exists')
+        }
+        this.validator.removeKeyword(definition.keyword)
+      }
       this.validator.addKeyword(definition)
     } catch (e) {
       this.emit('warning', `Failed to define keyword '${definition.keyword}', ${e}`)
@@ -156,7 +151,7 @@ class Schemas extends EventEmitter {
    * @param {string} options.cwd Base directory for glob patterns
    * @returns {Promise<void>}
    */
-  async loadSchemas(patterns, options = {}) {
+  async loadSchemas (patterns, options = {}) {
     if (!this._initialized) {
       await this.init()
     }
@@ -196,7 +191,7 @@ class Schemas extends EventEmitter {
    * @param {boolean} options.replace Replace existing schema with same name
    * @returns {Promise<Schema>}
    */
-  async registerSchema(filePath, options = {}) {
+  async registerSchema (filePath, options = {}) {
     if (!_.isString(filePath)) {
       throw new SchemaError('INVALID_PARAMS', 'filePath must be a string', { params: ['filePath'] })
     }
@@ -229,7 +224,7 @@ class Schemas extends EventEmitter {
    * Deregisters a single JSON schema
    * @param {string} name Schema name to deregister
    */
-  deregisterSchema(name) {
+  deregisterSchema (name) {
     if (this.schemas[name]) {
       delete this.schemas[name]
     }
@@ -246,7 +241,7 @@ class Schemas extends EventEmitter {
    * @param {Object} options Options passed to Schema constructor
    * @returns {Promise<Schema>}
    */
-  async createSchema(filePath, options = {}) {
+  async createSchema (filePath, options = {}) {
     const schema = new Schema({
       enableCache: options.enableCache ?? this.options.enableCache,
       filePath,
@@ -267,7 +262,7 @@ class Schemas extends EventEmitter {
    * @param {string} baseSchemaName The name of the schema to extend
    * @param {string} extSchemaName The name of the schema to extend with
    */
-  extendSchema(baseSchemaName, extSchemaName) {
+  extendSchema (baseSchemaName, extSchemaName) {
     const baseSchema = this.schemas[baseSchemaName]
     if (baseSchema) {
       baseSchema.addExtension(extSchemaName)
@@ -290,7 +285,7 @@ class Schemas extends EventEmitter {
    * @param {function} options.extensionFilter Filter function for extensions
    * @returns {Promise<Schema>}
    */
-  async getSchema(schemaName, options = {}) {
+  async getSchema (schemaName, options = {}) {
     const schema = this.schemas[schemaName]
     if (!schema) {
       throw new SchemaError('MISSING_SCHEMA', `Schema '${schemaName}' not found`, { schemaName })
@@ -305,7 +300,7 @@ class Schemas extends EventEmitter {
    * @param {Object} options Validation options
    * @returns {Promise<Object>} The validated data with defaults applied
    */
-  async validate(schemaName, data, options = {}) {
+  async validate (schemaName, data, options = {}) {
     const schema = await this.getSchema(schemaName)
     return schema.validate(data, options)
   }
@@ -316,7 +311,7 @@ class Schemas extends EventEmitter {
    * @param {Object} options Build options
    * @returns {Promise<Object>} The built schema object
    */
-  async getBuiltSchema(schemaName, options = {}) {
+  async getBuiltSchema (schemaName, options = {}) {
     const schema = await this.getSchema(schemaName)
     return schema.built
   }
@@ -326,7 +321,7 @@ class Schemas extends EventEmitter {
    * @param {string} schemaName The schema name
    * @returns {Promise<Object>} The defaults object
    */
-  async getSchemaDefaults(schemaName) {
+  async getSchemaDefaults (schemaName) {
     const schema = await this.getSchema(schemaName)
     return schema.getObjectDefaults()
   }
@@ -336,7 +331,7 @@ class Schemas extends EventEmitter {
    * @param {string} schemaName Schema name (defaults to 'course')
    * @returns {Promise<Object>} The _globals defaults
    */
-  async getGlobalsDefaults(schemaName = 'course') {
+  async getGlobalsDefaults (schemaName = 'course') {
     const schema = await this.getSchema(schemaName)
     const defaults = schema.getObjectDefaults()
     return defaults._globals || {}
@@ -346,7 +341,7 @@ class Schemas extends EventEmitter {
    * Returns list of all registered schema names
    * @returns {string[]}
    */
-  getSchemaNames() {
+  getSchemaNames () {
     return Object.keys(this.schemas)
   }
 
@@ -354,7 +349,7 @@ class Schemas extends EventEmitter {
    * Returns information about all registered schemas
    * @returns {Object}
    */
-  getSchemaInfo() {
+  getSchemaInfo () {
     return Object.entries(this.schemas).reduce((info, [name, schema]) => {
       info[name] = {
         filePath: schema.filePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-schemas",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Standalone JSON Schema library for the Adapt framework",
   "type": "module",
   "main": "index.js",
@@ -8,6 +8,7 @@
     ".": "./index.js",
     "./Schemas": "./lib/Schemas.js",
     "./Schema": "./lib/Schema.js",
+    "./SchemaError": "./lib/SchemaError.js",
     "./Keywords": "./lib/Keywords.js",
     "./XSSDefaults": "./lib/XSSDefaults.js"
   },
@@ -29,5 +30,30 @@
     "ms": "^2.1.3",
     "safe-regex": "^2.1.1",
     "xss": "^1.0.14"
+  },
+  "devDependencies": {
+    "@semantic-release/git": "^10.0.1",
+    "conventional-changelog-eslint": "^6.0.0",
+    "semantic-release": "^25.0.3",
+    "standard": "^17.1.2"
+  },
+  "release": {
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "eslint"
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "eslint"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
   }
 }

package/test.js

@@ -9,7 +9,7 @@ import fs from 'fs/promises'
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const hasSpecifiedPath = Boolean(process.argv[2])
 
-async function setupTestSchemas() {
+async function setupTestSchemas () {
   if (hasSpecifiedPath) return
   // Create test schema directory
   const testSchemaDir = path.join(__dirname, 'test-schemas')
@@ -17,51 +17,51 @@ async function setupTestSchemas() {
 
   // Create a course schema with _globals
   const courseSchema = {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$anchor": "course",
-    "$merge": {
-      "source": { "$ref": "base" },
-      "with": {
-        "properties": {
-          "title": {
-            "type": "string",
-            "description": "Course title",
-            "default": "Untitled Course"
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'course',
+    $merge: {
+      source: { $ref: 'base' },
+      with: {
+        properties: {
+          title: {
+            type: 'string',
+            description: 'Course title',
+            default: 'Untitled Course'
           },
-          "description": {
-            "type": "string",
-            "description": "Course description",
-            "default": ""
+          description: {
+            type: 'string',
+            description: 'Course description',
+            default: ''
           },
-          "_globals": {
-            "type": "object",
-            "description": "Global settings",
-            "properties": {
-              "_accessibility": {
-                "type": "object",
-                "properties": {
-                  "_isEnabled": {
-                    "type": "boolean",
-                    "default": true
+          _globals: {
+            type: 'object',
+            description: 'Global settings',
+            properties: {
+              _accessibility: {
+                type: 'object',
+                properties: {
+                  _isEnabled: {
+                    type: 'boolean',
+                    default: true
                   },
-                  "skipNavigationText": {
-                    "type": "string",
-                    "default": "Skip navigation"
+                  skipNavigationText: {
+                    type: 'string',
+                    default: 'Skip navigation'
                   }
                 },
-                "required": [
-                  "skipNavigationText"
+                required: [
+                  'skipNavigationText'
                 ]
               },
-              "_extensions": {
-                "type": "object",
-                "properties": {
-                  "_trickle": {
-                    "type": "object",
-                    "properties": {
-                      "incompleteContent": {
-                        "type": "string",
-                        "default": "There is incomplete content above"
+              _extensions: {
+                type: 'object',
+                properties: {
+                  _trickle: {
+                    type: 'object',
+                    properties: {
+                      incompleteContent: {
+                        type: 'string',
+                        default: 'There is incomplete content above'
                       }
                     }
                   }
@@ -70,31 +70,31 @@ async function setupTestSchemas() {
             }
           }
         },
-        "required": ["title"]
+        required: ['title']
       }
     }
   }
 
   // Create a content schema
   const contentSchema = {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$anchor": "content",
-    "$merge": {
-      "source": { "$ref": "base" },
-      "with": {
-        "properties": {
-          "_type": {
-            "type": "string",
-            "description": "Content type"
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'content',
+    $merge: {
+      source: { $ref: 'base' },
+      with: {
+        properties: {
+          _type: {
+            type: 'string',
+            description: 'Content type'
           },
-          "body": {
-            "type": "string",
-            "description": "Content body",
-            "default": ""
+          body: {
+            type: 'string',
+            description: 'Content body',
+            default: ''
           },
-          "_isOptional": {
-            "type": "boolean",
-            "default": false
+          _isOptional: {
+            type: 'boolean',
+            default: false
           }
         }
       }
@@ -103,39 +103,39 @@ async function setupTestSchemas() {
 
   // Create a component schema that extends content
   const componentSchema = {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$anchor": "component",
-    "$merge": {
-      "source": { "$ref": "content" },
-      "with": {
-        "properties": {
-          "_component": {
-            "type": "string",
-            "description": "Component type"
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'component',
+    $merge: {
+      source: { $ref: 'content' },
+      with: {
+        properties: {
+          _component: {
+            type: 'string',
+            description: 'Component type'
           }
         },
-        "required": ["_component"]
+        required: ['_component']
       }
     }
   }
 
   // Create a patch schema that extends course
   const coursePatchSchema = {
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$anchor": "course-extension",
-    "$patch": {
-      "source": { "$ref": "course" },
-      "with": {
-        "properties": {
-          "_globals": {
-            "type": "object",
-            "properties": {
-              "_myPlugin": {
-                "type": "object",
-                "properties": {
-                  "buttonLabel": {
-                    "type": "string",
-                    "default": "Click me"
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $anchor: 'course-extension',
+    $patch: {
+      source: { $ref: 'course' },
+      with: {
+        properties: {
+          _globals: {
+            type: 'object',
+            properties: {
+              _myPlugin: {
+                type: 'object',
+                properties: {
+                  buttonLabel: {
+                    type: 'string',
+                    default: 'Click me'
                   }
                 }
               }
@@ -166,10 +166,10 @@ async function setupTestSchemas() {
   return testSchemaDir
 }
 
-async function runTests() {
+async function runTests () {
   console.log('=== Adapt Schema Library Tests ===\n')
 
-  const testSchemaDir =  hasSpecifiedPath
+  const testSchemaDir = hasSpecifiedPath
     ? path.join(__dirname, process.argv[2])
     : await setupTestSchemas()
 
@@ -177,10 +177,7 @@ async function runTests() {
     // Test 1: Initialize library
     console.log('Test 1: Initialize library')
     const library = new Schemas({
-      enableCache: true,
-      directoryReplacements: {
-        '$ROOT': process.cwd()
-      }
+      enableCache: true
     })
     await library.init()
     console.log('  ✓ Library initialized\n')
@@ -202,12 +199,12 @@ async function runTests() {
     // 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')
+    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')
+    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')
@@ -234,7 +231,7 @@ async function runTests() {
     console.log('Test 7b: Type validation error')
     try {
       await library.validate('course', {
-        title: 12345  // Should be string, not number
+        title: 12345 // Should be string, not number
       })
       console.log('  ✗ Should have thrown validation error\n')
     } catch (e) {
@@ -267,22 +264,22 @@ async function runTests() {
     // Create another test schema to trigger the event
     const newSchemaPath = path.join(testSchemaDir, 'test-event.schema.json')
     await fs.writeFile(newSchemaPath, JSON.stringify({
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "$anchor": "test-event",
-      "$merge": {
-        "source": { "$ref": "base" },
-        "with": { "properties": { "test": { "type": "string" } } }
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      $anchor: 'test-event',
+      $merge: {
+        source: { $ref: 'base' },
+        with: { properties: { test: { type: 'string' } } }
       }
     }))
     await library.registerSchema(newSchemaPath)
     console.log('')
 
     console.log('=== All tests passed! ===')
-
   } finally {
-    if (hasSpecifiedPath) return
-    // Cleanup
-    await fs.rm(testSchemaDir, { recursive: true, force: true })
+    if (!hasSpecifiedPath) {
+      // Cleanup
+      await fs.rm(testSchemaDir, { recursive: true, force: true })
+    }
   }
 }