@budibase/server 2.2.26 → 2.2.27-alpha.0

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

@@ -0,0 +1,27 @@
+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 = {
+            username: "joe_bloggs",
+            url: "http://www.test.com",
+        }
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to run the action", async () => {
+        const res = await setup.runStep(setup.actions.discord.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/tests/executeQuery.spec.js

@@ -0,0 +1,49 @@
+const setup = require("./utilities")
+
+describe("test the execute query action", () => {
+    let datasource
+    let config = setup.getConfig()
+
+    beforeEach(async () => {
+        await config.init()
+
+        await config.createDatasource()
+        query = await config.createQuery()
+
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: query._id }
+            }
+        )
+        expect(res.response).toEqual([{ a: 'string', b: 1 }])
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null query value", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: null
+            }
+        )
+        expect(res.response.message).toEqual("Invalid inputs")
+        expect(res.success).toEqual(false)
+    })
+
+
+    it("should handle an error executing a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: "wrong_id" }
+            }
+        )
+        expect(res.response).toEqual('{"status":404,"name":"not_found","message":"missing","reason":"missing"}')
+        expect(res.success).toEqual(false)
+    })
+
+
+})

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

@@ -0,0 +1,48 @@
+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/loop.spec.ts

@@ -0,0 +1,45 @@
+import * as automation from "../index"
+import * as triggers from "../triggers"
+import { loopAutomation } from "../../tests/utilities/structures"
+import { context } from "@budibase/backend-core"
+import * as setup from "./utilities"
+
+describe("Attempt to run a basic loop automation", () => {
+  let config = setup.getConfig(),
+    table: any,
+    row: any
+
+  beforeEach(async () => {
+    await automation.init()
+    await config.init()
+    table = await config.createTable()
+    row = await config.createRow()
+  })
+
+  afterAll(setup.afterAll)
+
+  async function runLoop(loopOpts?: any) {
+    const appId = config.getAppId()
+    return await context.doInAppContext(appId, async () => {
+      const params = { fields: { appId } }
+      return await triggers.externalTrigger(
+        loopAutomation(table._id, loopOpts),
+        params,
+        { getResponses: true }
+      )
+    })
+  }
+
+  it("attempt to run a basic loop", async () => {
+    const resp = await runLoop()
+    expect(resp.steps[2].outputs.iterations).toBe(1)
+  })
+
+  it("test a loop with a string", async () => {
+    const resp = await runLoop({
+      type: "String",
+      binding: "a,b,c",
+    })
+    expect(resp.steps[2].outputs.iterations).toBe(3)
+  })
+})

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

@@ -0,0 +1,71 @@
+
+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

@@ -0,0 +1,22 @@
+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/utilities/index.ts

@@ -31,7 +31,7 @@ export async function runInProd(fn: any) {
   }
 }
 
