@budibase/server 2.1.43-alpha.6 → 2.1.44

package/src/automations/{triggers.ts → triggers.js}

@@ -1,39 +1,36 @@
-import emitter from "../events/index"
-import { getAutomationParams } from "../db/utils"
-import { coerce } from "../utilities/rowProcessor"
-import { definitions } from "./triggerInfo"
-import { isDevAppID } from "../db/utils"
+const emitter = require("../events/index")
+const { getAutomationParams } = require("../db/utils")
+const { coerce } = require("../utilities/rowProcessor")
+const { definitions } = require("./triggerInfo")
+const { isDevAppID } = require("../db/utils")
 // need this to call directly, so we can get a response
-import { automationQueue } from "./bullboard"
-import { checkTestFlag } from "../utilities/redis"
-import * as utils from "./utils"
-import env from "../environment"
-import { context, db as dbCore } from "@budibase/backend-core"
-import { Automation, Row } from "@budibase/types"
+const { automationQueue } = require("./bullboard")
+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")
 
-export const TRIGGER_DEFINITIONS = definitions
+const TRIGGER_DEFINITIONS = definitions
 const JOB_OPTS = {
   removeOnComplete: true,
   removeOnFail: true,
 }
 
 async function getAllAutomations() {
-  const db = context.getAppDB()
+  const db = getAppDB()
   let automations = await db.allDocs(
     getAutomationParams(null, { include_docs: true })
   )
   return automations.rows.map(row => row.doc)
 }
 
