@budibase/server 1.3.12-alpha.3 → 1.3.14

package/src/app.ts

@@ -26,12 +26,10 @@ const bullboard = require("./automations/bullboard")
 const { logAlert } = require("@budibase/backend-core/logging")
 const { pinoSettings } = require("@budibase/backend-core")
 const { Thread } = require("./threads")
-const fs = require("fs")
 import redis from "./utilities/redis"
 import * as migrations from "./migrations"
 import { events, installation, tenancy } from "@budibase/backend-core"
 import { createAdminUser, getChecklist } from "./utilities/workerRequests"
-import { watch } from "./watch"
 
 const app = new Koa()
 
@@ -141,16 +139,6 @@ module.exports = server.listen(env.PORT || 0, async () => {
     }
   }
 
-  // monitor plugin directory if required
-  if (
-    env.SELF_HOSTED &&
-    !env.MULTI_TENANCY &&
-    env.PLUGINS_DIR &&
-    fs.existsSync(env.PLUGINS_DIR)
-  ) {
-    watch()
-  }
-
   // check for version updates
   await installation.checkInstallVersion()
 

package/src/automations/index.js

@@ -1,16 +1,19 @@
 const { processEvent } = require("./utils")
 const { queue, shutdown } = require("./bullboard")
-const { TRIGGER_DEFINITIONS } = require("./triggers")
+const { TRIGGER_DEFINITIONS, rebootTrigger } = require("./triggers")
 const { ACTION_DEFINITIONS } = require("./actions")
 
 /**
  * This module is built purely to kick off the worker farm and manage the inputs/outputs
  */
