adaptorex/plugins/data/data.js

Connect all your live interactive storytelling devices and software

/**
 * Organize access to adaptor:ex data collections
 *
 * data is a core plugin and will be included with every game
 *
 * @requires plugin
 * @requires file
 *
 * @module data/data
 * @copyright Lasse Marburg 2022
 * @license MIT
 */

const plugin = require("../plugin.js")
var schema = require("./schema.json")
const file = require("../../file.js")
const path = require("path")

/** @typedef {import('../../types').AdaptorAction} Action */

/**
 * install request API for all custom collections the game contains
 */
class Data extends plugin.Plugin {
  constructor() {
    super(schema)
    this.name = "data"
    this.core = true
    this.collection_apis = []
  }

  /**
   * create request API for each custom database
   *
   * collect files in file directory and watch for changes.
   */
  setup(config, game) {
    return new Promise((resolve, reject) => {
      super
        .setup(config, game)
        .then((result) => {
          this.addTemplate("addItem", (payload, action) => {
            const title = `data ${action.name}`
            let subtitle = `Add new ${payload.collection} Item`
            const body = []

            if (payload.reference) {
              subtitle += ` as ${payload.reference}`
            }

            if (payload.variables) {
              body.push({ text: JSON.stringify(payload.variables) })
            }

            return { title, subtitle, body }
          })

          this.addTemplate("getItem", (payload, action) => {
            const title = `data ${action.name}`
            let subtitle = `Get Item from ${payload.collection} as '${payload.reference}'`
            if (payload.multiple && payload.limit != 1) {
              subtitle = `Get Item(s) from ${payload.collection} as '${payload.reference}'`
            }

            const body = [{ text: payload.query }]

            if (payload.sort && payload.sort.length) {
              let txt = ""
              for (let s of payload.sort) {
                if (s.direction == 1) {
                  txt += ` ${s.by} ⬆️`
                } else {
                  txt += ` ${s.by} ⬇️`
                }
              }
              body.push({ text: `sort by:${txt}` })
            }

            if (payload.limit && payload.limit > 1 && payload.multiple) {
              body.push({ text: `limit to ${payload.limit} Items` })
            }

            if (payload.skip) {
              if (payload.skip == 1) {
                body.push({ text: `skip first Item` })
              } else {
                body.push({ text: `skip first ${payload.skip} Items` })
              }
            }

            return { title, subtitle, body }
          })

          log.debug(this.name, "load assets filenames from " + this.game.files)

          this.collectFiles(this.game.files)

          file.watchDir(this.game.files, (e, file) => {
            this.collectFiles(this.game.files)
            log.debug(this.name, "change in file directory: " + e + " " + file)
            this.schemaUpdate(this.schema)
          })

          for (let coll of this.game.setup.collections) {
            this.schema.definitions.collection.enum.push(coll)
            this.schema.definitions.collection.options.enum_titles.push(coll)
            this.schema.definitions.data_collection.enum.push(coll)
          }

          this.game.status.on("collection_added", (data) => {
            let updt = false
            if (
              !this.schema.definitions.collection.enum.includes(data.collection)
            ) {
              this.schema.definitions.collection.enum.push(data.collection)
              if (data.plugin) {
                this.schema.definitions.collection.options.enum_titles.push(
                  data.plugin + " " + data.name
                )
              } else {
                this.schema.definitions.collection.options.enum_titles.push(
                  data.name
                )
              }
              updt = true
            }
            if (
              data.type == "data" &&
              !this.schema.definitions.data_collection.enum.includes(
                data.collection
              )
            ) {
              this.schema.definitions.data_collection.enum.push(data.collection)
              updt = true
            }
            if (updt) {
              this.schemaUpdate(this.schema)
            }
          })

          return resolve(this.schema)
        })
        .catch((err) => {
          return reject(err)
        })
    })
  }