-export async function runStep(stepId: string, inputs: any) {
+export async function runStep(stepId: string, inputs: any, stepContext?: any) {
   async function run() {
     let step = await getAction(stepId)
     expect(step).toBeDefined()
@@ -39,7 +39,7 @@ export async function runStep(stepId: string, inputs: any) {
       throw new Error("No step found")
     }
     return step({
-      context: {},
+      context: stepContext || {},
       inputs,
       appId: config ? config.getAppId() : null,
       // don't really need an API key, mocked out usage quota, not being tested here

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

@@ -0,0 +1,27 @@
+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/triggers.ts

@@ -109,8 +109,13 @@ export async function externalTrigger(
     }
     params.fields = coercedFields
   }
-  const data = { automation, event: params }
+  const data: Record<string, any> = { automation, event: params }
   if (getResponses) {
+    data.event = {
+      ...data.event,
+      appId: context.getAppId(),
+      automation,
+    }
     return utils.processEvent({ data })
   } else {
     return automationQueue.add(data, JOB_OPTS)

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

@@ -0,0 +1,65 @@
+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/db/index.ts

@@ -1,5 +1,5 @@
 import { init as coreInit } from "@budibase/backend-core"
-import env = require("../environment")
+import env from "../environment"
 
 export function init() {
   const dbConfig: any = {

package/src/db/linkedRows/LinkController.ts

@@ -441,4 +441,4 @@ class LinkController {
   }
 }
 
-export = LinkController
+export default LinkController

package/src/db/linkedRows/LinkDocument.ts

@@ -57,4 +57,4 @@ class LinkDocumentImpl implements LinkDocument {
   }
 }
 
-export = LinkDocumentImpl
+export default LinkDocumentImpl

package/src/db/newid.ts

@@ -1,5 +1,5 @@
 const { v4 } = require("uuid")
 
-export = function (): string {
+export default function (): string {
   return v4().replace(/-/g, "")
 }

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

@@ -1,6 +1,6 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
 const { basicRow, basicLinkedRow, basicTable } = require("../../tests/utilities/structures")
-const LinkController = require("../linkedRows/LinkController")
+const LinkController = require("../linkedRows/LinkController").default
 const { context } = require("@budibase/backend-core")
 const { RelationshipTypes } = require("../../constants")
 const { cloneDeep } = require("lodash/fp")

package/src/definitions/automations.ts

@@ -24,6 +24,7 @@ export interface TriggerOutput {
 
 export interface AutomationContext extends AutomationResults {
   steps: any[]
+  env?: Record<string, string>
   trigger: any
 }
 

package/src/definitions/datasource.ts

@@ -7,44 +7,3 @@
 export interface QueryOptions {
   disableReturning?: boolean
 }
-
-export enum AuthType {
-  BASIC = "basic",
-  BEARER = "bearer",
-}
-
-interface AuthConfig {
-  _id: string
-  name: string
-  type: AuthType
-  config: BasicAuthConfig | BearerAuthConfig
-}
-
-export interface BasicAuthConfig {
-  username: string
-  password: string
-}
-
-export interface BearerAuthConfig {
-  token: string
-}
-
-export interface RestConfig {
-  url: string
-  rejectUnauthorized: boolean
-  defaultHeaders: {
-    [key: string]: any
-  }
-  legacyHttpParser: boolean
-  authConfigs: AuthConfig[]
-  staticVariables: {
-    [key: string]: string
-  }
-  dynamicVariables: [
-    {
-      name: string
-      queryId: string
-      value: string
-    }
-  ]
-}

package/src/definitions/openapi.ts

@@ -102,6 +102,16 @@ export interface components {
         lockedBy?: { [key: string]: unknown };
       };
     };
+    deploymentOutput: {
+      data: {
+        /** @description The ID of the deployment. */
+        _id: string;
+        /** @description The status of the deployment. */
+        status: "SUCCESS" | "FAILURE";
+        /** @description The URL by which the published app is accessed. */
+        appUrl?: string;
+      }
+    };
     applicationSearch: {
       data: {
         /** @description The name of the app. */

package/src/environment.ts

@@ -79,7 +79,6 @@ const environment = {
   // flags
   ALLOW_DEV_AUTOMATIONS: process.env.ALLOW_DEV_AUTOMATIONS,
   DISABLE_THREADING: process.env.DISABLE_THREADING,
-  DISABLE_DEVELOPER_LICENSE: process.env.DISABLE_DEVELOPER_LICENSE,
   DISABLE_AUTOMATION_LOGS: process.env.DISABLE_AUTOMATION_LOGS,
   MULTI_TENANCY: process.env.MULTI_TENANCY,
   ENABLE_ANALYTICS: process.env.ENABLE_ANALYTICS,
@@ -119,6 +118,11 @@ for (let [key, value] of Object.entries(environment)) {
     // @ts-ignore
     environment[key] = 0
   }
+  // handle the edge case of "false" to disable an environment variable
+  if (value === "false") {
+    // @ts-ignore
+    environment[key] = 0
+  }
 }
 
-export = environment
+export default environment

package/src/events/AutomationEmitter.ts

@@ -55,4 +55,4 @@ class AutomationEmitter {
   }
 }
 
-export = AutomationEmitter
+export default AutomationEmitter

package/src/events/BudibaseEmitter.ts

@@ -26,4 +26,4 @@ class BudibaseEmitter extends EventEmitter {
   }
 }
 
-export = BudibaseEmitter
+export default BudibaseEmitter

package/src/events/index.ts

@@ -2,4 +2,4 @@ import BudibaseEmitter from "./BudibaseEmitter"
 
 const emitter = new BudibaseEmitter()
 
-export = emitter
+export default emitter

package/src/index.ts

@@ -1,6 +1,6 @@
 import { bootstrap } from "global-agent"
 const fixPath = require("fix-path")
-const { checkDevelopmentEnvironment } = require("./utilities/fileSystem")
+import { checkDevelopmentEnvironment } from "./utilities/fileSystem"
 
 function runServer() {
   // this will shutdown the system if development environment not ready

package/src/integrations/base/query.ts

@@ -1,10 +1,12 @@
 import { QueryJson, Datasource } from "@budibase/types"
-const { getIntegration } = require("../index")
+import { getIntegration } from "../index"
+import sdk from "../../sdk"
 
 export async function makeExternalQuery(
   datasource: Datasource,
   json: QueryJson
 ) {
+  datasource = await sdk.datasources.enrich(datasource)
   const Integration = await getIntegration(datasource.source)
   // query is the opinionated function
   if (Integration.prototype.query) {

package/src/integrations/base/sqlTable.ts

@@ -3,7 +3,7 @@ import { Operation, QueryJson, RenameColumn, Table } from "@budibase/types"
 import { breakExternalTableId } from "../utils"
 import SchemaBuilder = Knex.SchemaBuilder
 import CreateTableBuilder = Knex.CreateTableBuilder
-const { FieldTypes, RelationshipTypes } = require("../../constants")
+import { FieldTypes, RelationshipTypes } from "../../constants"
 
 function generateSchema(
   schema: CreateTableBuilder,

package/src/integrations/couchdb.ts

@@ -1,11 +1,11 @@
 import {
-  Integration,
   DatasourceFieldType,
-  QueryType,
+  Document,
+  Integration,
   IntegrationBase,
+  QueryType,
 } from "@budibase/types"
-
-const PouchDB = require("pouchdb")
+import { db as dbCore } from "@budibase/backend-core"
 
 interface CouchDBConfig {
   url: string
@@ -39,6 +39,15 @@ const SCHEMA: Integration = {
     update: {
       type: QueryType.JSON,
     },
+    get: {
+      type: QueryType.FIELDS,
+      fields: {
+        id: {
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
+      },
+    },
     delete: {
       type: QueryType.FIELDS,
       fields: {
@@ -57,7 +66,7 @@ class CouchDBIntegration implements IntegrationBase {
 
   constructor(config: CouchDBConfig) {
     this.config = config
-    this.client = new PouchDB(`${config.url}/${config.database}`)
+    this.client = dbCore.DatabaseWithConnection(config.database, config.url)
   }
 
   async query(
@@ -66,31 +75,48 @@ class CouchDBIntegration implements IntegrationBase {
     query: { json?: object; id?: string }
   ) {
     try {
-      const response = await this.client[command](query.id || query.json)
-      await this.client.close()
-      return response
+      return await this.client[command](query.id || query.json)
     } catch (err) {
       console.error(errorMsg, err)
       throw err
     }
   }
 
-  async create(query: { json: object }) {
-    return this.query("post", "Error writing to couchDB", query)
+  private parse(query: { json: string | object }) {
+    return typeof query.json === "string" ? JSON.parse(query.json) : query.json
+  }
+
+  async create(query: { json: string | object }) {
+    const parsed = this.parse(query)
+    return this.query("post", "Error writing to couchDB", { json: parsed })
   }
 
-  async read(query: { json: object }) {
+  async read(query: { json: string | object }) {
+    const parsed = this.parse(query)
     const result = await this.query("allDocs", "Error querying couchDB", {
       json: {
         include_docs: true,
-        ...query.json,
+        ...parsed,
       },
     })
     return result.rows.map((row: { doc: object }) => row.doc)
   }
 
-  async update(query: { json: object }) {
-    return this.query("put", "Error updating couchDB document", query)
+  async update(query: { json: string | object }) {
+    const parsed: Document = this.parse(query)
+    if (!parsed?._rev && parsed?._id) {
+      const oldDoc = await this.get({ id: parsed._id })
+      parsed._rev = oldDoc._rev
+    }
+    return this.query("put", "Error updating couchDB document", {
+      json: parsed,
+    })
+  }
+
+  async get(query: { id: string }) {
+    return this.query("get", "Error retrieving couchDB document by ID", {
+      id: query.id,
+    })
   }
 
   async delete(query: { id: string }) {