-exports.init = function () {
+exports.init = async function () {
   // this promise will not complete
-  return queue.process(async job => {
+  const promise = queue.process(async job => {
     await processEvent(job)
   })
+  // on init we need to trigger any reboot automations
+  await rebootTrigger()
+  return promise
 }
 
 exports.getQueues = () => {

package/src/automations/triggers.js

@@ -9,6 +9,7 @@ const { checkTestFlag } = require("../utilities/redis")
 const utils = require("./utils")
 const env = require("../environment")
 const { doInAppContext, getAppDB } = require("@budibase/backend-core/context")
+const { getAllApps } = require("@budibase/backend-core/db")
 
 const TRIGGER_DEFINITIONS = definitions
 const JOB_OPTS = {
@@ -16,24 +17,27 @@ const JOB_OPTS = {
   removeOnFail: true,
 }
 
+async function getAllAutomations() {
+  const db = getAppDB()
+  let automations = await db.allDocs(
+    getAutomationParams(null, { include_docs: true })
+  )
+  return automations.rows.map(row => row.doc)
+}
+
 async function queueRelevantRowAutomations(event, eventType) {
   if (event.appId == null) {
     throw `No appId specified for ${eventType} - check event emitters.`
   }
 
   doInAppContext(event.appId, async () => {
-    const db = getAppDB()
-    let automations = await db.allDocs(
-      getAutomationParams(null, { include_docs: true })
-    )
+    let automations = await getAllAutomations()
 
     // filter down to the correct event type
-    automations = automations.rows
-      .map(automation => automation.doc)
-      .filter(automation => {
-        const trigger = automation.definition.trigger
-        return trigger && trigger.event === eventType
-      })
+    automations = automations.filter(automation => {
+      const trigger = automation.definition.trigger
+      return trigger && trigger.event === eventType
+    })
 
     for (let automation of automations) {
       let automationDef = automation.definition
@@ -110,4 +114,34 @@ exports.externalTrigger = async function (
   }
 }
 
+exports.rebootTrigger = async () => {
+  // reboot cron option is only available on the main thread at
+  // startup and only usable in self host
+  if (env.isInThread() || !env.SELF_HOSTED) {
+    return
+  }
+  // iterate through all production apps, find the reboot crons
+  // and trigger events for them
+  const appIds = await getAllApps({ dev: false, idsOnly: true })
+  for (let prodAppId of appIds) {
+    await doInAppContext(prodAppId, async () => {
+      let automations = await getAllAutomations()
+      let rebootEvents = []
+      for (let automation of automations) {
+        if (utils.isRebootTrigger(automation)) {
+          const job = {
+            automation,
+            event: {
+              appId: prodAppId,
+              timestamp: Date.now(),
+            },
+          }
+          rebootEvents.push(queue.add(job, JOB_OPTS))
+        }
+      }
+      await Promise.all(rebootEvents)
+    })
+  }
+}
+
 exports.TRIGGER_DEFINITIONS = TRIGGER_DEFINITIONS

package/src/automations/utils.ts

@@ -17,6 +17,7 @@ import { tenancy } from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
 import { Automation } from "@budibase/types"
 
+const REBOOT_CRON = "@reboot"
 const WH_STEP_ID = definitions.WEBHOOK.stepId
 const CRON_STEP_ID = definitions.CRON.stepId
 const Runner = new Thread(ThreadType.AUTOMATION)
@@ -109,22 +110,33 @@ export async function clearMetadata() {
   await db.bulkDocs(automationMetadata)
 }
 
+export function isCronTrigger(auto: Automation) {
+  return (
+    auto &&
+    auto.definition.trigger &&
+    auto.definition.trigger.stepId === CRON_STEP_ID
+  )
+}
+
+export function isRebootTrigger(auto: Automation) {
+  const trigger = auto ? auto.definition.trigger : null
+  return isCronTrigger(auto) && trigger?.inputs.cron === REBOOT_CRON
+}
+
 /**
  * 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.
  */
-export async function enableCronTrigger(appId: any, automation: any) {
+export async function enableCronTrigger(appId: any, automation: Automation) {
   const trigger = automation ? automation.definition.trigger : null
-  function isCronTrigger(auto: any) {
-    return (
-      auto &&
-      auto.definition.trigger &&
-      auto.definition.trigger.stepId === CRON_STEP_ID
-    )
-  }
+
   // need to create cron job
-  if (isCronTrigger(automation) && trigger?.inputs.cron) {
+  if (
+    isCronTrigger(automation) &&
+    !isRebootTrigger(automation) &&
+    trigger?.inputs.cron
+  ) {
     // make a job id rather than letting Bull decide, makes it easier to handle on way out
     const jobId = `${appId}_cron_${newid()}`
     const job: any = await queue.add(

package/src/db/utils.js

@@ -42,7 +42,6 @@ const DocumentType = {
   MEM_VIEW: "view",
   USER_FLAG: "flag",
   AUTOMATION_METADATA: "meta_au",
-  PLUGIN: "plg",
 }
 
 const InternalTables = {
@@ -371,10 +370,6 @@ exports.getMemoryViewParams = (otherProps = {}) => {
   return getDocParams(DocumentType.MEM_VIEW, null, otherProps)
 }
 
-exports.generatePluginID = name => {
-  return `${DocumentType.PLUGIN}${SEPARATOR}${name}`
-}
-
 /**
  * This can be used with the db.allDocs to get a list of IDs
  */
@@ -384,10 +379,3 @@ exports.getMultiIDParams = ids => {
     include_docs: true,
   }
 }
-
-/**
- * Gets parameters for retrieving automations, this is a utility function for the getDocParams function.
- */
-exports.getPluginParams = (pluginId = null, otherProps = {}) => {
-  return getDocParams(DocumentType.PLUGIN, pluginId, otherProps)
-}

package/src/definitions/datasource.ts

@@ -34,6 +34,7 @@ export interface RestConfig {
   defaultHeaders: {
     [key: string]: any
   }
+  legacyHttpParser: boolean
   authConfigs: AuthConfig[]
   staticVariables: {
     [key: string]: string

package/src/environment.js

@@ -74,7 +74,6 @@ module.exports = {
   SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
   BB_ADMIN_USER_EMAIL: process.env.BB_ADMIN_USER_EMAIL,
   BB_ADMIN_USER_PASSWORD: process.env.BB_ADMIN_USER_PASSWORD,
-  PLUGINS_DIR: process.env.PLUGINS_DIR || "/plugins",
   // flags
   ALLOW_DEV_AUTOMATIONS: process.env.ALLOW_DEV_AUTOMATIONS,
   DISABLE_THREADING: process.env.DISABLE_THREADING,

package/src/integrations/airtable.ts

@@ -5,144 +5,146 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const Airtable = require("airtable")
+module AirtableModule {
+  const Airtable = require("airtable")
 
-interface AirtableConfig {
-  apiKey: string
-  base: string
-}
+  interface AirtableConfig {
+    apiKey: string
+    base: string
+  }
 
-const SCHEMA: Integration = {
-  docs: "https://airtable.com/api",
-  description:
-    "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
-  friendlyName: "Airtable",
-  type: "Spreadsheet",
-  datasource: {
-    apiKey: {
-      type: DatasourceFieldType.PASSWORD,
-      default: "enter api key",
-      required: true,
-    },
-    base: {
-      type: DatasourceFieldType.STRING,
-      default: "mybase",
-      required: true,
-    },
-  },
-  query: {
-    create: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
+  const SCHEMA: Integration = {
+    docs: "https://airtable.com/api",
+    description:
+      "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
+    friendlyName: "Airtable",
+    type: "Spreadsheet",
+    datasource: {
+      apiKey: {
+        type: DatasourceFieldType.PASSWORD,
+        default: "enter api key",
+        required: true,
+      },
+      base: {
+        type: DatasourceFieldType.STRING,
+        default: "mybase",
+        required: true,
       },
     },
-    read: {
-      type: QueryType.FIELDS,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        view: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        numRecords: {
-          type: DatasourceFieldType.NUMBER,
-          default: 10,
+    query: {
+      create: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    update: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        id: {
-          display: "Record ID",
-          type: DatasourceFieldType.STRING,
-          required: true,
+      read: {
+        type: QueryType.FIELDS,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          view: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          numRecords: {
+            type: DatasourceFieldType.NUMBER,
+            default: 10,
+          },
         },
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      },
+      update: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          id: {
+            display: "Record ID",
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
+      delete: {
+        type: QueryType.JSON,
+      },
     },
-    delete: {
-      type: QueryType.JSON,
-    },
-  },
-}
+  }
 
-class AirtableIntegration implements IntegrationBase {
-  private config: AirtableConfig
-  private client: any
+  class AirtableIntegration implements IntegrationBase {
+    private config: AirtableConfig
+    private client: any
 
-  constructor(config: AirtableConfig) {
-    this.config = config
-    this.client = new Airtable(config).base(config.base)
-  }
+    constructor(config: AirtableConfig) {
+      this.config = config
+      this.client = new Airtable(config).base(config.base)
+    }
 
-  async create(query: { table: any; json: any }) {
-    const { table, json } = query
+    async create(query: { table: any; json: any }) {
+      const { table, json } = query
 
-    try {
-      return await this.client(table).create([
-        {
-          fields: json,
-        },
-      ])
-    } catch (err) {
-      console.error("Error writing to airtable", err)
-      throw err
+      try {
+        return await this.client(table).create([
+          {
+            fields: json,
+          },
+        ])
+      } catch (err) {
+        console.error("Error writing to airtable", err)
+        throw err
+      }
     }
-  }
 
-  async read(query: { table: any; numRecords: any; view: any }) {
-    try {
-      const records = await this.client(query.table)
-        .select({ maxRecords: query.numRecords || 10, view: query.view })
-        .firstPage()
-      // @ts-ignore
-      return records.map(({ fields }) => fields)
-    } catch (err) {
-      console.error("Error writing to airtable", err)
-      return []
+    async read(query: { table: any; numRecords: any; view: any }) {
+      try {
+        const records = await this.client(query.table)
+          .select({ maxRecords: query.numRecords || 10, view: query.view })
+          .firstPage()
+        // @ts-ignore
+        return records.map(({ fields }) => fields)
+      } catch (err) {
+        console.error("Error writing to airtable", err)
+        return []
+      }
     }
-  }
 
-  async update(query: { table: any; id: any; json: any }) {
-    const { table, id, json } = query
+    async update(query: { table: any; id: any; json: any }) {
+      const { table, id, json } = query
 
-    try {
-      return await this.client(table).update([
-        {
-          id,
-          fields: json,
-        },
-      ])
-    } catch (err) {
-      console.error("Error writing to airtable", err)
-      throw err
+      try {
+        return await this.client(table).update([
+          {
+            id,
+            fields: json,
+          },
+        ])
+      } catch (err) {
+        console.error("Error writing to airtable", err)
+        throw err
+      }
     }
-  }
 
-  async delete(query: { table: any; ids: any }) {
-    try {
-      return await this.client(query.table).destroy(query.ids)
-    } catch (err) {
-      console.error("Error writing to airtable", err)
-      throw err
+    async delete(query: { table: any; ids: any }) {
+      try {
+        return await this.client(query.table).destroy(query.ids)
+      } catch (err) {
+        console.error("Error writing to airtable", err)
+        throw err
+      }
     }
   }
-}
 
-export default {
-  schema: SCHEMA,
-  integration: AirtableIntegration,
+  module.exports = {
+    schema: SCHEMA,
+    integration: AirtableIntegration,
+  }
 }