@budibase/server 2.2.12-alpha.5 → 2.2.13

package/src/automations/tests/executeScript.spec.js

@@ -1,48 +0,0 @@
-const setup = require("./utilities")
-
-describe("test the execute script action", () => {
-    let config = setup.getConfig()
-
-    beforeEach(async () => {
-        await config.init()
-    })
-    afterAll(setup.afterAll)
-
-    it("should be able to execute a script", async () => {
-
-        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
-            inputs = {
-                code: "return 1 + 1"
-            }
-
-        )
-        expect(res.value).toEqual(2)
-        expect(res.success).toEqual(true)
-    })
-
-    it("should handle a null value", async () => {
-
-        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
-            inputs = {
-                code: null
-            }
-
-
-        )
-        expect(res.response.message).toEqual("Invalid inputs")
-        expect(res.success).toEqual(false)
-    })
-
-    it("should be able to handle an error gracefully", async () => {
-
-        let res = await setup.runStep(setup.actions.EXECUTE_SCRIPT.stepId,
-            inputs = {
-                code: "return something.map(x => x.name)"
-            }
-
-        )
-        expect(res.response).toEqual("ReferenceError: something is not defined")
-        expect(res.success).toEqual(false)
-    })
-
-})

package/src/automations/tests/sendSmtpEmail.spec.js

@@ -1,71 +0,0 @@
-
-function generateResponse(to, from) {
-    return {
-        "success": true,
-        "response": {
-            "accepted": [
-                to
-            ],
-            "envelope": {
-                "from": from,
-                "to": [
-                    to
-                ]
-            },
-            "message": `Email sent to ${to}.`
-        }
-
-    }
-}
-
-const mockFetch = jest.fn(() => ({
-    headers: {
-        raw: () => {
-            return { "content-type": ["application/json"] }
-        },
-        get: () => ["application/json"],
-    },
-    json: jest.fn(() => response),
-    status: 200,
-    text: jest.fn(),
-}))
-jest.mock("node-fetch", () => mockFetch)
-const setup = require("./utilities")
-
-
-describe("test the outgoing webhook action", () => {
-    let inputs
-    let config = setup.getConfig()
-    beforeEach(async () => {
-        await config.init()
-    })
-
-    afterAll(setup.afterAll)
-
-    it("should be able to run the action", async () => {
-        inputs = {
-            to: "user1@test.com",
-            from: "admin@test.com",
-            subject: "hello",
-            contents: "testing",
-        }
-        let resp = generateResponse(inputs.to, inputs.from)
-        mockFetch.mockImplementationOnce(() => ({
-            headers: {
-                raw: () => {
-                    return { "content-type": ["application/json"] }
-                },
-                get: () => ["application/json"],
-            },
-            json: jest.fn(() => resp),
-            status: 200,
-            text: jest.fn(),
-        }))
-        const res = await setup.runStep(setup.actions.SEND_EMAIL_SMTP.stepId, inputs)
-        expect(res.response).toEqual(resp)
-        expect(res.success).toEqual(true)
-
-    })
-
-
-})

package/src/automations/tests/serverLog.spec.js

@@ -1,22 +0,0 @@
-const setup = require("./utilities")
-
-describe("test the server log action", () => {
-    let config = setup.getConfig()
-
-    beforeEach(async () => {
-        await config.init()
-        inputs = {
-            text: "log message",
-        }
-    })
-    afterAll(setup.afterAll)
-
-    it("should be able to log the text", async () => {
-
-        let res = await setup.runStep(setup.actions.SERVER_LOG.stepId,
-            inputs
-        )
-        expect(res.message).toEqual(`App ${config.getAppId()} - ${inputs.text}`)
-        expect(res.success).toEqual(true)
-    })
-})

package/src/automations/tests/zapier.spec.js

@@ -1,27 +0,0 @@
-const setup = require("./utilities")
-const fetch = require("node-fetch")
-
-jest.mock("node-fetch")
-
-describe("test the outgoing webhook action", () => {
-    let inputs
-    let config = setup.getConfig()
-
-    beforeEach(async () => {
-        await config.init()
-        inputs = {
-            value1: "test",
-            url: "http://www.test.com",
-        }
-    })
-
-    afterAll(setup.afterAll)
-
-    it("should be able to run the action", async () => {
-        const res = await setup.runStep(setup.actions.zapier.stepId, inputs)
-        expect(res.response.url).toEqual("http://www.test.com")
-        expect(res.response.method).toEqual("post")
-        expect(res.success).toEqual(true)
-    })
-
-})

