@budibase/server 0.9.125-alpha.4 → 0.9.125-alpha.8

package/src/automations/utils.js

@@ -0,0 +1,159 @@
+const runner = require("./thread")
+const { definitions } = require("./triggerInfo")
+const webhooks = require("../api/controllers/webhook")
+const CouchDB = require("../db")
+const { queue } = require("./bullboard")
+const newid = require("../db/newid")
+const { updateEntityMetadata } = require("../utilities")
+const { MetadataTypes } = require("../constants")
+
+const WH_STEP_ID = definitions.WEBHOOK.stepId
+const CRON_STEP_ID = definitions.CRON.stepId
+
+exports.processEvent = async job => {
+  try {
+    // need to actually await these so that an error can be captured properly
+    return await runner(job)
+  } catch (err) {
+    console.error(
+      `${job.data.automation.appId} automation ${job.data.automation._id} was unable to run - ${err}`
+    )
+    return { err }
+  }
+}
+
+exports.updateTestHistory = async (appId, automation, history) => {
+  return updateEntityMetadata(
+    appId,
+    MetadataTypes.AUTOMATION_TEST_HISTORY,
+    automation._id,
+    metadata => {
+      if (metadata && Array.isArray(metadata.history)) {
+        metadata.history.push(history)
+      } else {
+        metadata = {
+          history: [history],
+        }
+      }
+      return metadata
+    }
+  )
+}
+
+// end the repetition and the job itself
+exports.disableAllCrons = async appId => {
+  const promises = []
+  const jobs = await queue.getRepeatableJobs()
+  for (let job of jobs) {
+    if (job.key.includes(`${appId}_cron`)) {
+      promises.push(queue.removeRepeatableByKey(job.key))
+      promises.push(queue.removeJobs(job.id))
+    }
+  }
+  return Promise.all(promises)
+}
+
+/**
+ * This function handles checking of any cron jobs that need to be enabled/updated.
+ * @param {string} appId The ID of the app in which we are checking for webhooks
+ * @param {object|undefined} automation The automation object to be updated.
+ */
+exports.enableCronTrigger = async (appId, automation) => {
+  const trigger = automation ? automation.definition.trigger : null
+  function isCronTrigger(auto) {
+    return (
+      auto &&
+      auto.definition.trigger &&
+      auto.definition.trigger.stepId === CRON_STEP_ID
+    )
+  }
+  // need to create cron job
+  if (isCronTrigger(automation)) {
+    // make a job id rather than letting Bull decide, makes it easier to handle on way out
+    const jobId = `${appId}_cron_${newid()}`
+    const job = await queue.add(
+      {
+        automation,
+        event: { appId, timestamp: Date.now() },
+      },
+      { repeat: { cron: trigger.inputs.cron }, jobId }
+    )
+    // Assign cron job ID from bull so we can remove it later if the cron trigger is removed
+    trigger.cronJobId = job.id
+    const db = new CouchDB(appId)
+    const response = await db.put(automation)
+    automation._id = response.id
+    automation._rev = response.rev
+  }
+  return automation
+}
+
+/**
+ * This function handles checking if any webhooks need to be created or deleted for automations.
+ * @param {string} appId The ID of the app in which we are checking for webhooks
+ * @param {object|undefined} oldAuto The old automation object if updating/deleting
+ * @param {object|undefined} newAuto The new automation object if creating/updating
+ * @returns {Promise<object|undefined>} After this is complete the new automation object may have been updated and should be
+ * written to DB (this does not write to DB as it would be wasteful to repeat).
+ */
+exports.checkForWebhooks = async ({ appId, oldAuto, newAuto }) => {
+  const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
+  const newTrigger = newAuto ? newAuto.definition.trigger : null
+  const triggerChanged =
+    oldTrigger && newTrigger && oldTrigger.id !== newTrigger.id
+  function isWebhookTrigger(auto) {
+    return (
+      auto &&
+      auto.definition.trigger &&
+      auto.definition.trigger.stepId === WH_STEP_ID
+    )
+  }
+  // need to delete webhook
+  if (
+    isWebhookTrigger(oldAuto) &&
+    (!isWebhookTrigger(newAuto) || triggerChanged) &&
+    oldTrigger.webhookId
+  ) {
+    try {
+      let db = new CouchDB(appId)
+      // need to get the webhook to get the rev
+      const webhook = await db.get(oldTrigger.webhookId)
+      const ctx = {
+        appId,
+        params: { id: webhook._id, rev: webhook._rev },
+      }
+      // might be updating - reset the inputs to remove the URLs
+      if (newTrigger) {
+        delete newTrigger.webhookId
+        newTrigger.inputs = {}
+      }
+      await webhooks.destroy(ctx)
+    } catch (err) {
+      // don't worry about not being able to delete, if it doesn't exist all good
+    }
+  }
+  // need to create webhook
+  if (
+    (!isWebhookTrigger(oldAuto) || triggerChanged) &&
+    isWebhookTrigger(newAuto)
+  ) {
+    const ctx = {
+      appId,
+      request: {
+        body: new webhooks.Webhook(
+          "Automation webhook",
+          webhooks.WebhookType.AUTOMATION,
+          newAuto._id
+        ),
+      },
+    }
+    await webhooks.save(ctx)
+    const id = ctx.body.webhook._id
+    newTrigger.webhookId = id
+    newTrigger.inputs = {
+      schemaUrl: `api/webhooks/schema/${appId}/${id}`,
+      triggerUrl: `api/webhooks/trigger/${appId}/${id}`,
+    }
+  }
+  return newAuto
+}