  /**
   * Collects all file paths from a directory and stores them in the data schema definitions under `files.anyOf[1].enum`.
   *
   * Clears the existing file enum array in the schema, walks through the specified directory to gather file paths, and then populates the enum array with those paths.
   *
   * @param {string} dir - The base directory to collect file paths from. All file paths will be relative to this directory.
   * @returns {string[]} - The updated `enum` array containing the relative file paths.
   *
   * @example
   * const fileList = this.collectFiles('./my-directory');
   * log.info(fileList);
   * // Output: ['file1.png', 'sub-dir/file2.mp3']
   */
  collectFiles(dir) {
    this.schema.definitions.files.anyOf[1].enum = []
    this.walkDirectory(dir, dir)
    return this.schema.definitions.files.anyOf[1].enum
  }

  /**
   * Recursively walks through a directory and returns a list of relative file paths in Unix-style format.
   *
   * @param {string} dir - The current directory being processed (absolute or relative path).
   * @param {string} baseDir - The base directory from which all file paths should be relative.
   */
  walkDirectory(dir, baseDir) {
    const files = file.ls(dir)

    files.forEach((f) => {
      const filePath = path.posix.join(dir, f)

      if (file.isDir(filePath)) {
        return this.walkDirectory(filePath, baseDir)
      }

      this.schema.definitions.files.anyOf[1].enum.push(
        path.posix.relative(baseDir, filePath)
      )
    })
  }

  /**
   * @type {Action}
   *
   * Call database update on an item
   */
  async update(data, session) {
    await session.variables.update(data.item, data.update, {
      multiple: data.multiple || false
    })
  }

  /**
   * @type {Action}
   *
   * Set value of variable
   */
  async set(data, session) {
    await session.variables.set(data.variable, data.value, {
      multiple: data.multiple || false
    })
  }

  /**
   * @type {Action}
   *
   * Increase numeric value of variable
   */
  async increase(data, session) {
    await session.variables.edit("inc", data.variable, data.value, {
      multiple: data.multiple || false
    })
  }

  /**
   * @type {Action}
   *
   * Add element to variable list
   */
  async push(data, session) {
    if (data.duplicates) {
      await session.variables.push(data.variable, data.value, {
        multiple: data.multiple || false
      })
    } else {
      await session.variables.add(data.variable, data.value, {
        multiple: data.multiple || false
      })
    }
  }

  /**
   * @type {Action}
   *
   * Remove Element from variable list
   */
  async pull(data, session) {
    await session.variables.pull(data.variable, data.value, {
      multiple: data.multiple || false
    })
  }

  /**
   * @type {Action}
   *
   * Create a new Item in one of the existing data collections
   */
  async addItem(data, session) {
    await session.variables.create(
      data.collection,
      data.variables,
      data.reference
    )
  }

  /**
   * @type {Action}
   *
   * Remove variable from item document or delete the whole document.
   */
  async delete(data, session) {
    await session.variables.delete(data.variable, {
      multiple: data.multiple || false
    })
  }

  /**
   * @type {Action}
   *
   * create new reference to current session in an external document.
   *
   * document can than be accessed during session via name reference.
   */
  async getItem(data, session) {
    if (!adaptor.hasOwnProperties(data, ["collection", "query", "reference"])) {
      throw new adaptor.InvalidError(
        "can not load reference. collection, query or reference property missing."
      )
    }

    let options = { multiple: data.multiple }
    if (data.sort && data.sort.length) {
      options.sort = {}
      for (let s of data.sort) {
        options.sort[s.by] = s.direction
      }
    }
    if (data.limit) {
      options.limit = parseInt(data.limit)
    }
    if (data.skip) {
      options.skip = parseInt(data.skip)
    }

    await session.createReference(
      data["collection"],
      data.query,
      data["reference"],
      options
    )

    session.log(`create ${data.collection} reference "${data.reference}"`)
  }
}

module.exports.Plugin = Data