package/src/automations/unitTests/automationUtils.spec.ts

@@ -1,65 +0,0 @@
-const automationUtils = require("../automationUtils")
-
-describe("automationUtils", () => {
-  describe("substituteLoopStep", () => {
-    it("should allow multiple loop binding substitutes", () => {
-      expect(
-        automationUtils.substituteLoopStep(
-          `{{ loop.currentItem._id }} {{ loop.currentItem._id }} {{ loop.currentItem._id }}`,
-          "step.2"
-        )
-      ).toBe(
-        `{{ step.2.currentItem._id }} {{ step.2.currentItem._id }} {{ step.2.currentItem._id }}`
-      )
-    })
-
-    it("should handle not subsituting outside of curly braces", () => {
-      expect(
-        automationUtils.substituteLoopStep(
-          `loop {{ loop.currentItem._id }}loop loop{{ loop.currentItem._id }}loop`,
-          "step.2"
-        )
-      ).toBe(
-        `loop {{ step.2.currentItem._id }}loop loop{{ step.2.currentItem._id }}loop`
-      )
-    })
-  })
-
-  describe("typeCastForLooping", () => {
-    it("should parse to correct type", () => {
-      expect(
-        automationUtils.typecastForLooping(
-          { inputs: { option: "Array" } },
-          { binding: [1, 2, 3] }
-        )
-      ).toEqual([1, 2, 3])
-      expect(
-        automationUtils.typecastForLooping(
-          { inputs: { option: "Array" } },
-          { binding: "[1, 2, 3]" }
-        )
-      ).toEqual([1, 2, 3])
-      expect(
-        automationUtils.typecastForLooping(
-          { inputs: { option: "String" } },
-          { binding: [1, 2, 3] }
-        )
-      ).toEqual("1,2,3")
-    })
-    it("should handle null values", () => {
-      // expect it to handle where the binding is null
-      expect(
-        automationUtils.typecastForLooping(
-          { inputs: { option: "Array" } },
-          { binding: null }
-        )
-      ).toEqual(null)
-      expect(() =>
-        automationUtils.typecastForLooping(
-          { inputs: { option: "Array" } },
-          { binding: "test" }
-        )
-      ).toThrow()
-    })
-  })
-})

package/src/utilities/fileSystem/app.ts

@@ -1,86 +0,0 @@
-import { budibaseTempDir } from "../budibaseDir"
-import fs from "fs"
-import { join } from "path"
-import { ObjectStoreBuckets } from "../../constants"
-import { updateClientLibrary } from "./clientLibrary"
-import env from "../../environment"
-import { objectStore, context } from "@budibase/backend-core"
-import { TOP_LEVEL_PATH } from "./filesystem"
-
-export const NODE_MODULES_PATH = join(TOP_LEVEL_PATH, "node_modules")
-
-/**
- * Uploads the latest client library to the object store.
- * @param {string} appId The ID of the app which is being created.
- * @return {Promise<void>} once promise completes app resources should be ready in object store.
- */
-export const createApp = async (appId: string) => {
-  await updateClientLibrary(appId)
-}
-
-/**
- * Removes all of the assets created for an app in the object store.
- * @param {string} appId The ID of the app which is being deleted.
- * @return {Promise<void>} once promise completes the app resources will be removed from object store.
- */
-export const deleteApp = async (appId: string) => {
-  await objectStore.deleteFolder(ObjectStoreBuckets.APPS, `${appId}/`)
-}
-
-/**
- * Retrieves component libraries from object store (or tmp symlink if in local)
- */
-export const getComponentLibraryManifest = async (library: string) => {
-  const appId = context.getAppId()
-  const filename = "manifest.json"
-  /* istanbul ignore next */
-  // when testing in cypress and so on we need to get the package
-  // as the environment may not be fully fleshed out for dev or prod
-  if (env.isTest()) {
-    library = library.replace("standard-components", "client")
-    const lib = library.split("/")[1]
-    const path = require.resolve(library).split(lib)[0]
-    return require(join(path, lib, filename))
-  } else if (env.isDev()) {
-    const path = join(NODE_MODULES_PATH, "@budibase", "client", filename)
-    // always load from new so that updates are refreshed
-    delete require.cache[require.resolve(path)]
-    return require(path)
-  }
-
-  if (!appId) {
-    throw new Error("No app ID found - cannot get component libraries")
-  }
-
-  let resp
-  let path
-  try {
-    // Try to load the manifest from the new file location
-    path = join(appId, filename)
-    resp = await objectStore.retrieve(ObjectStoreBuckets.APPS, path)
-  } catch (error) {
-    console.error(
-      `component-manifest-objectstore=failed appId=${appId} path=${path}`,
-      error
-    )
-    // Fallback to loading it from the old location for old apps
-    path = join(appId, "node_modules", library, "package", filename)
-    resp = await objectStore.retrieve(ObjectStoreBuckets.APPS, path)
-  }
-  if (typeof resp !== "string") {
-    resp = resp.toString("utf8")
-  }
-  return JSON.parse(resp)
-}
-
-/**
- * Given a set of app IDs makes sure file system is cleared of any of their temp info.
- */
-export const cleanup = (appIds: string[]) => {
-  for (let appId of appIds) {
-    const path = join(budibaseTempDir(), appId)
-    if (fs.existsSync(path)) {
-      fs.rmdirSync(path, { recursive: true })
-    }
-  }
-}

