budibase/packages/core/test/memory.js

import { isUndefined, has } from "lodash"
import { take } from "lodash/fp"
import { Readable, Writable } from "readable-stream"
import { Buffer } from "safe-buffer"
import { splitKey, joinKey, $, keySep, getFileFromKey } from "../src/common"
import { getLastPartInKey } from "../src/templateApi/hierarchy"

const folderMarker = "OH-YES-ITSA-FOLDER-"
const isFolder = val => {
  if (isUndefined(val)) {
    throw new Error("Passed undefined value for folder")
  }
  return val.includes(folderMarker)
}

const getParentFolderKey = key =>
  $(key, [splitKey, take(splitKey(key).length - 1), joinKey])

const getParentFolder = (data, key) => {
  if (key === keySep) return null
  const parentKey = getParentFolderKey(key)
  if (parentKey === keySep) return null
  if (data[parentKey] === undefined)
    throw new Error(
      "Parent folder for " + key + " does not exist (" + parentKey + ")"
    )
  return JSON.parse(data[parentKey])
}

const addItemToParentFolder = (data, path) => {
  if (getParentFolderKey(path) === "/") return
  const parentFolder = getParentFolder(data, path)
  parentFolder.items.push(getLastPartInKey(path))
  data[getParentFolderKey(path)] = JSON.stringify(parentFolder)
}

export const createFile = data => async (path, content) => {
  if (await exists(data)(path)) {
    throw new Error(path + " already exists")
  }
  addItemToParentFolder(data, path)
  data[path] = content
}
export const updateFile = data => async (path, content) => {
  // putting this check in to force use of create
  if (!(await exists(data)(path))) {
    throw new Error("cannot update " + path + " - does not exist")
  }
  data[path] = content
}

export const writableFileStream = data => async path => {
  //if(!await exists(data)(path)) throw new Error("cannot write stream to " + path + " - does not exist");
  if (!getParentFolder(data, path)) {
    throw new Error("Parent folder for " + path + " does not exist")
  }

  const stream = Writable()
  stream._write = (chunk, encoding, done) => {
    data[path] = data[path] === undefined ? [] : data[path]
    data[path] = [...data[path], ...chunk]
    done()
  }

  addItemToParentFolder(data, path)

  return stream
}

export const readableFileStream = data => async path => {
  if (!(await exists(data)(path)))
    throw new Error("cannot read stream from " + path + " - does not exist")
  const s = new Readable()
  s._read = () => {
    s.push(Buffer.from(data[path]))
    s.push(null)
  }
  return s
}

export const getFileSize = data => async path => {
  if (!(await exists(data)(path)))
    throw new Error("cannot get size of " + path + " - does not exist")
  return data[path].length
}

export const renameFile = data => async (oldKey, newKey) => {
  if (!(await exists(data)(oldKey)))
    throw new Error("cannot rename path: " + oldKey + " ... does not exist")
  if (await exists(data)(newKey))
    throw new Error("cannot rename path: " + newKey + " ... already exists")
  data[newKey] = data[oldKey]
  delete data[oldKey]

  const parent = getParentFolder(data, newKey)
  const oldFileName = getFileFromKey(oldKey)
  const newFileName = getFileFromKey(newKey)
  parent.items = [...parent.items.filter(i => i !== oldFileName), newFileName]
  data[getParentFolderKey(newKey)] = JSON.stringify(parent)
}

export const loadFile = data => async path => {
  const result = data[path]
  if (isUndefined(result)) {
    throw new Error("Load failed - path " + path + " does not exist")
  }
  return result
}
export const exists = data => async path => has(data, path)
export const deleteFile = data => async path => {
  if (!(await exists(data)(path)))
    throw new Error("Cannot delete file, path " + path + " does not exist")
  if (isFolder(data[path]))
    throw new Error("DeleteFile: Path " + path + " is a folder, not a file")
  const parentFolder = getParentFolder(data, path)
  parentFolder.items = parentFolder.items.filter(
    i => i !== getLastPartInKey(path)
  )
  data[getParentFolderKey(path)] = JSON.stringify(parentFolder)
  delete data[path]
}
export const createFolder = data => async path => {
  if (await exists(data)(path))
    throw new Error("Cannot create folder, path " + path + " already exists")
  addItemToParentFolder(data, path)
  data[path] = JSON.stringify({ folderMarker, items: [] })
}
export const deleteFolder = data => async path => {
  if (!(await exists(data)(path)))
    throw new Error("Cannot delete folder, path " + path + " does not exist")
  if (!isFolder(data[path]))
    throw new Error("DeleteFolder: Path " + path + " is not a folder")

  for (let item of JSON.parse(data[path]).items) {
    const fullItemPath = `${path}/${item}`
    if (isFolder(data[fullItemPath])) {
      await deleteFolder(data)(fullItemPath)
    } else {
      await deleteFile(data)(fullItemPath)
    }
  }

  const parent = getParentFolder(data, path)
  if (parent) {
    parent.items = parent.items.filter(f => f !== getLastPartInKey(path))
    data[getParentFolderKey(path)] = JSON.stringify(parent)
  }

  delete data[path]
}

export const getFolderContents = data => async folderPath => {
  if (!(await exists(data)(folderPath)))
    throw new Error("Folder does not exist: " + folderPath)
  if (!isFolder(data[folderPath]))
    throw new Error("Not a folder: " + folderPath)
  return JSON.parse(data[folderPath]).items
}

export default data => {
  return {
    createFile: createFile(data),
    updateFile: updateFile(data),
    loadFile: loadFile(data),
    exists: exists(data),
    deleteFile: deleteFile(data),
    createFolder: createFolder(data),
    deleteFolder: deleteFolder(data),
    readableFileStream: readableFileStream(data),
    writableFileStream: writableFileStream(data),
    renameFile: renameFile(data),
    getFolderContents: getFolderContents(data),
    getFileSize: getFileSize(data),
    datastoreType: "memory",
    datastoreDescription: "",
    data,
  }
}