adapt-authoring-jsonschema 1.1.4 → 1.2.0

package/lib/JsonSchemaModule.js

@@ -1,16 +1,12 @@
-import _ from 'lodash'
-import { AbstractModule, Hook } from 'adapt-authoring-core'
-import Ajv from 'ajv/dist/2020.js'
+import { AbstractModule, App, Hook } from 'adapt-authoring-core'
 import { glob } from 'glob'
-import JsonSchema from './JsonSchema.js'
-import Keywords from './Keywords.js'
 import path from 'path'
-import safeRegex from 'safe-regex'
-import XSSDefaults from './XSSDefaults.js'
+import { Schemas, SchemaError, XSSDefaults } from 'adapt-schemas'
 
-const BASE_SCHEMA_PATH = './schema/base.schema.json'
 /**
- * Module which add support for the JSON Schema specification
+ * Module which adds support for the JSON Schema specification.
+ * This is a thin wrapper around the adapt-schemas library providing
+ * Adapt framework integration (hooks, logging, config, errors).
  * @memberof jsonschema
  * @extends {AbstractModule}
  */
@@ -18,99 +14,141 @@ class JsonSchemaModule extends AbstractModule {
   /** @override */
   async init () {
     this.app.jsonschema = this
-    /**
-     * Reference to all registed schemas
-     * @type {Object}
-     */
-    this.schemas = {}
-    /**
-     * Temporary store of extension schemas
-     * @type {Object}
-     */
-    this.schemaExtensions = {}
     /**
      * Invoked when schemas are registered
      * @type {Hook}
      */
     this.registerSchemasHook = new Hook()
     /**
-     * Tags and attributes to be whitelisted by the XSS filter
-     * @type {Object}
-     */
-    this.xssWhitelist = {}
-    /**
-     * Reference to the Ajv instance
-     * @type {external:Ajv}
+     * Internal schema library instance
+     * @type {Schemas}
      */
-    this.validator = new Ajv({
-      addUsedSchema: false,
-      allErrors: true,
-      allowUnionTypes: true,
-      loadSchema: this.getSchema.bind(this),
-      removeAdditional: 'all',
-      strict: false,
-      verbose: true,
-      keywords: Keywords.all
+    this._library = new Schemas({
+      enableCache: true // Will be overridden from config when ready
     })
-    this.addStringFormats({
-      'date-time': /[A-za-z0-9:+()]+/,
-      time: /^(\d{2}):(\d{2}):(\d{2})\+(\d{2}):(\d{2})$/,
-      uri: /^(.+):\/\/(www\.)?[-a-zA-Z0-9@:%_+.~#?&//=]{1,256}/
+    // Forward library events to module logging
+    this._library.on('warning', msg => this.log('warn', msg))
+    this._library.on('schemaRegistered', (name, filePath) => this.log('verbose', 'REGISTER_SCHEMA', name, filePath))
+    this._library.on('schemaDeregistered', name => this.log('debug', 'DEREGISTER_SCHEMA', name))
+    this._library.on('schemaExtended', (base, ext) => this.log('verbose', 'EXTEND_SCHEMA', base, ext))
+    this._library.on('reset', () => this.log('debug', 'RESET_SCHEMAS'))
+
+    await this._library.init()
+
+    this._library.addKeyword({
+      keyword: 'isDirectory',
+      type: 'string',
+      modifying: true,
+      schemaType: 'boolean',
+      compile: function () {
+        const doReplace = value => {
+          const app = App.instance
+          return [
+            ['$ROOT', app.rootDir],
+            ['$DATA', app.getConfig('dataDir')],
+            ['$TEMP', app.getConfig('tempDir')]
+          ].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) {}
+          return true
+        }
+      }
     })
-    await this.resetSchemaRegistry()
 
     this.onReady()
       .then(() => this.app.waitForModule('config', 'errors'))
       .then(() => {
-        Object.assign(this.xssWhitelist,
+        // Update library options from config
+        this._library.options.enableCache = this.getConfig('enableCache')
+
+        // Update XSS whitelist
+        Object.assign(
+          this._library.xssWhitelist,
           this.getConfig('xssWhitelistOverride') ? {} : XSSDefaults,
-          this.getConfig('xssWhitelist'))
+          this.getConfig('xssWhitelist')
+        )
       })
-      .then(() => this.addStringFormats(this.getConfig('formatOverrides')))
-      .then(() => this.registerSchemas({ quiet: true })) // note: supress logging here as other schemas will likely be added
+      .then(() => {
+        // Add format overrides from config
+        const formatOverrides = this.getConfig('formatOverrides')
+        if (formatOverrides) {
+          this._library.addStringFormats(formatOverrides)
+        }
+      })
+      .then(() => this.registerSchemas({ quiet: true }))
       .catch(e => this.log('error', e))
 
     this.app.onReady()
       .then(() => this.logSchemas())
   }
 
+  /**
+   * Reference to all registered schemas
+   * @type {Object}
+   */
+  get schemas () {
+    return this._library.schemas
+  }
+
+  /**
+   * Temporary store of extension schemas
+   * @type {Object}
+   */
+  get schemaExtensions () {
+    return this._library.schemaExtensions
+  }
+
+  /**
+   * Tags and attributes to be whitelisted by the XSS filter
+   * @type {Object}
+   */
+  get xssWhitelist () {
+    return this._library.xssWhitelist
+  }
+
+  /**
+   * Reference to the Ajv instance
+   * @type {external:Ajv}
+   */
+  get validator () {
+    return this._library.validator
+  }
+
   /**
    * Empties the schema registry (with the exception of the base schema)
    */
   async resetSchemaRegistry () {
-    this.log('debug', 'RESET_SCHEMAS')
-    this.schemas = {
-      base: await this.createSchema(path.resolve(this.rootDir, BASE_SCHEMA_PATH), { enableCache: true })
-    }
+    await this._library.resetSchemaRegistry()
   }
 
   /**
    * Adds string formats to the Ajv validator
+   * @param {Object} formats Object mapping format names to RegExp patterns
    */
   addStringFormats (formats) {
-    Object.entries(formats).forEach(([name, re]) => {
-      const isUnsafe = !safeRegex(re)
-      if (isUnsafe) this.log('warn', `unsafe RegExp for format '${name}' (${re}), using default`)
-      this.validator.addFormat(name, isUnsafe ? /.*/ : re)
-    })
+    this._library.addStringFormats(formats)
   }
 
   /**
    * Adds a new keyword to be used in JSON schemas
-   * @param {AjvKeyword} definition
+   * @param {Object} definition AJV keyword definition
+   * @param {Object} options Configuration options
+   * @param {Boolean} options.override Whether to override an existing definition
    */
-  addKeyword (definition) {
-    try {
-      this.validator.addKeyword(definition)
-    } catch (e) {
-      this.log('warn', `failed to define keyword '${definition.keyword}', ${e}`)
-    }
+  addKeyword (definition, options) {
+    this._library.addKeyword(definition, options)
   }
 
   /**
-   * Searches all Adapt dependencies for any local JSON schemas and registers them for use in the app. Schemas must be located in in a `/schema` folder, and be named appropriately: `*.schema.json`.
-   * @param options {object}
-   * @param options.quiet {Boolean} Set to true to suppress logs
+   * Searches all Adapt dependencies for any local JSON schemas and registers them for use in the app.
+   * Schemas must be located in a `/schema` folder, and be named appropriately: `*.schema.json`.
+   * @param {Object} options
+   * @param {Boolean} options.quiet Set to true to suppress logs
    * @return {Promise}
    */
   async registerSchemas (options = {}) {
@@ -118,7 +156,8 @@ class JsonSchemaModule extends AbstractModule {
     await Promise.all(Object.values(this.app.dependencies).map(async d => {
       if (d.name === this.name) return
       const files = await glob('schema/*.schema.json', { cwd: d.rootDir, absolute: true })
-      ;(await Promise.allSettled(files.map(f => this.registerSchema(f))))
+      const results = await Promise.allSettled(files.map(f => this.registerSchema(f)))
+      results
         .filter(r => r.status === 'rejected')
         .forEach(r => this.log('warn', r.reason))
     }))
@@ -129,57 +168,44 @@ class JsonSchemaModule extends AbstractModule {
   /**
    * Registers a single JSON schema for use in the app
    * @param {String} filePath Path to the schema file
-   * @param {RegisterSchemaOptions} options Extra options
-   * @return {Promise}
+   * @param {Object} options Extra options
+   * @param {Boolean} options.replace Replace existing schema with same name
+   * @return {Promise<Schema>}
    */
   async registerSchema (filePath, options = {}) {
-    if (!_.isString(filePath)) {
-      throw this.app.errors.INVALID_PARAMS.setData({ params: ['filePath'] })
-    }
-    const schema = await this.createSchema(filePath, options)
-
-    if (this.schemas[schema.name]) {
-      if (options.replace) this.deregisterSchema(schema.name)
-      else throw this.app.errors.SCHEMA_EXISTS.setData({ schemaName: schema.name, filePath })
+    try {
+      return await this._library.registerSchema(filePath, options)
+    } catch (e) {
+      // Convert library errors to app errors
+      if (e instanceof SchemaError) {
+        const appError = this.app.errors[e.code]
+        if (appError) {
+          throw appError.setData(e.data)
+        }
+      }
+      throw e
     }
-    this.schemas[schema.name] = schema
-    this.schemaExtensions?.[schema.name]?.forEach(s => schema.addExtension(s))
-    if (schema.raw.$patch) this.extendSchema(schema.raw.$patch?.source?.$ref, schema.name)
-
-    this.log('verbose', 'REGISTER_SCHEMA', schema.name, filePath)
   }
 
   /**
-   * deregisters a single JSON schema
-   * @param {String} name Schem name to deregister
-   * @return {Promise} Resolves with schema data
+   * Deregisters a single JSON schema
+   * @param {String} name Schema name to deregister
    */
   deregisterSchema (name) {
-    if (this.schemas[name]) delete this.schemas[name]
-    // remove schema from any extensions lists
-    Object.entries(this.schemaExtensions).forEach(([base, extensions]) => {
-      this.schemaExtensions[base] = extensions.filter(s => s !== name)
-    })
-    this.log('debug', 'DEREGISTER_SCHEMA', name)
+    this._library.deregisterSchema(name)
   }
 
   /**
-   * Creates a new JsonSchema instance
+   * Creates a new Schema instance
    * @param {String} filePath Path to the schema file
-   * @param {Object} options Options passed to JsonSchema constructor
-   * @returns {JsonSchema}
+   * @param {Object} options Options passed to Schema constructor
+   * @returns {Promise<Schema>}
    */
-  createSchema (filePath, options) {
-    const schema = new JsonSchema({
+  createSchema (filePath, options = {}) {
+    return this._library.createSchema(filePath, {
       enableCache: this.getConfig('enableCache'),
-      filePath,
-      validator: this.validator,
-      xssWhitelist: this.xssWhitelist,
       ...options
     })
-    this.schemaExtensions?.[schema.name]?.forEach(s => schema.addExtension(s))
-    delete this.schemaExtensions?.[schema.name]
-    return schema.load()
   }
 
   /**
@@ -188,27 +214,26 @@ class JsonSchemaModule extends AbstractModule {
    * @param {String} extSchemaName The name of the schema to extend with
    */
   extendSchema (baseSchemaName, extSchemaName) {
-    const baseSchema = this.schemas[baseSchemaName]
-    if (baseSchema) {
-      baseSchema.addExtension(extSchemaName)
-    } else {
-      if (!this.schemaExtensions[baseSchemaName]) this.schemaExtensions[baseSchemaName] = []
-      this.schemaExtensions[baseSchemaName].push(extSchemaName)
-    }
-    this.log('verbose', 'EXTEND_SCHEMA', baseSchemaName, extSchemaName)
+    this._library.extendSchema(baseSchemaName, extSchemaName)
   }
 
   /**
-   * Retrieves the specified schema. Recursively applies any schema merge/patch schemas. Will returned cached data if enabled.
+   * Retrieves the specified schema. Recursively applies any schema merge/patch schemas.
+   * Will return cached data if enabled.
    * @param {String} schemaName The name of the schema to return
-   * @param {LoadSchemaOptions} options
+   * @param {Object} options
    * @param {Boolean} options.compiled If false, the raw schema will be returned
-   * @return {Promise} The compiled schema validation function (default) or the raw schema
+   * @return {Promise<Schema>} The schema instance
    */
   async getSchema (schemaName, options = {}) {
-    const schema = this.schemas[schemaName]
-    if (!schema) throw this.app.errors.MISSING_SCHEMA.setData({ schemaName })
-    return schema.build(options)
+    try {
+      return await this._library.getSchema(schemaName, options)
+    } catch (e) {
+      if (e instanceof SchemaError && e.code === 'MISSING_SCHEMA') {
+        throw this.app.errors.MISSING_SCHEMA.setData({ schemaName })
+      }
+      throw e
+    }
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-jsonschema",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Module to add support for the JSON schema specification",
   "homepage": "https://github.com/adapt-security/adapt-authoring-jsonschema",
   "license": "GPL-3.0",
@@ -11,26 +11,15 @@
   },
   "repository": "github:adapt-security/adapt-authoring-jsonschema",
   "dependencies": {
-    "ajv": "^8.12.0",
-    "bytes": "^3.1.2",
-    "glob": "^13.0.0",
-    "lodash": "^4.17.21",
-    "ms": "^2.1.3",
-    "safe-regex": "2.1.1",
-    "xss": "^1.0.14"
+    "adapt-schemas": "^1.0.0"
   },
   "peerDependencies": {
     "adapt-authoring-core": "github:adapt-security/adapt-authoring-core"
   },
   "devDependencies": {
-    "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
-    "@semantic-release/npm": "^13.1.2",
-    "@semantic-release/release-notes-generator": "^14.1.0",
     "conventional-changelog-eslint": "^6.0.0",
     "semantic-release": "^25.0.2",
-    "semantic-release-replace-plugin": "^1.2.7",
     "standard": "^17.1.0"
   },
   "release": {
@@ -49,15 +38,7 @@
       ],
       "@semantic-release/npm",
       "@semantic-release/github",
-      [
-        "@semantic-release/git",
-        {
-          "assets": [
-            "package.json"
-          ],
-          "message": "Chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-        }
-      ]
+      "@semantic-release/git"
     ]
   }
 }

package/lib/JsonSchema.js

@@ -1,273 +0,0 @@
-import _ from 'lodash'
-import { App, Hook } from 'adapt-authoring-core'
-import fs from 'fs/promises'
-import xss from 'xss'
-
-/** @ignore */ const BASE_SCHEMA_NAME = 'base'
-
-/**
- * Functionality related to JSON schema
- * @memberof jsonschema
- */
-class JsonSchema {
-  constructor ({ enableCache, filePath, validator, xssWhitelist }) {
-    /**
-     * The raw built JSON schema
-     * @type {Object}
-     */
-    this.built = undefined
-    /**
-     * The compiled schema validation function
-     * @type {function}
-     */
-    this.compiled = undefined
-    /**
-     * Whether caching is enabled for this schema
-     * @type {Boolean}
-     */
-    this.enableCache = enableCache
-    /**
-     * List of extensions for this schema
-     * @type {Array<String>}
-     */
-    this.extensions = []
-    /**
-     * File path to the schema
-     * @type {String}
-     */
-    this.filePath = filePath
-    /**
-     * Whether the schema is currently building
-     * @type {Boolean}
-     */
-    this.isBuilding = false
-    /**
-     * The last build time (in milliseconds)
-     * @type {Number}
-     */
-    this.lastBuildTime = undefined
-    /**
-     * The raw schema data for this schema (with no inheritance/extensions)
-     * @type {Object}
-     */
-    this.raw = undefined
-    /**
-     * Reference to the Ajv validator instance
-     * @type {external:Ajv}
-     */
-    this.validator = validator
-    /**
-     * Reference to the local XSS sanitiser instance
-     * @type {Object}
-     */
-    this.xss = new xss.FilterXSS({ whiteList: xssWhitelist })
-    /**
-     * Hook which invokes every time the schema is built
-     * @type {Hook}
-     */
-    this.buildHook = new Hook()
-  }
-
-  /**
-   * Determines whether the current schema build is valid using last modification timestamp
-   * @returns {Boolean}
-   */
-  async isBuildValid () {
-    if (!this.built) return false
-    let schema = this
-    while (schema) {
-      const { mtimeMs } = await fs.stat(schema.filePath)
-      if (mtimeMs > this.lastBuildTime) return false
-      schema = await schema.getParent()
-    }
-    return true
-  }
-
-  /**
-   * Returs the parent schema if $merge is defined (or the base schema if a root schema)
-   * @returns {JsonSchema}
-   */
-  async getParent () {
-    if (this.name === BASE_SCHEMA_NAME) return // base schema always the root
-    const jsonschema = await App.instance.waitForModule('jsonschema')
-    return await jsonschema.getSchema(this.raw?.$merge?.source?.$ref ?? BASE_SCHEMA_NAME)
-  }
-
-  /**
-   * Loads the schema file
-   * @returns {JsonSchema} This instance
-   */
-  async load () {
-    try {
-      this.raw = JSON.parse((await fs.readFile(this.filePath)).toString())
-      this.name = this.raw.$anchor
-    } catch (e) {
-      throw App.instance.errors?.SCHEMA_LOAD_FAILED?.setData({ schemaName: this.filePath }) ?? e
-    }
-    if (this.validator.validateSchema(this.raw)?.errors) {
-      const errors = this.validator.errors.map(e => e.instancePath ? `${e.instancePath} ${e.message}` : e.message)
-      if (errors.length) {
-        throw App.instance.errors.INVALID_SCHEMA
-          .setData({ schemaName: this.name, errors: errors.join(', ') })
-      }
-    }
-    return this
-  }
-
-  /**
-   * Builds and compiles the schema from the $merge and $patch schemas
-   * @param {LoadSchemaOptions}
-   * @return {JsonSchema}
-   */
-  async build (options = {}) {
-    if (options.useCache !== false && this.enableCache && await this.isBuildValid()) {
-      return this
-    }
-    if (this.isBuilding) {
-      return new Promise(resolve => this.buildHook.tap(() => resolve(this)))
-    }
-    this.isBuilding = true
-
-    const jsonschema = await App.instance.waitForModule('jsonschema')
-    const { applyExtensions, extensionFilter } = options
-
-    let built = _.cloneDeep(this.raw)
-    let parent = await this.getParent()
-
-    while (parent) {
-      const parentBuilt = _.cloneDeep((await parent.build({ ...options, compile: false })).built)
-      built = await this.patch(parentBuilt, built, { strict: !parent.name === BASE_SCHEMA_NAME })
-      parent = await parent.getParent()
-    }
-    if (this.extensions.length) {
-      await Promise.all(this.extensions.map(async s => {
-        const applyPatch = typeof extensionFilter === 'function' ? extensionFilter(s) : applyExtensions !== false
-        if (applyPatch) {
-          const extSchema = await jsonschema.getSchema(s)
-          this.patch(built, extSchema.raw, { extendAnnotations: false })
-        }
-      }))
-    }
-    this.built = built
-    if (options.compile !== false) { // don't compile when option present (e.g. when running build recursively)
-      this.compiled = await this.validator.compileAsync(built)
-    }
-    this.isBuilding = false
-    this.lastBuildTime = Date.now()
-
-    this.buildHook.invoke(this)
-    return this
-  }
-
-  /**
-   * Applies a patch schema to another schema
-   * @param {Object} baseSchema The base schema to apply the patch
-   * @param {Object} patchSchema The patch schema to apply to the base
-   * @param {ApplyPatchOptions} options
-   * @return {Object} The base schema
-   */
-  patch (baseSchema, patchSchema, options = {}) {
-    const opts = _.defaults(options, {
-      extendAnnotations: patchSchema.$anchor !== BASE_SCHEMA_NAME,
-      overwriteProperties: true,
-      strict: true
-    })
-    const patchData = patchSchema.$patch?.with ?? patchSchema.$merge?.with ?? (!opts.strict && patchSchema)
-    if (!patchData) {
-      throw App.instance.errors.INVALID_SCHEMA.setData({ schemaName: patchSchema.$anchor })
-    }
-    if (opts.extendAnnotations) {
-      ['$anchor', 'title', 'description'].forEach(p => {
-        if (patchSchema[p]) baseSchema[p] = patchSchema[p]
-      })
-    }
-    if (patchData.properties) {
-      const mergeFunc = opts.overwriteProperties ? _.merge : _.defaultsDeep
-      mergeFunc(baseSchema.properties, patchData.properties)
-    }
-    ['allOf', 'anyOf', 'oneOf'].forEach(p => {
-      if (patchData[p]?.length) baseSchema[p] = (baseSchema[p] ?? []).concat(_.cloneDeep(patchData[p]))
-    })
-    if (patchData.required) {
-      baseSchema.required = _.uniq([...(baseSchema.required ?? []), ...patchData.required])
-    }
-    return baseSchema
-  }
-
-  /**
-   * Checks passed data against the specified schema (if it exists)
-   * @param {Object} dataToValidate The data to be validated
-   * @param {SchemaValidateOptions} options
-   * @return {Object} The validated data
-   */
-  validate (dataToValidate, options) {
-    const opts = _.defaults(options, { useDefaults: true, ignoreRequired: false })
-    const data = _.defaults(_.cloneDeep(dataToValidate), opts.useDefaults ? this.getObjectDefaults() : {})
-    if (!this.compiled) { // fallback in the case that the compiled function is missing
-      this.log('warn', 'NO_COMPILED_FUNC', this.name)
-      this.validator.compile(this.built)
-    }
-    this.compiled(data)
-
-    const errors = this.compiled.errors && this.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}, `, '')
-
-    if (errors?.length) { throw App.instance.errors.VALIDATION_FAILED.setData({ schemaName: this.name, errors, data }) }
-
-    return data
-  }
-
-  /**
-   * Sanitises data by removing attributes according to the context (provided by options)
-   * @param {Object} dataToValidate The data to be sanitised
-   * @param {SchemaSanitiseOptions} options
-   * @return {Object} The sanitised data
-   */
-  sanitise (dataToSanitise, options = {}, schema) {
-    const opts = _.defaults(options, { isInternal: false, isReadOnly: false, sanitiseHtml: true, strict: true })
-    schema = schema ?? this.built
-    const sanitised = {}
-    for (const prop in schema.properties) {
-      const schemaData = schema.properties[prop]
-      const value = dataToSanitise[prop]
-      const ignore = (opts.isInternal && schemaData.isInternal) || (opts.isReadOnly && schemaData.isReadOnly)
-      if (value === undefined || (ignore && !opts.strict)) {
-        continue
-      }
-      if (ignore && opts.strict) {
-        throw App.instance.errors.MODIFY_PROTECTED_ATTR.setData({ attribute: prop, value })
-      }
-      sanitised[prop] =
-        schemaData.type === 'object' && schemaData.properties
-          ? this.sanitise(value, opts, schemaData)
-          : schemaData.type === 'string' && opts.sanitiseHtml
-            ? this.xss.process(value)
-            : value
-    }
-    return sanitised
-  }
-
-  /**
-   * Adds an extension schema
-   * @param {String} extSchemaName
-   */
-  addExtension (extSchemaName) {
-    !this.extensions.includes(extSchemaName) && this.extensions.push(extSchemaName)
-  }
-
-  /**
-   * Returns all schema defaults as a correctly structured object
-   * @param {Object} schema
-   * @param {Object} memo For recursion
-   * @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 => s.type === 'object' && s.properties ? this.getObjectDefaults(s) : s.default)
-  }
-}
-
-export default JsonSchema

package/lib/Keywords.js

@@ -1,74 +0,0 @@
-import { App } from 'adapt-authoring-core'
-import bytes from 'bytes'
-import ms from 'ms'
-import path from 'path'
-/**
- * Adds some useful schema keywords
- * @memberof jsonschema
- * @extends {AbstractModule}
- */
-class Keywords {
-  static get all () {
-    const keywords = {
-      isBytes: function () {
-        return (value, { parentData, parentDataProperty }) => {
-          try {
-            parentData[parentDataProperty] = bytes.parse(value)
-            return true
-          } catch (e) {
-            return false
-          }
-        }
-      },
-      isDate: function () {
-        return (value, { parentData, parentDataProperty }) => {
-          try {
-            parentData[parentDataProperty] = new Date(value)
-            return true
-          } catch (e) {
-            return false
-          }
-        }
-      },
-      isDirectory: function () {
-        const doReplace = value => {
-          const app = App.instance
-          return [
-            ['$ROOT', app.rootDir],
-            ['$DATA', app.getConfig('dataDir')],
-            ['$TEMP', app.getConfig('tempDir')]
-          ].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) {}
-          return true
-        }
-      },
-      isTimeMs: function () {
-        return (value, { parentData, parentDataProperty }) => {
-          try {
-            parentData[parentDataProperty] = ms(value)
-            return true
-          } catch (e) {
-            return false
-          }
-        }
-      }
-    }
-    return Object.entries(keywords).map(([keyword, compile]) => {
-      return {
-        keyword,
-        type: 'string',
-        modifying: true,
-        schemaType: 'boolean',
-        compile
-      }
-    })
-  }
-}
-
-export default Keywords

package/lib/XSSDefaults.js

@@ -1,142 +0,0 @@
-export default {
-  a: ['class', 'href', 'rel', 'target', 'title'],
-  abbr: ['title'],
-  address: [],
-  area: ['alt', 'coords', 'href', 'shape'],
-  article: [],
-  aside: ['aria-hidden', 'class', 'role'],
-  audio: [
-    'autoplay',
-    'controls',
-    'crossorigin',
-    'loop',
-    'muted',
-    'preload',
-    'src'
-  ],
-  b: [],
-  bdi: ['dir'],
-  bdo: ['dir'],
-  big: [],
-  blockquote: ['cite'],
-  br: [],
-  button: ['class'],
-  caption: [],
-  center: [],
-  cite: [],
-  code: [],
-  col: ['align', 'span', 'valign', 'width'],
-  colgroup: ['align', 'span', 'valign', 'width'],
-  data: [],
-  dd: [],
-  del: ['datetime'],
-  dfn: [],
-  details: ['open'],
-  div: [
-    'aria-describedby',
-    'aria-description',
-    'aria-label',
-    'aria-hidden',
-    'class',
-    'role',
-    'tabindex'
-  ],
-  dl: [],
-  dt: [],
-  em: [],
-  figcaption: [],
-  figure: ['class'],
-  font: ['color', 'face', 'size'],
-  footer: [],
-  h1: ['class'],
-  h2: ['class'],
-  h3: ['class'],
-  h4: ['class'],
-  h5: ['class'],
-  h6: ['class'],
-  header: [],
-  hr: [],
-  i: [],
-  img: [
-    'alt',
-    'aria-hidden',
-    'aria-label',
-    'class',
-    'height',
-    'loading',
-    'src',
-    'title',
-    'width'
-  ],
-  ins: ['datetime'],
-  kbd: [],
-  li: ['class'],
-  mark: [],
-  math: [],
-  mfrac: [],
-  mi: [],
-  mn: [],
-  mo: [],
-  mover: [],
-  mrow: [],
-  ms: [],
-  mspace: [],
-  msub: [],
-  msubsup: [],
-  msup: [],
-  mtext: [],
-  munder: [],
-  munderover: [],
-  nav: [],
-  ol: ['class'],
-  p: ['lang'],
-  pre: [],
-  q: [],
-  rp: [],
-  rt: [],
-  ruby: [],
-  s: [],
-  samp: [],
-  section: [],
-  small: [],
-  span: [
-    'aria-describedby',
-    'aria-description',
-    'aria-label',
-    'aria-hidden',
-    'class',
-    'role',
-    'tabindex'
-  ],
-  sub: [],
-  summary: [],
-  sup: [],
-  strong: [],
-  strike: [],
-  table: ['align', 'border', 'width', 'valign'],
-  tbody: ['align', 'valign'],
-  td: ['align', 'colspan', 'rowspan', 'valign', 'width'],
-  tfoot: ['align', 'valign'],
-  th: ['align', 'colspan', 'rowspan', 'valign', 'width'],
-  thead: ['align', 'valign'],
-  time: [],
-  tr: ['align', 'rowspan', 'valign'],
-  tt: [],
-  u: [],
-  ul: ['class'],
-  var: [],
-  video: [
-    'autoplay',
-    'controls',
-    'crossorigin',
-    'loop',
-    'muted',
-    'playsinline',
-    'poster',
-    'preload',
-    'src',
-    'height',
-    'width'
-  ],
-  wbr: []
-}

package/schema/base.schema.json

@@ -1,13 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$anchor": "base",
-  "description": "The base schema inherited by all other schemas",
-  "type": "object",
-  "properties": {
-    "_id": {
-      "description": "Unique identifier",
-      "type": "string",
-      "isObjectId": true
-    }
-  }
-}