package/src/utilities/fileSystem/filesystem.ts

@@ -1,170 +0,0 @@
-import { PathLike } from "fs"
-const { budibaseTempDir } = require("../budibaseDir")
-const fs = require("fs")
-const { join } = require("path")
-const uuid = require("uuid/v4")
-const env = require("../../environment")
-import tar from "tar"
-
-export const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
-
-/**
- * Upon first startup of instance there may not be everything we need in tmp directory, set it up.
- */
-export const init = () => {
-  const tempDir = budibaseTempDir()
-  if (!fs.existsSync(tempDir)) {
-    // some test cases fire this quickly enough that
-    // synchronous cases can end up here at the same time
-    try {
-      fs.mkdirSync(tempDir)
-    } catch (err: any) {
-      if (!err || err.code !== "EEXIST") {
-        throw err
-      }
-    }
-  }
-  const clientLibPath = join(budibaseTempDir(), "budibase-client.js")
-  if (env.isTest() && !fs.existsSync(clientLibPath)) {
-    fs.copyFileSync(require.resolve("@budibase/client"), clientLibPath)
-  }
-}
-
-/**
- * Checks if the system is currently in development mode and if it is makes sure
- * everything required to function is ready.
- */
-export const checkDevelopmentEnvironment = () => {
-  if (!env.isDev() || env.isTest()) {
-    return
-  }
-  if (!fs.existsSync(budibaseTempDir())) {
-    fs.mkdirSync(budibaseTempDir())
-  }
-  let error
-  if (!fs.existsSync(join(process.cwd(), ".env"))) {
-    error = "Must run via yarn once to generate environment."
-  }
-  if (error) {
-    console.error(error)
-    process.exit(-1)
-  }
-}
-
-/**
- * Used to retrieve a handlebars file from the system which will be used as a template.
- * This is allowable as the template handlebars files should be static and identical across
- * the cluster.
- * @param {string} path The path to the handlebars file which is to be loaded.
- * @returns {string} The loaded handlebars file as a string - loaded as utf8.
- */
-export const loadHandlebarsFile = (path: PathLike) => {
-  return fs.readFileSync(path, "utf8")
-}
-
-/**
- * When return a file from the API need to write the file to the system temporarily so we
- * can create a read stream to send.
- * @param {string} contents the contents of the file which is to be returned from the API.
- * @return {Object} the read stream which can be put into the koa context body.
- */
-export const apiFileReturn = (contents: any) => {
-  const path = join(budibaseTempDir(), uuid())
-  fs.writeFileSync(path, contents)
-  return fs.createReadStream(path)
-}
-
-export const streamFile = (path: string) => {
-  return fs.createReadStream(path)
-}
-
-/**
- * Writes the provided contents to a temporary file, which can be used briefly.
- * @param {string} fileContents contents which will be written to a temp file.
- * @return {string} the path to the temp file.
- */
-export const storeTempFile = (fileContents: any) => {
-  const path = join(budibaseTempDir(), uuid())
-  fs.writeFileSync(path, fileContents)
-  return path
-}
-
-/**
- * Utility function for getting a file read stream - a simple in memory buffered read
- * stream doesn't work for pouchdb.
- */
-export const stringToFileStream = (contents: any) => {
-  const path = storeTempFile(contents)
-  return fs.createReadStream(path)
-}
-
-/**
- * Creates a temp file and returns it from the API.
- * @param {string} fileContents the contents to be returned in file.
- */
-export const sendTempFile = (fileContents: any) => {
-  const path = storeTempFile(fileContents)
-  return fs.createReadStream(path)
-}
-
-/**
- * All file reads come through here just to make sure all of them make sense
- * allows a centralised location to check logic is all good.
- */
-export const readFileSync = (filepath: PathLike, options = "utf8") => {
-  return fs.readFileSync(filepath, options)
-}
-
-export const createTempFolder = (item: any) => {
-  const path = join(budibaseTempDir(), item)
-  try {
-    // remove old tmp directories automatically - don't combine
-    if (fs.existsSync(path)) {
-      fs.rmSync(path, { recursive: true, force: true })
-    }
-    fs.mkdirSync(path)
-  } catch (err: any) {
-    throw new Error(`Path cannot be created: ${err.message}`)
-  }
-
-  return path
-}
-
-export const extractTarball = async (fromFilePath: string, toPath: string) => {
-  await tar.extract({
-    file: fromFilePath,
-    C: toPath,
-  })
-}
-
-/**
- * Find for a file recursively from start path applying filter, return first match
- */
-export const findFileRec = (startPath: PathLike, filter: string): any => {
-  if (!fs.existsSync(startPath)) {
-    return
-  }
-
-  const files = fs.readdirSync(startPath)
-  for (let i = 0, len = files.length; i < len; i++) {
-    const filename = join(startPath, files[i])
-    const stat = fs.lstatSync(filename)
-
-    if (stat.isDirectory()) {
-      return findFileRec(filename, filter)
-    } else if (filename.endsWith(filter)) {
-      return filename
-    }
-  }
-}
-
-/**
- * Remove a folder which is not empty from the file system
- */
-export const deleteFolderFileSystem = (path: PathLike) => {
-  if (!fs.existsSync(path)) {
-    return
-  }
-
-  fs.rmSync(path, { recursive: true, force: true })
-}

