@budibase/server 2.2.11 → 2.2.12-alpha.1

package/src/api/routes/tests/static.spec.js

@@ -1,20 +1,5 @@
-jest.mock("node-fetch")
-jest.mock("aws-sdk", () => ({
-  config: {
-    update: jest.fn(),
-  },
-  DynamoDB: {
-    DocumentClient: jest.fn(),
-  },
-  S3: jest.fn(() => ({
-    getSignedUrl: jest.fn(() => {
-      return "my-url"
-    }),
-  })),
-}))
-
 const setup = require("./utilities")
-const { events, constants } = require("@budibase/backend-core")
+const { constants } = require("@budibase/backend-core")
 
 describe("/static", () => {
   let request = setup.getRequest()
@@ -102,7 +87,7 @@ describe("/static", () => {
           .set(config.defaultHeaders())
           .expect("Content-Type", /json/)
           .expect(200)
-        expect(res.body.signedUrl).toEqual("my-url")
+        expect(res.body.signedUrl).toEqual("http://test.com/foo/bar")
         expect(res.body.publicUrl).toEqual(
           `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
         )

package/src/api/routes/tests/table.spec.js

@@ -51,7 +51,7 @@ describe("/tables", () => {
       table.dataImport.schema = table.schema
 
       const res = await createTable(table)
- 
+
       expect(events.table.created).toBeCalledTimes(1)
       expect(events.table.created).toBeCalledWith(res.body)
       expect(events.table.imported).toBeCalledTimes(1)
@@ -87,6 +87,12 @@ describe("/tables", () => {
 
     it("updates all the row fields for a table when a schema key is renamed", async () => {
       const testTable = await config.createTable()
+      await config.createView({
+        name: "TestView",
+        field: "Price",
+        calculation: "stats",
+        tableId: testTable._id,
+      })
 
       const testRow = await request
         .post(`/api/${testTable._id}/rows`)
@@ -109,7 +115,7 @@ describe("/tables", () => {
             updated: "updatedName"
           },
           schema: {
-            updatedName: {type: "string"}
+            updatedName: { type: "string" }
           }
         })
         .set(config.defaultHeaders())

package/src/api/routes/tests/user.spec.js

@@ -90,4 +90,90 @@ describe("/users", () => {
       expect(res.body.tableId).toBeDefined()
     })
   })
+  describe("setFlag", () => {
+    it("should throw an error if a flag is not provided", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test" })
+        .expect(400)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Must supply a 'flag' field in request body.")
+
+    })
+
+    it("should be able to set a flag on the user", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test", flag: "test" })
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Flag set successfully")
+    })
+  })
+
+  describe("getFlags", () => {
+    it("should get flags for a specific user", async () => {
+      let flagData = { value: "test", flag: "test" }
+      await config.createUser()
+      await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send(flagData)
+        .expect(200)
+        .expect("Content-Type", /json/)
+
+      const res = await request
+        .get(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body[flagData.value]).toEqual(flagData.flag)
+    })
+  })
+
+  describe("setFlag", () => {
+    it("should throw an error if a flag is not provided", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test" })
+        .expect(400)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Must supply a 'flag' field in request body.")
+
+    })
+
+    it("should be able to set a flag on the user", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test", flag: "test" })
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Flag set successfully")
+    })
+  })
+
+  describe("syncUser", () => {
+    it("should sync the user", async () => {
+      let user = await config.createUser()
+      await config.createApp('New App')
+      let res = await request
+        .post(`/api/users/metadata/sync/${user._id}`)
+        .set(config.defaultHeaders())
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual('User synced.')
+    })
+  })
+
+
+
+
 })

package/src/api/routes/tests/utilities/index.ts

@@ -63,14 +63,14 @@ export function afterAll() {
 
 export function getRequest() {
   if (!request) {
-    exports.beforeAll()
+    beforeAll()
   }
   return request
 }
 
 export function getConfig() {
   if (!config) {
-    exports.beforeAll()
+    beforeAll()
   }
   return config
 }

package/src/api/routes/tests/webhook.spec.js

@@ -113,7 +113,7 @@ describe("/webhooks", () => {
   describe("trigger", () => {
     it("should allow triggering from public", async () => {
       // replicate changes before checking webhook
-      await config.deploy()
+      await config.publish()
 
       const res = await request
         .post(`/api/webhooks/trigger/${config.prodAppId}/${webhook._id}`)

package/src/automations/automationUtils.ts

@@ -5,6 +5,7 @@ import {
 } from "@budibase/string-templates"
 import sdk from "../sdk"
 import { Row } from "@budibase/types"
+import { LoopStep, LoopStepType, LoopInput } from "../definitions/automations"
 
 /**
  * When values are input to the system generally they will be of type string as this is required for template strings.
@@ -123,3 +124,26 @@ export function stringSplit(value: string | string[]) {
   }
   return value
 }
+
+export function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
+  if (!input || !input.binding) {
+    return null
+  }
+  try {
+    switch (loopStep.inputs.option) {
+      case LoopStepType.ARRAY:
+        if (typeof input.binding === "string") {
+          return JSON.parse(input.binding)
+        }
+        break
+      case LoopStepType.STRING:
+        if (Array.isArray(input.binding)) {
+          return input.binding.join(",")
+        }
+        break
+    }
+  } catch (err) {
+    throw new Error("Unable to cast to correct type")
+  }
+  return input.binding
+}

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

@@ -0,0 +1,34 @@
+const setup = require("./utilities")
+
+describe("test the bash 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("EXECUTE_BASH",
+            inputs = {
+                code: "echo 'test'"
+            }
+
+        )
+        expect(res.stdout).toEqual("test\n")
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null value", async () => {
+
+        let res = await setup.runStep("EXECUTE_BASH",
+            inputs = {
+                code: null
+            }
+
+
+        )
+        expect(res.stdout).toEqual("Budibase bash automation failed: Invalid inputs")
+    })
+})

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/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/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/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

package/src/integrations/googlesheets.ts

@@ -284,7 +284,7 @@ class GoogleSheetsIntegration implements DatasourcePlus {
   async createTable(name?: string) {
     try {
       await this.connect()
-      return await this.client.addSheet({ title: name })
+      return await this.client.addSheet({ title: name, headerValues: ["test"] })
     } catch (err) {
       console.error("Error creating new table in google sheets", err)
       throw err

package/src/integrations/index.ts

@@ -98,11 +98,7 @@ export async function getIntegration(integration: string) {
     for (let plugin of plugins) {
       if (plugin.name === integration) {
         // need to use commonJS require due to its dynamic runtime nature
-        const retrieved: any = await getDatasourcePlugin(
-          plugin.name,
-          plugin.jsUrl,
-          plugin.schema?.hash
-        )
+        const retrieved: any = await getDatasourcePlugin(plugin)
         if (retrieved.integration) {
           return retrieved.integration
         } else {

package/src/migrations/functions/backfill/global/configs.ts

@@ -5,6 +5,7 @@ import {
   isGoogleConfig,
   isOIDCConfig,
   isSettingsConfig,
+  ConfigType,
 } from "@budibase/types"
 import env from "./../../../../environment"
 
@@ -31,15 +32,15 @@ export const backfill = async (
       await events.email.SMTPCreated(timestamp)
     }
     if (isGoogleConfig(config)) {
-      await events.auth.SSOCreated("google", timestamp)
+      await events.auth.SSOCreated(ConfigType.GOOGLE, timestamp)
       if (config.config.activated) {
-        await events.auth.SSOActivated("google", timestamp)
+        await events.auth.SSOActivated(ConfigType.GOOGLE, timestamp)
       }
     }
     if (isOIDCConfig(config)) {
-      await events.auth.SSOCreated("oidc", timestamp)
+      await events.auth.SSOCreated(ConfigType.OIDC, timestamp)
       if (config.config.configs[0].activated) {
-        await events.auth.SSOActivated("oidc", timestamp)
+        await events.auth.SSOActivated(ConfigType.OIDC, timestamp)
       }
     }
     if (isSettingsConfig(config)) {