package/src/constants/index.js

@@ -123,5 +123,10 @@ exports.BaseQueryVerbs = {
   DELETE: "delete",
 }
 
+exports.MetadataTypes = {
+  AUTOMATION_TEST_INPUT: "automationTestInput",
+  AUTOMATION_TEST_HISTORY: "automationTestHistory",
+}
+
 // pass through the list from the auth/core lib
 exports.ObjectStoreBuckets = ObjectStoreBuckets

package/src/db/linkedRows/index.js

@@ -36,6 +36,18 @@ exports.IncludeDocs = IncludeDocs
 exports.getLinkDocuments = getLinkDocuments
 exports.createLinkView = createLinkView
 
+function clearRelationshipFields(table, rows) {
+  for (let [key, field] of Object.entries(table.schema)) {
+    if (field.type === FieldTypes.LINK) {
+      rows = rows.map(row => {
+        delete row[key]
+        return row
+      })
+    }
+  }
+  return rows
+}
+
 async function getLinksForRows(appId, rows) {
   const tableIds = [...new Set(rows.map(el => el.tableId))]
   // start by getting all the link values for performance reasons
@@ -126,33 +138,6 @@ exports.updateLinks = async function (args) {
   }
 }
 
-/**
- * Update a row with information about the links that pertain to it.
- * @param {string} appId The instance in which this row has been created.
- * @param {object} rows The row(s) themselves which is to be updated with info (if applicable). This can be
- * a single row object or an array of rows - both will be handled.
- * @returns {Promise<object>} The updated row (this may be the same if no links were found). If an array was input
- * then an array will be output, object input -> object output.
- */
-exports.attachLinkIDs = async (appId, rows) => {
-  const links = await getLinksForRows(appId, rows)
-  // now iterate through the rows and all field information
-  for (let row of rows) {
-    // find anything that matches the row's ID we are searching for and join it
-    links
-      .filter(el => el.thisId === row._id)
-      .forEach(link => {
-        if (row[link.fieldName] == null) {
-          row[link.fieldName] = []
-        }
-        row[link.fieldName].push(link.id)
-      })
-  }
-  // if it was an array when it came in then handle it as an array in response
-  // otherwise return the first element as there was only one input
-  return rows
-}
-
 /**
  * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
  * This is required for formula fields, this may only be utilised internally (for now).
@@ -173,6 +158,9 @@ exports.attachFullLinkedDocs = async (ctx, table, rows) => {
   const links = (await getLinksForRows(appId, rows)).filter(link =>
     rows.some(row => row._id === link.thisId)
   )
+  // clear any existing links that could be dupe'd
+  rows = clearRelationshipFields(table, rows)
+  // now get the docs and combine into the rows
   let linked = await getFullLinkedDocs(ctx, appId, links)
   const linkedTables = []
   for (let row of rows) {

package/src/db/tests/linkTests.spec.js

@@ -59,16 +59,4 @@ describe("test link functionality", () => {
       expect(Array.isArray(output)).toBe(true)
     })
   })
-
-  describe("attachLinkIDs", () => {
-    it("should be able to attach linkIDs", async () => {
-      await config.init()
-      await config.createTable()
-      const table = await config.createLinkedTable()
-      const row = await config.createRow()
-      const linkRow = await config.createRow(basicLinkedRow(table._id, row._id))
-      const attached = await links.attachLinkIDs(config.getAppId(), [linkRow])
-      expect(attached[0].link[0]).toBe(row._id)
-    })
-  })
 })

package/src/db/utils.js

@@ -7,6 +7,8 @@ const {
   APP_PREFIX,
   SEPARATOR,
   StaticDatabases,
+  isDevAppID,
+  isProdAppID,
 } = require("@budibase/auth/db")
 
 const UNICODE_MAX = "\ufff0"
@@ -36,6 +38,7 @@ const DocumentTypes = {
   DATASOURCE_PLUS: "datasource_plus",
   QUERY: "query",
   DEPLOYMENTS: "deployments",
+  METADATA: "metadata",
 }
 
 const ViewNames = {
@@ -63,6 +66,8 @@ const BudibaseInternalDB = {
 
 exports.APP_PREFIX = APP_PREFIX
 exports.APP_DEV_PREFIX = APP_DEV_PREFIX
+exports.isDevAppID = isDevAppID
+exports.isProdAppID = isProdAppID
 exports.USER_METDATA_PREFIX = `${DocumentTypes.ROW}${SEPARATOR}${InternalTables.USER_METADATA}${SEPARATOR}`
 exports.LINK_USER_METADATA_PREFIX = `${DocumentTypes.LINK}${SEPARATOR}${InternalTables.USER_METADATA}${SEPARATOR}`
 exports.ViewNames = ViewNames
@@ -331,6 +336,18 @@ exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
   )
 }
 
+exports.generateMetadataID = (type, entityId) => {
+  return `${DocumentTypes.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`
+}
+
+exports.getMetadataParams = (type, entityId = null, otherProps = {}) => {
+  let docId = `${type}${SEPARATOR}`
+  if (entityId != null) {
+    docId += entityId
+  }
+  return getDocParams(DocumentTypes.METADATA, docId, otherProps)
+}
+
 /**
  * This can be used with the db.allDocs to get a list of IDs
  */