-async function queueRelevantRowAutomations(
-  event: { appId: string; row: Row },
-  eventType: string
-) {
+async function queueRelevantRowAutomations(event, eventType) {
   if (event.appId == null) {
     throw `No appId specified for ${eventType} - check event emitters.`
   }
 
-  await context.doInAppContext(event.appId, async () => {
+  doInAppContext(event.appId, async () => {
     let automations = await getAllAutomations()
 
     // filter down to the correct event type
@@ -89,20 +86,20 @@ emitter.on("row:delete", async function (event) {
   await queueRelevantRowAutomations(event, "row:delete")
 })
 
-export async function externalTrigger(
-  automation: Automation,
-  params: { fields: Record<string, any> },
-  { getResponses }: { getResponses?: boolean } = {}
+exports.externalTrigger = async function (
+  automation,
+  params,
+  { getResponses } = {}
 ) {
   if (
     automation.definition != null &&
     automation.definition.trigger != null &&
     automation.definition.trigger.stepId === definitions.APP.stepId &&
     automation.definition.trigger.stepId === "APP" &&
-    !(await checkTestFlag(automation._id!))
+    !(await checkTestFlag(automation._id))
   ) {
     // values are likely to be submitted as strings, so we shall convert to correct type
-    const coercedFields: any = {}
+    const coercedFields = {}
     const fields = automation.definition.trigger.inputs.fields
     for (let key of Object.keys(fields || {})) {
       coercedFields[key] = coerce(params.fields[key], fields[key])
@@ -117,7 +114,7 @@ export async function externalTrigger(
   }
 }
 
-export async function rebootTrigger() {
+exports.rebootTrigger = async () => {
   // reboot cron option is only available on the main thread at
   // startup and only usable in self host and single tenant environments
   if (env.isInThread() || !env.SELF_HOSTED || env.MULTI_TENANCY) {
@@ -125,12 +122,9 @@ export async function rebootTrigger() {
   }
   // iterate through all production apps, find the reboot crons
   // and trigger events for them
-  const appIds = (await dbCore.getAllApps({
-    dev: false,
-    idsOnly: true,
-  })) as string[]
+  const appIds = await getAllApps({ dev: false, idsOnly: true })
   for (let prodAppId of appIds) {
-    await context.doInAppContext(prodAppId, async () => {
+    await doInAppContext(prodAppId, async () => {
       let automations = await getAllAutomations()
       let rebootEvents = []
       for (let automation of automations) {
@@ -149,3 +143,5 @@ export async function rebootTrigger() {
     })
   }
 }
+
+exports.TRIGGER_DEFINITIONS = TRIGGER_DEFINITIONS

package/src/automations/utils.ts

@@ -4,9 +4,15 @@ import { automationQueue } from "./bullboard"
 import newid from "../db/newid"
 import { updateEntityMetadata } from "../utilities"
 import { MetadataTypes } from "../constants"
-import { db as dbCore, context } from "@budibase/backend-core"
+import { getProdAppID, doWithDB } from "@budibase/backend-core/db"
 import { getAutomationMetadataParams } from "../db/utils"
 import { cloneDeep } from "lodash/fp"
+import {
+  getAppDB,
+  getAppId,
+  getProdAppDB,
+} from "@budibase/backend-core/context"
+import { context } from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
 import { Automation, WebhookActionType } from "@budibase/types"
 import sdk from "../sdk"
@@ -96,7 +102,7 @@ export async function disableCronById(jobId: number | string) {
 }
 
 export async function clearMetadata() {
-  const db = context.getProdAppDB()
+  const db = getProdAppDB()
   const automationMetadata = (
     await db.allDocs(
       getAutomationMetadataParams({
@@ -151,7 +157,7 @@ export async function enableCronTrigger(appId: any, automation: Automation) {
     // can't use getAppDB here as this is likely to be called from dev app,
     // but this call could be for dev app or prod app, need to just use what
     // was passed in
-    await dbCore.doWithDB(appId, async (db: any) => {
+    await doWithDB(appId, async (db: any) => {
       const response = await db.put(automation)
       automation._id = response.id
       automation._rev = response.rev
@@ -169,10 +175,7 @@ export async function enableCronTrigger(appId: any, automation: Automation) {
  * written to DB (this does not write to DB as it would be wasteful to repeat).
  */
 export async function checkForWebhooks({ oldAuto, newAuto }: any) {
-  const appId = context.getAppId()
-  if (!appId) {
-    throw new Error("Unable to check webhooks - no app ID in context.")
-  }
+  const appId = getAppId()
   const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
   const newTrigger = newAuto ? newAuto.definition.trigger : null
   const triggerChanged =
@@ -191,7 +194,7 @@ export async function checkForWebhooks({ oldAuto, newAuto }: any) {
     oldTrigger.webhookId
   ) {
     try {
-      let db = context.getAppDB()
+      let db = getAppDB()
       // need to get the webhook to get the rev
       const webhook = await db.get(oldTrigger.webhookId)
       // might be updating - reset the inputs to remove the URLs
@@ -221,7 +224,7 @@ export async function checkForWebhooks({ oldAuto, newAuto }: any) {
     // the app ID has to be development for this endpoint
     // it can only be used when building the app
     // but the trigger endpoint will always be used in production
-    const prodAppId = dbCore.getProdAppID(appId)
+    const prodAppId = getProdAppID(appId)
     newTrigger.inputs = {
       schemaUrl: `api/webhooks/schema/${appId}/${id}`,
       triggerUrl: `api/webhooks/trigger/${prodAppId}/${id}`,

package/src/constants/index.js

@@ -0,0 +1,208 @@
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
+const { UserStatus } = require("@budibase/backend-core/constants")
+const { objectStore } = require("@budibase/backend-core")
+
+const FilterTypes = {
+  STRING: "string",
+  FUZZY: "fuzzy",
+  RANGE: "range",
+  EQUAL: "equal",
+  NOT_EQUAL: "notEqual",
+  EMPTY: "empty",
+  NOT_EMPTY: "notEmpty",
+  CONTAINS: "contains",
+  NOT_CONTAINS: "notContains",
+  ONE_OF: "oneOf",
+}
+
+exports.FilterTypes = FilterTypes
+exports.NoEmptyFilterStrings = [
+  FilterTypes.STRING,
+  FilterTypes.FUZZY,
+  FilterTypes.EQUAL,
+  FilterTypes.NOT_EQUAL,
+  FilterTypes.CONTAINS,
+  FilterTypes.NOT_CONTAINS,
+]
+
+exports.FieldTypes = {
+  STRING: "string",
+  BARCODEQR: "barcodeqr",
+  LONGFORM: "longform",
+  OPTIONS: "options",
+  NUMBER: "number",
+  BOOLEAN: "boolean",
+  ARRAY: "array",
+  DATETIME: "datetime",
+  ATTACHMENT: "attachment",
+  LINK: "link",
+  FORMULA: "formula",
+  AUTO: "auto",
+  JSON: "json",
+  INTERNAL: "internal",
+}
+
+exports.CanSwitchTypes = [
+  [exports.FieldTypes.JSON, exports.FieldTypes.ARRAY],
+  [
+    exports.FieldTypes.STRING,
+    exports.FieldTypes.OPTIONS,
+    exports.FieldTypes.LONGFORM,
+    exports.FieldTypes.BARCODEQR,
+  ],
+  [exports.FieldTypes.BOOLEAN, exports.FieldTypes.NUMBER],
+]
+
+exports.SwitchableTypes = exports.CanSwitchTypes.reduce((prev, current) =>
+  prev ? prev.concat(current) : current
+)
+
+exports.RelationshipTypes = {
+  ONE_TO_MANY: "one-to-many",
+  MANY_TO_ONE: "many-to-one",
+  MANY_TO_MANY: "many-to-many",
+}
+
+exports.FormulaTypes = {
+  STATIC: "static",
+  DYNAMIC: "dynamic",
+}
+
+exports.AuthTypes = {
+  APP: "app",
+  BUILDER: "builder",
+  EXTERNAL: "external",
+}
+
+exports.DataSourceOperation = {
+  CREATE: "CREATE",
+  READ: "READ",
+  UPDATE: "UPDATE",
+  DELETE: "DELETE",
+  BULK_CREATE: "BULK_CREATE",
+  CREATE_TABLE: "CREATE_TABLE",
+  UPDATE_TABLE: "UPDATE_TABLE",
+  DELETE_TABLE: "DELETE_TABLE",
+}
+
+exports.DatasourceAuthTypes = {
+  GOOGLE: "google",
+}
+
+exports.SortDirection = {
+  ASCENDING: "ASCENDING",
+  DESCENDING: "DESCENDING",
+}
+
+exports.USERS_TABLE_SCHEMA = {
+  _id: "ta_users",
+  type: "table",
+  views: {},
+  name: "Users",
+  // TODO: ADMIN PANEL - when implemented this doesn't need to be carried out
+  schema: {
+    email: {
+      type: exports.FieldTypes.STRING,
+      constraints: {
+        type: exports.FieldTypes.STRING,
+        email: true,
+        length: {
+          maximum: "",
+        },
+        presence: true,
+      },
+      fieldName: "email",
+      name: "email",
+    },
+    firstName: {
+      name: "firstName",
+      fieldName: "firstName",
+      type: exports.FieldTypes.STRING,
+      constraints: {
+        type: exports.FieldTypes.STRING,
+        presence: false,
+      },
+    },
+    lastName: {
+      name: "lastName",
+      fieldName: "lastName",
+      type: exports.FieldTypes.STRING,
+      constraints: {
+        type: exports.FieldTypes.STRING,
+        presence: false,
+      },
+    },
+    roleId: {
+      fieldName: "roleId",
+      name: "roleId",
+      type: exports.FieldTypes.OPTIONS,
+      constraints: {
+        type: exports.FieldTypes.STRING,
+        presence: false,
+        inclusion: Object.values(BUILTIN_ROLE_IDS),
+      },
+    },
+    status: {
+      fieldName: "status",
+      name: "status",
+      type: exports.FieldTypes.OPTIONS,
+      constraints: {
+        type: exports.FieldTypes.STRING,
+        presence: false,
+        inclusion: Object.values(UserStatus),
+      },
+    },
+  },
+  primaryDisplay: "email",
+}
+
+exports.AutoFieldSubTypes = {
+  CREATED_BY: "createdBy",
+  CREATED_AT: "createdAt",
+  UPDATED_BY: "updatedBy",
+  UPDATED_AT: "updatedAt",
+  AUTO_ID: "autoID",
+}
+
+exports.AutoFieldDefaultNames = {
+  CREATED_BY: "Created By",
+  CREATED_AT: "Created At",
+  UPDATED_BY: "Updated By",
+  UPDATED_AT: "Updated At",
+  AUTO_ID: "Auto ID",
+}
+
+exports.OBJ_STORE_DIRECTORY = "/prod-budi-app-assets"
+exports.BaseQueryVerbs = {
+  CREATE: "create",
+  READ: "read",
+  UPDATE: "update",
+  DELETE: "delete",
+}
+
+exports.MetadataTypes = {
+  AUTOMATION_TEST_INPUT: "automationTestInput",
+  AUTOMATION_TEST_HISTORY: "automationTestHistory",
+}
+
+exports.InvalidColumns = {
+  ID: "_id",
+  REV: "_rev",
+  TABLE_ID: "tableId",
+}
+
+exports.BuildSchemaErrors = {
+  NO_KEY: "no_key",
+  INVALID_COLUMN: "invalid_column",
+}
+
+exports.AutomationErrors = {
+  INCORRECT_TYPE: "INCORRECT_TYPE",
+  MAX_ITERATIONS: "MAX_ITERATIONS_REACHED",
+  FAILURE_CONDITION: "FAILURE_CONDITION_MET",
+}
+
+// pass through the list from the auth/core lib
+exports.ObjectStoreBuckets = objectStore.ObjectStoreBuckets
+
+exports.MAX_AUTOMATION_RECURRING_ERRORS = 5

package/src/constants/{layouts.ts → layouts.js}

@@ -1,9 +1,9 @@
-export const BASE_LAYOUT_PROP_IDS = {
+const BASE_LAYOUT_PROP_IDS = {
   PRIVATE: "layout_private_master",
   PUBLIC: "layout_public_master",
 }
 
-export const EMPTY_LAYOUT = {
+const EMPTY_LAYOUT = {
   componentLibraries: ["@budibase/standard-components"],
   title: "{{ name }}",
   favicon: "./_shared/favicon.png",
@@ -48,7 +48,7 @@ export const EMPTY_LAYOUT = {
   },
 }
 
-export const BASE_LAYOUTS = [
+const BASE_LAYOUTS = [
   {
     _id: BASE_LAYOUT_PROP_IDS.PRIVATE,
     componentLibraries: ["@budibase/standard-components"],
@@ -145,3 +145,9 @@ export const BASE_LAYOUTS = [
     },
   },
 ]
+
+module.exports = {
+  BASE_LAYOUTS,
+  BASE_LAYOUT_PROP_IDS,
+  EMPTY_LAYOUT,
+}

package/src/constants/screens.js

@@ -0,0 +1,46 @@
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
+const { BASE_LAYOUT_PROP_IDS } = require("./layouts")
+
+exports.createHomeScreen = () => ({
+  description: "",
+  url: "",
+  layoutId: BASE_LAYOUT_PROP_IDS.PRIVATE,
+  props: {
+    _id: "d834fea2-1b3e-4320-ab34-f9009f5ecc59",
+    _component: "@budibase/standard-components/container",
+    _styles: {
+      normal: {},
+      hover: {},
+      active: {},
+      selected: {},
+    },
+    _transition: "fade",
+    _children: [
+      {
+        _id: "ef60083f-4a02-4df3-80f3-a0d3d16847e7",
+        _component: "@budibase/standard-components/heading",
+        _styles: {
+          hover: {},
+          active: {},
+          selected: {},
+        },
+        text: "Welcome to your Budibase App 👋",
+        size: "M",
+        align: "left",
+        _instanceName: "Heading",
+        _children: [],
+      },
+    ],
+    _instanceName: "Home",
+    direction: "column",
+    hAlign: "stretch",
+    vAlign: "top",
+    size: "grow",
+    gap: "M",
+  },
+  routing: {
+    route: "/",
+    roleId: BUILTIN_ROLE_IDS.BASIC,
+  },
+  name: "home-screen",
+})

package/src/db/{dynamoClient.ts → dynamoClient.js}

@@ -1,7 +1,8 @@
-import { merge } from "lodash"
-import env from "../environment"
+let { merge } = require("lodash")
+let env = require("../environment")
 
-export const AWS_REGION = env.AWS_REGION ? env.AWS_REGION : "eu-west-1"
+const AWS_REGION = env.AWS_REGION ? env.AWS_REGION : "eu-west-1"
+exports.AWS_REGION = AWS_REGION
 
 const TableInfo = {
   API_KEYS: {
@@ -15,36 +16,10 @@ const TableInfo = {
   },
 }
 
-let docClient: any = null
-
-type GetOpts = {
-  primary: string
-  sort?: string
-  otherProps?: any
-}
-
-type UpdateOpts = {
-  primary: string
-  sort?: string
-  expression?: string
-  condition?: string
-  names?: string[]
-  values?: any[]
-  exists?: boolean
-  otherProps?: any
-}
-
-type PutOpts = {
-  item: any
-  otherProps?: any
-}
+let docClient = null
 
 class Table {
-  _name: string
-  _primary: string
-  _sort?: string
-
-  constructor(tableInfo: { name: string; primary: string; sort?: string }) {
+  constructor(tableInfo) {
     if (!tableInfo.name || !tableInfo.primary) {
       throw "Table info must specify a name and a primary key"
     }
@@ -53,7 +28,7 @@ class Table {
     this._sort = tableInfo.sort
   }
 
-  async get({ primary, sort, otherProps }: GetOpts) {
+  async get({ primary, sort, otherProps }) {
     let params = {
       TableName: this._name,
       Key: {
@@ -79,8 +54,8 @@ class Table {
     values,
     exists,
     otherProps,
-  }: UpdateOpts) {
-    let params: any = {
+  }) {
+    let params = {
       TableName: this._name,
       Key: {
         [this._primary]: primary,
@@ -108,7 +83,7 @@ class Table {
     return docClient.update(params).promise()
   }
 
-  async put({ item, otherProps }: PutOpts) {
+  async put({ item, otherProps }) {
     if (
       item[this._primary] == null ||
       (this._sort && item[this._sort] == null)
@@ -126,9 +101,9 @@ class Table {
   }
 }
 
-export function init(endpoint: string) {
+exports.init = endpoint => {
   let AWS = require("aws-sdk")
-  let docClientParams: any = {
+  let docClientParams = {
     correctClockSkew: true,
     region: AWS_REGION,
   }
@@ -140,8 +115,13 @@ export function init(endpoint: string) {
   docClient = new AWS.DynamoDB.DocumentClient(docClientParams)
 }
 
-if (!env.isProd()) {
+exports.apiKeyTable = new Table(TableInfo.API_KEYS)
+exports.userTable = new Table(TableInfo.USERS)
+
+if (env.isProd()) {
+  exports.init(`https://dynamodb.${AWS_REGION}.amazonaws.com`)
+} else {
   env._set("AWS_ACCESS_KEY_ID", "KEY_ID")
   env._set("AWS_SECRET_ACCESS_KEY", "SECRET_KEY")
-  init("http://localhost:8333")
+  exports.init("http://localhost:8333")
 }

package/src/db/{inMemoryView.ts → inMemoryView.js}

@@ -1,17 +1,11 @@
-import newid from "./newid"
-import { Row, View, Document } from "@budibase/types"
+const newid = require("./newid")
 
 // bypass the main application db config
 // use in memory pouchdb directly
-import { db as dbCore } from "@budibase/backend-core"
-const Pouch = dbCore.getPouch({ inMemory: true })
+const { getPouch, closeDB } = require("@budibase/backend-core/db")
+const Pouch = getPouch({ inMemory: true })
 
-export async function runView(
-  view: View,
-  calculation: string,
-  group: boolean,
-  data: Row[]
-) {
+exports.runView = async (view, calculation, group, data) => {
   // use a different ID each time for the DB, make sure they
   // are always unique for each query, don't want overlap
   // which could cause 409s
@@ -24,16 +18,16 @@ export async function runView(
         _rev: undefined,
       }))
     )
-    let fn = (doc: Document, emit: any) => emit(doc._id)
-    eval("fn = " + view?.map?.replace("function (doc)", "function (doc, emit)"))
-    const queryFns: any = {
+    let fn = (doc, emit) => emit(doc._id)
+    eval("fn = " + view.map.replace("function (doc)", "function (doc, emit)"))
+    const queryFns = {
       meta: view.meta,
       map: fn,
     }
     if (view.reduce) {
       queryFns.reduce = view.reduce
     }
-    const response: { rows: Row[] } = await db.query(queryFns, {
+    const response = await db.query(queryFns, {
       include_docs: !calculation,
       group: !!group,
     })
@@ -50,6 +44,6 @@ export async function runView(
     return response
   } finally {
     await db.destroy()
-    await dbCore.closePouchDB(db)
+    await closeDB(db)
   }
 }

package/src/db/index.js

@@ -0,0 +1,16 @@
+const core = require("@budibase/backend-core")
+const env = require("../environment")
+
+exports.init = () => {
+  const dbConfig = {
+    replication: true,
+    find: true,
+  }
+
+  if (env.isTest() && !env.COUCH_DB_URL) {
+    dbConfig.inMemory = true
+    dbConfig.allDbs = true
+  }
+
+  core.init({ db: dbConfig })
+}