package/src/utilities/fileSystem/plugin.ts

@@ -1,65 +0,0 @@
-import { Plugin } from "@budibase/types"
-
-const { budibaseTempDir } = require("../budibaseDir")
-const fs = require("fs")
-const { join } = require("path")
-import { objectStore } from "@budibase/backend-core"
-
-const DATASOURCE_PATH = join(budibaseTempDir(), "datasource")
-
-export const getPluginMetadata = async (path: string) => {
-  let metadata: any = {}
-  try {
-    const pkg = fs.readFileSync(join(path, "package.json"), "utf8")
-    const schema = fs.readFileSync(join(path, "schema.json"), "utf8")
-
-    metadata.schema = JSON.parse(schema)
-    metadata.package = JSON.parse(pkg)
-
-    if (
-      !metadata.package.name ||
-      !metadata.package.version ||
-      !metadata.package.description
-    ) {
-      throw new Error(
-        "package.json is missing one of 'name', 'version' or 'description'."
-      )
-    }
-  } catch (err: any) {
-    throw new Error(
-      `Unable to process schema.json/package.json in plugin. ${err.message}`
-    )
-  }
-
-  return { metadata, directory: path }
-}
-
-export const getDatasourcePlugin = async (plugin: Plugin) => {
-  const hash = plugin.schema?.hash
-  if (!fs.existsSync(DATASOURCE_PATH)) {
-    fs.mkdirSync(DATASOURCE_PATH)
-  }
-  const filename = join(DATASOURCE_PATH, plugin.name)
-  const metadataName = `${filename}.bbmetadata`
-  if (fs.existsSync(filename)) {
-    const currentHash = fs.readFileSync(metadataName, "utf8")
-    // if hash is the same return the file, otherwise remove it and re-download
-    if (currentHash === hash) {
-      return require(filename)
-    } else {
-      console.log(`Updating plugin: ${plugin.name}`)
-      delete require.cache[require.resolve(filename)]
-      fs.unlinkSync(filename)
-    }
-  }
-  const pluginKey = objectStore.getPluginJSKey(plugin)
-  const pluginJs = await objectStore.retrieve(
-    objectStore.ObjectStoreBuckets.PLUGINS,
-    pluginKey
-  )
-
-  fs.writeFileSync(filename, pluginJs)
-  fs.writeFileSync(metadataName, hash)
-
-  return require(filename)
-}