package/src/environment.js

@@ -55,6 +55,7 @@ module.exports = {
   BUDIBASE_API_KEY: process.env.BUDIBASE_API_KEY,
   USERID_API_KEY: process.env.USERID_API_KEY,
   DEPLOYMENT_CREDENTIALS_URL: process.env.DEPLOYMENT_CREDENTIALS_URL,
+  ALLOW_DEV_AUTOMATIONS: process.env.ALLOW_DEV_AUTOMATIONS,
   _set(key, value) {
     process.env[key] = value
     module.exports[key] = value

package/src/integrations/mysql.ts

@@ -152,7 +152,7 @@ module MySQLModule {
         false
       )
       const tableNames = tablesResp.map(
-        (obj: any) => obj[`Tables_in_${database}`]
+        (obj: any) => obj[`Tables_in_${database.toLowerCase()}`]
       )
       for (let tableName of tableNames) {
         const primaryKeys = []

package/src/middleware/appInfo.js

@@ -0,0 +1,19 @@
+const { isDevAppID, isProdAppID } = require("../db/utils")
+
+exports.AppType = {
+  DEV: "dev",
+  PROD: "prod",
+}
+
+exports.middleware =
+  ({ appType } = {}) =>
+  (ctx, next) => {
+    const appId = ctx.appId
+    if (appType === exports.AppType.DEV && appId && !isDevAppID(appId)) {
+      ctx.throw(400, "Only apps in development support this endpoint")
+    }
+    if (appType === exports.AppType.PROD && appId && !isProdAppID(appId)) {
+      ctx.throw(400, "Only apps in production support this endpoint")
+    }
+    return next()
+  }

package/src/middleware/usageQuota.js

@@ -14,7 +14,7 @@ const DOMAIN_MAP = {
   views: usageQuota.Properties.VIEW,
   users: usageQuota.Properties.USER,
   // this will not be updated by endpoint calls
-  // instead it will be updated by triggers
+  // instead it will be updated by triggerInfo
   automationRuns: usageQuota.Properties.AUTOMATION,
 }
 

package/src/utilities/fileSystem/index.js

@@ -14,18 +14,12 @@ const {
   downloadTarball,
 } = require("./utilities")
 const { updateClientLibrary } = require("./clientLibrary")
-const download = require("download")
 const env = require("../../environment")
-const { homedir } = require("os")
-const fetch = require("node-fetch")
 const {
   USER_METDATA_PREFIX,
   LINK_USER_METADATA_PREFIX,
 } = require("../../db/utils")
 
-const DEFAULT_AUTOMATION_BUCKET =
-  "https://prod-budi-automations.s3-eu-west-1.amazonaws.com"
-const DEFAULT_AUTOMATION_DIRECTORY = ".budibase-automations"
 const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
 const NODE_MODULES_PATH = join(TOP_LEVEL_PATH, "node_modules")
 
@@ -205,30 +199,6 @@ exports.getComponentLibraryManifest = async (appId, library) => {
   return JSON.parse(resp)
 }
 
-exports.automationInit = async () => {
-  const directory =
-    env.AUTOMATION_DIRECTORY || join(homedir(), DEFAULT_AUTOMATION_DIRECTORY)
-  const bucket = env.AUTOMATION_BUCKET || DEFAULT_AUTOMATION_BUCKET
-  if (!fs.existsSync(directory)) {
-    fs.mkdirSync(directory, { recursive: true })
-  }
-  // env setup to get async packages
-  let response = await fetch(`${bucket}/manifest.json`)
-  return response.json()
-}
-
-exports.getExternalAutomationStep = async (name, version, bundleName) => {
-  const directory =
-    env.AUTOMATION_DIRECTORY || join(homedir(), DEFAULT_AUTOMATION_DIRECTORY)
-  const bucket = env.AUTOMATION_BUCKET || DEFAULT_AUTOMATION_BUCKET
-  try {
-    return require(join(directory, bundleName))
-  } catch (err) {
-    await download(`${bucket}/${name}/${version}/${bundleName}`, directory)
-    return require(join(directory, bundleName))
-  }
-}
-
 /**
  * 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.

package/src/utilities/index.js

@@ -1,6 +1,8 @@
 const env = require("../environment")
 const { OBJ_STORE_DIRECTORY } = require("../constants")
 const { sanitizeKey } = require("@budibase/auth/src/objectStore")
+const CouchDB = require("../db")
+const { generateMetadataID } = require("../db/utils")
 
 const BB_CDN = "https://cdn.budi.live"
 
@@ -55,3 +57,52 @@ exports.attachmentsRelativeURL = attachmentKey => {
     `${exports.objectStoreUrl()}/${attachmentKey}`
   )
 }
+
+exports.updateEntityMetadata = async (appId, type, entityId, updateFn) => {
+  const db = new CouchDB(appId)
+  const id = generateMetadataID(type, entityId)
+  // read it to see if it exists, we'll overwrite it no matter what
+  let rev,
+    metadata = {}
+  try {
+    const oldMetadata = await db.get(id)
+    rev = oldMetadata._rev
+    metadata = updateFn(oldMetadata)
+  } catch (err) {
+    rev = null
+    metadata = updateFn({})
+  }
+  metadata._id = id
+  if (rev) {
+    metadata._rev = rev
+  }
+  const response = await db.put(metadata)
+  return {
+    ...metadata,
+    _id: id,
+    _rev: response.rev,
+  }
+}
+
+exports.saveEntityMetadata = async (appId, type, entityId, metadata) => {
+  return exports.updateEntityMetadata(appId, type, entityId, () => {
+    return metadata
+  })
+}
+
+exports.deleteEntityMetadata = async (appId, type, entityId) => {
+  const db = new CouchDB(appId)
+  const id = generateMetadataID(type, entityId)
+  let rev
+  try {
+    const metadata = await db.get(id)
+    if (metadata) {
+      rev = metadata._rev
+    }
+  } catch (err) {
+    // don't need to error if it doesn't exist
+  }
+  if (id && rev) {
+    await db.remove(id, rev)
+  }
+}