adapt-octopus 0.1.1

package/.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*]
+indent_style = tab
+tab_width = 2

package/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/.eslintrc.json

@@ -0,0 +1,13 @@
+{
+  "env": {
+      "browser": false,
+      "node": true,
+      "commonjs": false
+  },
+  "extends": [
+      "standard"
+  ],
+  "parserOptions": {
+      "ecmaVersion": 2022
+  }
+}

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/README.md

@@ -0,0 +1,49 @@
+# 🐙 adapt-octopus
+
+Utility for converting old Adapt schema from the non-conformant `properties.schema` style into the new conformant JSON schema format.
+
+## Command-line
+
+The utility can be used directly from a command line. See below for details.
+
+### Installation
+
+Note: requires [Node.js](http://nodejs.org) to be installed.
+
+From the command line, run:
+
+```console
+npm install -g adapt-security/adapt-octopus
+```
+
+## Usage
+
+To convert a single schema, simply run the following:
+```console
+adapt-octopus <inputPath> <id>
+```
+* ID should match the value of the _component/extension/menu/theme_ attribute in a plugin’s bower.json.
+
+To convert all schemas in a framework source repository, run:
+```console
+adapt-octopus <inputPath>
+```
+
+## Programmatic
+
+The utility also exports a Node.js API for use programatically. 
+
+```js
+import octopus from 'adapt-security/adapt-octopus'
+// to run for a single schema, use the following (returns a promise)
+octopus.run(options);
+// to run for multiple schemas, use the following (returns a promise)
+octopus.runRecursive(options);
+```
+
+### Options
+The following options can be passed to the run functions:
+- **cwd**: the current working directory (used when searching and writing files)
+- **inputPath**: _required when calling `run`_ should be the path to the input schema
+- **inputId**: _required when calling `run`_ the type of the schema being converted (accepted values: `component`, `extension`, `menu`, `theme`)
+- **logger**: an instance to a logger to be used when logging status messages (must export a `log` function)

package/bin/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import path from 'path'
+import Octopus from '../lib/Octopus.js'
+
+async function run () {
+  const opts = { cwd: path.resolve(process.argv[2]), inputId: process.argv[3] }
+  process.argv.length === 4
+    ? await Octopus.run(opts)
+    : await Octopus.runRecursive(opts)
+}
+
+run()

package/lib/Octopus.js

@@ -0,0 +1,117 @@
+import { EOL } from 'os'
+import fs from 'fs/promises'
+import path from 'path'
+import SchemaNode from './SchemaNode.js'
+
+export default class Octopus {
+  static async run (opts) {
+    await new Octopus(opts).start()
+  }
+
+  static async runRecursive (opts) {
+    const _recurse = async pluginDir => {
+      const hasNewSchemas = (await fs.readdir(path.join(pluginDir, 'schema'))).some(f => f.endsWith('.schema.json'))
+      if(hasNewSchemas && opts.force !== true) {
+        return
+      }
+      const bowerJson = JSON.parse(await fs.readFile(path.join(pluginDir, 'bower.json')))
+      const inputId = bowerJson.component || bowerJson.extension || bowerJson.menu || bowerJson.theme
+      const octopus = new Octopus({ ...opts, cwd: pluginDir, inputId })
+      await octopus.start()
+    }
+    const { name } = JSON.parse(await fs.readFile(path.join(opts.cwd, 'package.json')))
+    if (name !== 'adapt_framework') {
+      return await _recurse(opts.cwd)
+    }
+    await Promise.all(['components', 'extensions', 'menu', 'theme'].map(async f => {
+      try {
+        const dir = path.join(opts.cwd, 'src', f)
+        const contents = await fs.readdir(dir)
+        return await Promise.all(contents.map(async c => _recurse(path.join(dir, c))))
+      } catch (e) {}
+    }))
+  }
+
+  logger
+  inputPath
+  outputPath
+  inputId
+  inputSchema
+  outputSchema
+
+  constructor ({ inputPath = 'properties.schema', inputId, cwd, logger = console }) {
+    this.cwd = cwd || path.basename(inputPath)
+    this.inputPath = path.resolve(cwd, inputPath)
+    this.inputId = inputId
+    this.logger = logger
+  }
+
+  async start () {
+    if (!this.inputPath) throw (new Error('No input path specified'))
+    if (!this.inputId) throw (new Error('No ID specified'))
+
+    this.inputSchema = JSON.parse(await fs.readFile(this.inputPath, 'utf8'))
+    await this.convert()
+  }
+
+  async convert () {
+    const properties = this.inputSchema.properties
+    if (this.inputSchema.$ref === 'http://localhost/plugins/content/component/model.schema') {
+      await this.construct('course', {})
+      await this.construct('component')
+      return
+    }
+    if (this.inputSchema.$ref === 'http://localhost/plugins/content/theme/model.schema') {
+      await this.construct('theme', { properties: properties.variables })
+    }
+    if (properties?.pluginLocations) return await this.iterateLocations()
+    await this.construct(path.basename(this.inputPath, '.model.schema'))
+  }
+
+  async iterateLocations () {
+    const locations = this.inputSchema.properties.pluginLocations.properties
+
+    for (const location of Object.entries(locations)) {
+      await this.construct(...location)
+    }
+
+    // ensure any globals are converted
+    if (!Object.keys(locations).includes('course')) {
+      await this.construct('course', {})
+    }
+  }
+
+  async construct (type, schema = this.inputSchema) {
+    const properties = schema.properties
+
+    if (type !== 'course' || !(schema.globals || (schema.globals = this.inputSchema.globals))) {
+      if (!properties || !Object.keys(properties).length) return
+      delete schema.globals
+    }
+
+    this.outputSchema = new SchemaNode({
+      nodeType: 'root',
+      schemaType: type,
+      inputId: this.inputId,
+      inputSchema: schema,
+      logger: this.logger
+    })
+
+    this.outputPath = path.resolve(this.cwd, `schema/${type}.schema.json`)
+    await this.write()
+  }
+
+  async write () {
+    try {
+      return await fs.readFile(this.outputPath)
+      // return this.logger.log(`JSON schema already exists at ${this.outputPath}, exiting`);
+    } catch (e) {
+      // carry on
+    }
+    const json = JSON.stringify(this.outputSchema, null, 2) + EOL
+
+    await fs.mkdir(path.dirname(this.outputPath), { recursive: true })
+    await fs.writeFile(this.outputPath, json)
+    this.logger.log(`converted JSON schema written to ${this.outputPath}`)
+  }
+}

package/lib/SchemaNode.js

@@ -0,0 +1,328 @@
+import stripObject from '../utils/stripObject.js'
+
+export default class SchemaNode {
+  inputId
+  inputSchema
+
+  constructor (options) {
+    this.inputId = options.inputId
+    this.inputSchema = options.inputSchema
+    this.logger = options.logger
+
+    switch (options.nodeType) {
+      case 'root': {
+        const type = options.schemaType
+        const isCore = type === this.inputId
+        const isComponent = type === 'component'
+        const isExtension = (!isCore || type !== 'config') && type !== 'theme'
+
+        let schemaInner = {
+          required: this.getRequiredFields(),
+          properties: this.getProperties()
+        }
+
+        if (isExtension) {
+          schemaInner = {
+            [isCore || isComponent ? '$merge' : '$patch']: {
+              source: { $ref: isCore ? 'content' : type },
+              with: schemaInner
+            }
+          }
+        }
+        return {
+          $anchor: isCore ? type : `${this.inputId}-${type}`,
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          ...schemaInner
+        }
+      }
+      case 'properties':
+        return {
+          type: this.inputSchema.type,
+          isObjectId: this.getIsObjectId(),
+          title: this.getTitle(options.key),
+          description: this.getDescription(),
+          default: this.getDefault(),
+          enum: this.getEnumeratedValues(),
+          required: this.getRequiredFields(),
+          items: this.getItems(),
+          properties: this.getProperties(),
+          _adapt: this.getAdaptOptions(),
+          _backboneForms: this.getBackboneFormsOptions(),
+          _unrecognisedFields: this.getUnrecognisedFields()
+        }
+      case 'items':{
+        const properties = this.getItemsProperties()
+
+        return {
+          type: properties ? this.getType() : 'object',
+          isObjectId: this.getIsObjectId(),
+          properties
+        }
+      }
+    }
+  }
+
+  getItemsProperties () {
+    const originalItems = this.inputSchema.properties
+
+    if (!originalItems) return
+
+    return Object.entries(originalItems).reduce((a, [key, inputSchema]) => {
+      a[key] = new SchemaNode({ nodeType: 'properties', key, inputSchema, logger: this.logger })
+
+      return a
+    }, {})
+  }
+
+  getProperties () {
+    const originalProperties = this.inputSchema.properties
+    const originalGlobals = this.inputSchema.globals
+
+    if (!originalProperties && !originalGlobals) return
+
+    const globals = {}
+    const properties = {}
+
+    if (originalGlobals) {
+      for (const [key, inputSchema] of Object.entries(originalGlobals)) {
+        globals[key] = new SchemaNode({
+          nodeType: 'properties',
+          key,
+          inputSchema,
+          logger: this.logger
+        })
+      }
+
+      properties._globals = {
+        type: 'object',
+        default: {},
+        properties: {
+          [`_${this.inputId}`]: {
+            type: 'object',
+            default: {},
+            properties: globals
+          }
+        }
+      }
+    }
+
+    if (originalProperties) {
+      for (const [key, inputSchema] of Object.entries(originalProperties)) {
+        properties[key] = new SchemaNode({
+          nodeType: 'properties',
+          key,
+          inputSchema,
+          logger: this.logger
+        })
+      }
+    }
+
+    return properties
+  }
+
+  getType () {
+    const type = this.inputSchema.type
+
+    return type === 'objectid' ? 'string' : type
+  }
+
+  getTitle (key) {
+    const { title, legend } = this.inputSchema
+
+    if (title) return title
+    if (legend) return legend
+    if (key === 'pluginLocations') return
+
+    key = key.replace(/_/g, '').replace(/[A-Z]/g, ' $&').toLowerCase()
+
+    return key.charAt(0).toUpperCase() + key.slice(1)
+  }
+
+  getDescription () {
+    const help = this.inputSchema.help
+
+    if (help) return help
+  }
+
+  getDefault () {
+    if (this.getIsObjectId()) return
+
+    const originalDefault = this.inputSchema.default
+
+    if (originalDefault !== undefined) return originalDefault
+    if (this.inputSchema.required || this.inputSchema.validators?.includes('required')) return
+
+    switch (this.inputSchema.type) {
+      case 'string':
+        return ''
+      case 'number':
+        return 0
+      case 'object':
+        return {}
+      case 'array':
+        if (!this.inputSchema.items) return []
+        break
+      case 'boolean':
+        return false
+    }
+  }
+
+  getEnumeratedValues () {
+    const { originalEnum, inputType } = this.inputSchema
+
+    if (originalEnum) return originalEnum
+    if (inputType?.type === 'Select') return inputType.options
+  }
+
+  getRequiredFields () {
+    const properties = this.inputSchema.properties
+
+    if (!properties) return
+
+    const requiredFields = Object.entries(properties).reduce((a, [key, value]) => {
+      if ((value.required === true || value.validators?.includes('required')) && value?.default === undefined) a.push(key)
+
+      return a
+    }, [])
+
+    if (!requiredFields.length) return
+
+    return requiredFields
+  }
+
+  getItems () {
+    const items = this.inputSchema.items
+
+    if (items) return new SchemaNode({ nodeType: 'items', inputSchema: items, logger: this.logger })
+  }
+
+  getIsObjectId () {
+    const inputType = this.inputSchema.inputType
+    const isAsset = (inputType?.type || inputType)?.startsWith('Asset')
+
+    if (isAsset || this.inputSchema.type === 'objectid') return true
+  }
+
+  getAdaptOptions () {
+    return stripObject({
+      editorOnly: this.inputSchema.editorOnly,
+      isSetting: this.inputSchema.isSetting,
+      translatable: this.inputSchema.translatable
+    })
+  }
+
+  getBackboneFormsOptions () {
+    const inputType = this.inputSchema.inputType
+
+    const getEditor = () => {
+      const type = this.inputSchema.type
+
+      const recognisedTypes = [
+        'string',
+        'number',
+        'object',
+        'array',
+        'boolean',
+        'objectid'
+      ]
+
+      const editor = options.type || inputType
+
+      if (!recognisedTypes.includes(type)) {
+        this.logger.log(`Unrecognised type => ${type}`)
+      }
+
+      if (editor === 'QuestionButton' ||
+        (type === 'string' && editor === 'Text') ||
+        (type === 'number' && editor === 'Number') ||
+        (type === 'boolean' && editor === 'Checkbox')) {
+        return
+      }
+
+      return editor
+    }
+
+    const getValidators = () => {
+      let validators = this.inputSchema.validators
+
+      if (!validators) return
+
+      validators = this.inputSchema.validators.filter(validator => {
+        return validator === 'number'
+          ? inputType !== 'Number'
+          : validator !== 'required'
+      })
+
+      if (!validators.length) return
+
+      return validators
+    }
+
+    let options = typeof inputType === 'object' ? inputType : {}
+
+    Object.assign(options, {
+      type: getEditor(),
+      titleHTML: this.inputSchema.titleHTML,
+      validators: getValidators(),
+      editorClass: this.inputSchema.editorClass,
+      editorAttrs: this.inputSchema.editorAttrs,
+      fieldClass: this.inputSchema.fieldClass,
+      fieldAttrs: this.inputSchema.fieldAttrs,
+      confirmDelete: this.inputSchema.confirmDelete
+    })
+
+    const splitTypes = options.type?.split(':')
+
+    switch (splitTypes?.length > 1 && splitTypes[0]) {
+      case 'Asset':
+        options.type = { type: 'Asset', media: splitTypes[1] }
+        break
+      case 'CodeEditor':
+        options.type = { type: 'CodeEditor', mode: splitTypes[1] }
+    }
+
+    if (options.type === 'Select') delete options.options
+
+    options = stripObject(options)
+
+    return (options && Object.keys(options).length === 1 && options.type) || options
+  }
+
+  getUnrecognisedFields () {
+    const recognisedKeys = [
+      'confirmDelete',
+      'default',
+      'description',
+      'editorAttrs',
+      'editorClass',
+      'editorOnly',
+      'enum',
+      'fieldAttrs',
+      'fieldClass',
+      'help',
+      'inputType',
+      'items',
+      'isSetting',
+      'legend',
+      'properties',
+      'required',
+      'title',
+      'titleHTML',
+      'translatable',
+      'type',
+      'validators'
+    ]
+
+    const unrecognisedFields = {}
+
+    for (const [key, value] of Object.entries(this.inputSchema)) {
+      if (recognisedKeys.includes(key)) continue
+
+      this.logger.log(`Unrecognised field => "${key}": ${JSON.stringify(value)}`)
+      unrecognisedFields[key] = value
+    }
+
+    return stripObject(unrecognisedFields)
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "adapt-octopus",
+  "version": "0.1.1",
+  "description": "Convert old Adapt schema into conformant JSON schema",
+  "type": "module",
+  "main": "./lib/Octopus.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tomgreenfield/adapt-octopus.git"
+  },
+  "license": "GPL-3.0",
+  "bugs": {
+    "url": "https://github.com/tomgreenfield/adapt-octopus/issues"
+  },
+  "homepage": "https://github.com/tomgreenfield/adapt-octopus#readme",
+  "bin": "./bin/cli.js",
+  "devDependencies": {
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.6.0"
+  }
+}

package/utils/stripObject.js

@@ -0,0 +1,5 @@
+export default function stripObject (object) {
+  Object.keys(object).forEach(i => object[i] === undefined && delete object[i])
+
+  if (Object.keys(object).length) return object
+};