package/src/utilities/fileSystem/template.ts

@@ -1,36 +0,0 @@
-const fs = require("fs")
-const { join } = require("path")
-import { ObjectStoreBuckets } from "../../constants"
-import { objectStore } from "@budibase/backend-core"
-
-/**
- * This function manages temporary template files which are stored by Koa.
- * @param {Object} template The template object retrieved from the Koa context object.
- * @returns {Object} Returns an fs read stream which can be loaded into the database.
- */
-export const getTemplateStream = async (template: any) => {
-  if (template.file) {
-    return fs.createReadStream(template.file.path)
-  } else {
-    const [type, name] = template.key.split("/")
-    const tmpPath = await downloadTemplate(type, name)
-    return fs.createReadStream(join(tmpPath, name, "db", "dump.txt"))
-  }
-}
-
-/**
- * Retrieves a template and pipes it to minio as well as making it available temporarily.
- * @param {string} type The type of template which is to be retrieved.
- * @param name
- * @return {Promise<*>}
- */
-export const downloadTemplate = async (type: string, name: string) => {
-  const DEFAULT_TEMPLATES_BUCKET =
-    "prod-budi-templates.s3-eu-west-1.amazonaws.com"
-  const templateUrl = `https://${DEFAULT_TEMPLATES_BUCKET}/templates/${type}/${name}.tar.gz`
-  return objectStore.downloadTarball(
-    templateUrl,
-    ObjectStoreBuckets.TEMPLATES,
-    type
-  )
-}

package/src/utilities/rowProcessor/tests/utils.spec.ts

@@ -1,57 +0,0 @@
-import { fixAutoColumnSubType } from "../utils"
-import { AutoFieldDefaultNames, AutoFieldSubTypes } from "../../../constants"
-
-describe("rowProcessor utility", () => {
-  describe("fixAutoColumnSubType", () => {
-    let schema = {
-      name: "",
-      type: "link",
-      subtype: "", // missing subtype
-      icon: "ri-magic-line",
-      autocolumn: true,
-      constraints: { type: "array", presence: false },
-      tableId: "ta_users",
-      fieldName: "test-Updated By",
-      relationshipType: "many-to-many",
-      sortable: false,
-    }
-
-    it("updates the schema with the correct subtype", async () => {
-      schema.name = AutoFieldDefaultNames.CREATED_BY
-      expect(fixAutoColumnSubType(schema).subtype).toEqual(
-        AutoFieldSubTypes.CREATED_BY
-      )
-      schema.subtype = ""
-
-      schema.name = AutoFieldDefaultNames.UPDATED_BY
-      expect(fixAutoColumnSubType(schema).subtype).toEqual(
-        AutoFieldSubTypes.UPDATED_BY
-      )
-      schema.subtype = ""
-
-      schema.name = AutoFieldDefaultNames.CREATED_AT
-      expect(fixAutoColumnSubType(schema).subtype).toEqual(
-        AutoFieldSubTypes.CREATED_AT
-      )
-      schema.subtype = ""
-
-      schema.name = AutoFieldDefaultNames.UPDATED_AT
-      expect(fixAutoColumnSubType(schema).subtype).toEqual(
-        AutoFieldSubTypes.UPDATED_AT
-      )
-      schema.subtype = ""
-
-      schema.name = AutoFieldDefaultNames.AUTO_ID
-      expect(fixAutoColumnSubType(schema).subtype).toEqual(
-        AutoFieldSubTypes.AUTO_ID
-      )
-      schema.subtype = ""
-    })
-
-    it("returns the column if subtype exists", async () => {
-      schema.subtype = AutoFieldSubTypes.CREATED_BY
-      schema.name = AutoFieldDefaultNames.CREATED_AT
-      expect(fixAutoColumnSubType(schema)).toEqual(schema)
-    })
-  })
-})