@budibase/server 2.6.18 → 2.6.19-alpha.0

package/jest.config.ts

@@ -20,9 +20,9 @@ const baseConfig: Config.InitialProjectOptions = {
 }
 
 // add pro sources if they exist
-if (fs.existsSync("../../../budibase-pro")) {
-  baseConfig.moduleNameMapper["@budibase/pro"] =
-    "<rootDir>/../../../budibase-pro/packages/pro/src"
+if (fs.existsSync("../pro/packages")) {
+  baseConfig.moduleNameMapper!["@budibase/pro"] =
+    "<rootDir>/../pro/packages/pro/src"
 }
 
 const config: Config.InitialOptions = {

package/nodemon.json

@@ -1,6 +1,10 @@
 {
-  "watch": ["src", "../backend-core", "../../../budibase-pro/packages/pro"],
+  "watch": ["src", "../backend-core", "../pro/packages/pro"],
   "ext": "js,ts,json",
-  "ignore": ["src/**/*.spec.ts", "src/**/*.spec.js", "../backend-core/dist/**/*"],
+  "ignore": [
+    "src/**/*.spec.ts",
+    "src/**/*.spec.js",
+    "../backend-core/dist/**/*"
+  ],
   "exec": "ts-node src/index.ts"
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "2.6.18",
+  "version": "2.6.19-alpha.0",
   "description": "Budibase Web Server",
   "main": "src/index.ts",
   "repository": {
@@ -45,12 +45,12 @@
   "license": "GPL-3.0",
   "dependencies": {
     "@apidevtools/swagger-parser": "10.0.3",
-    "@budibase/backend-core": "^2.6.18",
-    "@budibase/client": "^2.6.18",
-    "@budibase/pro": "2.6.17",
-    "@budibase/shared-core": "^2.6.18",
-    "@budibase/string-templates": "^2.6.18",
-    "@budibase/types": "^2.6.18",
+    "@budibase/backend-core": "2.6.19-alpha.0",
+    "@budibase/client": "2.6.19-alpha.0",
+    "@budibase/pro": "2.6.19-alpha.0",
+    "@budibase/shared-core": "2.6.19-alpha.0",
+    "@budibase/string-templates": "2.6.19-alpha.0",
+    "@budibase/types": "2.6.19-alpha.0",
     "@bull-board/api": "3.7.0",
     "@bull-board/koa": "3.9.4",
     "@elastic/elasticsearch": "7.10.0",
@@ -99,7 +99,7 @@
     "mysql2": "2.3.3",
     "node-fetch": "2.6.7",
     "open": "8.4.0",
-    "pg": "8.5.1",
+    "pg": "8.10.0",
     "posthog-node": "1.3.0",
     "pouchdb": "7.3.0",
     "pouchdb-adapter-memory": "7.2.2",
@@ -141,6 +141,7 @@
     "@types/node": "14.18.20",
     "@types/node-fetch": "2.6.1",
     "@types/oracledb": "5.2.2",
+    "@types/pg": "8.6.6",
     "@types/pouchdb": "6.4.0",
     "@types/redis": "4.0.11",
     "@types/server-destroy": "1.0.1",
@@ -176,5 +177,5 @@
   "optionalDependencies": {
     "oracledb": "5.3.0"
   },
-  "gitHead": "6e97c358e00e4a7be0c620858c564960c393c1b8"
+  "gitHead": "82e867c0f5b41fe3af88333effeb88f29b8b4d23"
 }

package/src/api/controllers/datasource.ts

@@ -18,11 +18,71 @@ import {
   Row,
   CreateDatasourceResponse,
   UpdateDatasourceResponse,
-  UpdateDatasourceRequest,
   CreateDatasourceRequest,
+  VerifyDatasourceRequest,
+  VerifyDatasourceResponse,
+  IntegrationBase,
+  DatasourcePlus,
 } from "@budibase/types"
 import sdk from "../../sdk"
 
+function getErrorTables(errors: any, errorType: string) {
+  return Object.entries(errors)
+    .filter(entry => entry[1] === errorType)
+    .map(([name]) => name)
+}
+
+function updateError(error: any, newError: any, tables: string[]) {
+  if (!error) {
+    error = ""
+  }
+  if (error.length > 0) {
+    error += "\n"
+  }
+  error += `${newError} ${tables.join(", ")}`
+  return error
+}
+
+async function getConnector(
+  datasource: Datasource
+): Promise<IntegrationBase | DatasourcePlus> {
+  const Connector = await getIntegration(datasource.source)
+  // can't enrich if it doesn't have an ID yet
+  if (datasource._id) {
+    datasource = await sdk.datasources.enrich(datasource)
+  }
+  // Connect to the DB and build the schema
+  return new Connector(datasource.config)
+}
+
+async function buildSchemaHelper(datasource: Datasource) {
+  const connector = (await getConnector(datasource)) as DatasourcePlus
+  await connector.buildSchema(datasource._id!, datasource.entities!)
+
+  const errors = connector.schemaErrors
+  let error = null
+  if (errors && Object.keys(errors).length > 0) {
+    const noKey = getErrorTables(errors, BuildSchemaErrors.NO_KEY)
+    const invalidCol = getErrorTables(errors, BuildSchemaErrors.INVALID_COLUMN)
+    if (noKey.length) {
+      error = updateError(
+        error,
+        "No primary key constraint found for the following:",
+        noKey
+      )
+    }
+    if (invalidCol.length) {
+      const invalidCols = Object.values(InvalidColumns).join(", ")
+      error = updateError(
+        error,
+        `Cannot use columns ${invalidCols} found in following:`,
+        invalidCol
+      )
+    }
+  }
+  return { tables: connector.tables, error }
+}
+
 export async function fetch(ctx: UserCtx) {
   // Get internal tables
   const db = context.getAppDB()
@@ -66,6 +126,33 @@ export async function fetch(ctx: UserCtx) {
   ctx.body = [bbInternalDb, ...datasources]
 }
 
+export async function verify(
+  ctx: UserCtx<VerifyDatasourceRequest, VerifyDatasourceResponse>
+) {
+  const { datasource } = ctx.request.body
+  let existingDatasource: undefined | Datasource
+  if (datasource._id) {
+    existingDatasource = await sdk.datasources.get(datasource._id)
+  }
+  let enrichedDatasource = datasource
+  if (existingDatasource) {
+    enrichedDatasource = sdk.datasources.mergeConfigs(
+      datasource,
+      existingDatasource
+    )
+  }
+  const connector = await getConnector(enrichedDatasource)
+  if (!connector.testConnection) {
+    ctx.throw(400, "Connection information verification not supported")
+  }
+  const response = await connector.testConnection()
+
+  ctx.body = {
+    connected: response.connected,
+    error: response.error,
+  }
+}
+
 export async function buildSchemaFromDb(ctx: UserCtx) {
   const db = context.getAppDB()
   const datasource = await sdk.datasources.get(ctx.params.datasourceId)
@@ -311,51 +398,3 @@ export async function query(ctx: UserCtx) {
     ctx.throw(400, err)
   }
 }
-
-function getErrorTables(errors: any, errorType: string) {
-  return Object.entries(errors)
-    .filter(entry => entry[1] === errorType)
-    .map(([name]) => name)
-}
-
-function updateError(error: any, newError: any, tables: string[]) {
-  if (!error) {
-    error = ""
-  }
-  if (error.length > 0) {
-    error += "\n"
-  }
-  error += `${newError} ${tables.join(", ")}`
-  return error
-}
-
-async function buildSchemaHelper(datasource: Datasource) {
-  const Connector = await getIntegration(datasource.source)
-  datasource = await sdk.datasources.enrich(datasource)
-  // Connect to the DB and build the schema
-  const connector = new Connector(datasource.config)
-  await connector.buildSchema(datasource._id, datasource.entities)
-
-  const errors = connector.schemaErrors
-  let error = null
-  if (errors && Object.keys(errors).length > 0) {
-    const noKey = getErrorTables(errors, BuildSchemaErrors.NO_KEY)
-    const invalidCol = getErrorTables(errors, BuildSchemaErrors.INVALID_COLUMN)
-    if (noKey.length) {
-      error = updateError(
-        error,
-        "No primary key constraint found for the following:",
-        noKey
-      )
-    }
-    if (invalidCol.length) {
-      const invalidCols = Object.values(InvalidColumns).join(", ")
-      error = updateError(
-        error,
-        `Cannot use columns ${invalidCols} found in following:`,
-        invalidCol
-      )
-    }
-  }
-  return { tables: connector.tables, error }
-}

package/src/api/controllers/integration.ts

@@ -1,4 +1,4 @@
-import { getDefinitions } from "../../integrations"
+import { getDefinition, getDefinitions } from "../../integrations"
 import { BBContext } from "@budibase/types"
 
 export async function fetch(ctx: BBContext) {
@@ -7,7 +7,7 @@ export async function fetch(ctx: BBContext) {
 }
 
 export async function find(ctx: BBContext) {
-  const defs = await getDefinitions()
+  const def = await getDefinition(ctx.params.type)
+  ctx.body = def
   ctx.status = 200
-  ctx.body = defs[ctx.params.type]
 }

package/src/api/routes/datasource.ts

@@ -15,6 +15,11 @@ router
     authorized(permissions.BUILDER),
     datasourceController.fetch
   )
+  .post(
+    "/api/datasources/verify",
+    authorized(permissions.BUILDER),
+    datasourceController.verify
+  )
   .get(
     "/api/datasources/:datasourceId",
     authorized(

package/src/automations/steps/make.ts

@@ -26,6 +26,10 @@ export const definition: AutomationStepSchema = {
           type: AutomationIOType.STRING,
           title: "Webhook URL",
         },
+        body: {
+          type: AutomationIOType.JSON,
+          title: "Payload",
+        },
         value1: {
           type: AutomationIOType.STRING,
           title: "Input Value 1",
@@ -70,7 +74,19 @@ export const definition: AutomationStepSchema = {
 }
 
 export async function run({ inputs }: AutomationStepInput) {
-  const { url, value1, value2, value3, value4, value5 } = inputs
+  //TODO - Remove deprecated values 1,2,3,4,5 after November 2023
+  const { url, value1, value2, value3, value4, value5, body } = inputs
+
+  let payload = {}
+  try {
+    payload = body?.value ? JSON.parse(body?.value) : {}
+  } catch (err) {
+    return {
+      httpStatus: 400,
+      response: "Invalid payload JSON",
+      success: false,
+    }
+  }
 
   if (!url?.trim()?.length) {
     return {
@@ -89,6 +105,7 @@ export async function run({ inputs }: AutomationStepInput) {
         value3,
         value4,
         value5,
+        ...payload,
       }),
       headers: {
         "Content-Type": "application/json",

package/src/automations/steps/zapier.ts

@@ -24,6 +24,10 @@ export const definition: AutomationStepSchema = {
           type: AutomationIOType.STRING,
           title: "Webhook URL",
         },
+        body: {
+          type: AutomationIOType.JSON,
+          title: "Payload",
+        },
         value1: {
           type: AutomationIOType.STRING,
           title: "Payload Value 1",
@@ -63,7 +67,19 @@ export const definition: AutomationStepSchema = {
 }
 
 export async function run({ inputs }: AutomationStepInput) {
-  const { url, value1, value2, value3, value4, value5 } = inputs
+  //TODO - Remove deprecated values 1,2,3,4,5 after November 2023
+  const { url, value1, value2, value3, value4, value5, body } = inputs
+
+  let payload = {}
+  try {
+    payload = body?.value ? JSON.parse(body?.value) : {}
+  } catch (err) {
+    return {
+      httpStatus: 400,
+      response: "Invalid payload JSON",
+      success: false,
+    }
+  }
 
   if (!url?.trim()?.length) {
     return {
@@ -85,6 +101,7 @@ export async function run({ inputs }: AutomationStepInput) {
         value3,
         value4,
         value5,
+        ...payload,
       }),
       headers: {
         "Content-Type": "application/json",

package/src/automations/tests/make.spec.ts

@@ -0,0 +1,54 @@
+import { getConfig, afterAll, runStep, actions } from "./utilities"
+
+describe("test the outgoing webhook action", () => {
+  let config = getConfig()
+
+  beforeAll(async () => {
+    await config.init()
+  })
+
+  afterAll()
+
+  it("should be able to run the action", async () => {
+    const res = await runStep(actions.integromat.stepId, {
+      value1: "test",
+      url: "http://www.test.com",
+    })
+    expect(res.response.url).toEqual("http://www.test.com")
+    expect(res.response.method).toEqual("post")
+    expect(res.success).toEqual(true)
+  })
+
+  it("should add the payload props when a JSON string is provided", async () => {
+    const payload = `{"value1":1,"value2":2,"value3":3,"value4":4,"value5":5,"name":"Adam","age":9}`
+    const res = await runStep(actions.integromat.stepId, {
+      value1: "ONE",
+      value2: "TWO",
+      value3: "THREE",
+      value4: "FOUR",
+      value5: "FIVE",
+      body: {
+        value: payload,
+      },
+      url: "http://www.test.com",
+    })
+    expect(res.response.url).toEqual("http://www.test.com")
+    expect(res.response.method).toEqual("post")
+    expect(res.response.body).toEqual(payload)
+    expect(res.success).toEqual(true)
+  })
+
+  it("should return a 400 if the JSON payload string is malformed", async () => {
+    const payload = `{ value1 1 }`
+    const res = await runStep(actions.integromat.stepId, {
+      value1: "ONE",
+      body: {
+        value: payload,
+      },
+      url: "http://www.test.com",
+    })
+    expect(res.httpStatus).toEqual(400)
+    expect(res.response).toEqual("Invalid payload JSON")
+    expect(res.success).toEqual(false)
+  })
+})

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

@@ -0,0 +1,56 @@
+import { getConfig, afterAll, runStep, actions } from "./utilities"
+
+describe("test the outgoing webhook action", () => {
+  let config = getConfig()
+
+  beforeAll(async () => {
+    await config.init()
+  })
+
+  afterAll()
+
+  it("should be able to run the action", async () => {
+    const res = await runStep(actions.zapier.stepId, {
+      value1: "test",
+      url: "http://www.test.com",
+    })
+    expect(res.response.url).toEqual("http://www.test.com")
+    expect(res.response.method).toEqual("post")
+    expect(res.success).toEqual(true)
+  })
+
+  it("should add the payload props when a JSON string is provided", async () => {
+    const payload = `{ "value1": 1, "value2": 2, "value3": 3, "value4": 4, "value5": 5, "name": "Adam", "age": 9 }`
+    const res = await runStep(actions.zapier.stepId, {
+      value1: "ONE",
+      value2: "TWO",
+      value3: "THREE",
+      value4: "FOUR",
+      value5: "FIVE",
+      body: {
+        value: payload,
+      },
+      url: "http://www.test.com",
+    })
+    expect(res.response.url).toEqual("http://www.test.com")
+    expect(res.response.method).toEqual("post")
+    expect(res.response.body).toEqual(
+      `{"platform":"budibase","value1":1,"value2":2,"value3":3,"value4":4,"value5":5,"name":"Adam","age":9}`
+    )
+    expect(res.success).toEqual(true)
+  })
+
+  it("should return a 400 if the JSON payload string is malformed", async () => {
+    const payload = `{ value1 1 }`
+    const res = await runStep(actions.zapier.stepId, {
+      value1: "ONE",
+      body: {
+        value: payload,
+      },
+      url: "http://www.test.com",
+    })
+    expect(res.httpStatus).toEqual(400)
+    expect(res.response).toEqual("Invalid payload JSON")
+    expect(res.success).toEqual(false)
+  })
+})

package/src/automations/utils.ts

@@ -17,10 +17,16 @@ const CRON_STEP_ID = definitions.CRON.stepId
 const Runner = new Thread(ThreadType.AUTOMATION)
 
 function loggingArgs(job: AutomationJob) {
-  return {
-    jobId: job.id,
-    trigger: job.data.automation.definition.trigger.event,
-  }
+  return [
+    {
+      _logKey: "automation",
+      trigger: job.data.automation.definition.trigger.event,
+    },
+    {
+      _logKey: "bull",
+      jobId: job.id,
+    },
+  ]
 }
 
 export async function processEvent(job: AutomationJob) {
@@ -29,16 +35,16 @@ export async function processEvent(job: AutomationJob) {
   const task = async () => {
     try {
       // need to actually await these so that an error can be captured properly
-      console.log("automation running", loggingArgs(job))
+      console.log("automation running", ...loggingArgs(job))
 
       const runFn = () => Runner.run(job)
       const result = await quotas.addAutomation(runFn, {
         automationId,
       })
-      console.log("automation completed", loggingArgs(job))
+      console.log("automation completed", ...loggingArgs(job))
       return result
     } catch (err) {
-      console.error(`automation was unable to run`, err, loggingArgs(job))
+      console.error(`automation was unable to run`, err, ...loggingArgs(job))
       return { err }
     }
   }

package/src/db/dynamoClient.ts

@@ -140,7 +140,7 @@ export function init(endpoint: string) {
   docClient = new AWS.DynamoDB.DocumentClient(docClientParams)
 }
 
-if (!env.isProd()) {
+if (!env.isProd() && !env.isJest()) {
   env._set("AWS_ACCESS_KEY_ID", "KEY_ID")
   env._set("AWS_SECRET_ACCESS_KEY", "SECRET_KEY")
   init("http://localhost:8333")

package/src/integration-test/postgres.spec.ts

@@ -19,7 +19,6 @@ import _ from "lodash"
 import { generator } from "@budibase/backend-core/tests"
 import { utils } from "@budibase/backend-core"
 import { GenericContainer } from "testcontainers"
-import { generateRowIdField } from "../integrations/utils"
 
 const config = setup.getConfig()!
 

package/src/integrations/airtable.ts

@@ -1,11 +1,13 @@
 import {
-  Integration,
+  ConnectionInfo,
+  DatasourceFeature,
   DatasourceFieldType,
-  QueryType,
+  Integration,
   IntegrationBase,
+  QueryType,
 } from "@budibase/types"
 
-const Airtable = require("airtable")
+import Airtable from "airtable"
 
 interface AirtableConfig {
   apiKey: string
@@ -18,6 +20,7 @@ const SCHEMA: Integration = {
     "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
   friendlyName: "Airtable",
   type: "Spreadsheet",
+  features: [DatasourceFeature.CONNECTION_CHECKING],
   datasource: {
     apiKey: {
       type: DatasourceFieldType.PASSWORD,
@@ -81,13 +84,37 @@ const SCHEMA: Integration = {
 
 class AirtableIntegration implements IntegrationBase {
   private config: AirtableConfig
-  private client: any
+  private client
 
   constructor(config: AirtableConfig) {
     this.config = config
     this.client = new Airtable(config).base(config.base)
   }
 
+  async testConnection(): Promise<ConnectionInfo> {
+    const mockTable = Date.now().toString()
+    try {
+      await this.client.makeRequest({
+        path: `/${mockTable}`,
+      })
+
+      return { connected: true }
+    } catch (e: any) {
+      if (
+        e.message ===
+        `Could not find table ${mockTable} in application ${this.config.base}`
+      ) {
+        // The request managed to check the application, so the credentials are valid
+        return { connected: true }
+      }
+
+      return {
+        connected: false,
+        error: e.message as string,
+      }
+    }
+  }
+
   async create(query: { table: any; json: any }) {
     const { table, json } = query
 

package/src/integrations/arangodb.ts

@@ -3,9 +3,11 @@ import {
   DatasourceFieldType,
   QueryType,
   IntegrationBase,
+  DatasourceFeature,
+  ConnectionInfo,
 } from "@budibase/types"
 
-const { Database, aql } = require("arangojs")
+import { Database, aql } from "arangojs"
 
 interface ArangodbConfig {
   url: string
@@ -21,6 +23,7 @@ const SCHEMA: Integration = {
   type: "Non-relational",
   description:
     "ArangoDB is a scalable open-source multi-model database natively supporting graph, document and search. All supported data models & access patterns can be combined in queries allowing for maximal flexibility. ",
+  features: [DatasourceFeature.CONNECTION_CHECKING],
   datasource: {
     url: {
       type: DatasourceFieldType.STRING,
@@ -58,7 +61,7 @@ const SCHEMA: Integration = {
 
 class ArangoDBIntegration implements IntegrationBase {
   private config: ArangodbConfig
-  private client: any
+  private client
 
   constructor(config: ArangodbConfig) {
     const newConfig = {
@@ -74,6 +77,19 @@ class ArangoDBIntegration implements IntegrationBase {
     this.client = new Database(newConfig)
   }
 
+  async testConnection() {
+    const response: ConnectionInfo = {
+      connected: false,
+    }
+    try {
+      await this.client.get()
+      response.connected = true
+    } catch (e: any) {
+      response.error = e.message as string
+    }
+    return response
+  }
+
   async read(query: { sql: any }) {
     try {
       const result = await this.client.query(query.sql)

package/src/integrations/couchdb.ts

@@ -1,4 +1,6 @@
 import {
+  ConnectionInfo,
+  DatasourceFeature,
   DatasourceFieldType,
   Document,
   Integration,
@@ -18,6 +20,7 @@ const SCHEMA: Integration = {
   type: "Non-relational",
   description:
     "Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang.",
+  features: [DatasourceFeature.CONNECTION_CHECKING],
   datasource: {
     url: {
       type: DatasourceFieldType.STRING,
@@ -61,21 +64,32 @@ const SCHEMA: Integration = {
 }
 
 class CouchDBIntegration implements IntegrationBase {
-  private config: CouchDBConfig
-  private readonly client: any
+  private readonly client: dbCore.DatabaseImpl
 
   constructor(config: CouchDBConfig) {
-    this.config = config
     this.client = dbCore.DatabaseWithConnection(config.database, config.url)
   }
 
+  async testConnection() {
+    const response: ConnectionInfo = {
+      connected: false,
+    }
+    try {
+      const result = await this.query("exists", "validation error", {})
+      response.connected = result === true
+    } catch (e: any) {
+      response.error = e.message as string
+    }
+    return response
+  }
+
   async query(
     command: string,
     errorMsg: string,
     query: { json?: object; id?: string }
   ) {
     try {
-      return await this.client[command](query.id || query.json)
+      return await (this.client as any)[command](query.id || query.json)
     } catch (err) {
       console.error(errorMsg, err)
       throw err