@budibase/server 2.4.40 → 2.4.42-alpha.0

package/src/api/routes/public/tests/metrics.spec.js

@@ -0,0 +1,34 @@
+const setup = require("../../tests/utilities")
+
+jest.setTimeout(30000)
+
+describe("/metrics", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  // For some reason this cannot be a beforeAll or the test "should be able to update the user" fail
+  beforeEach(async () => {
+    await config.init()
+  })
+
+  describe("get", () => {
+    it("returns a list of metrics", async () => {
+      const res = await request
+        .get(`/api/public/v1/metrics`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /text\/plain/)
+        .expect(200)
+      expect(res.text).toContain("budibase_tenant_user_count")
+    })
+
+    it("endpoint should not be publicly exposed", async () => {
+      await request
+      .get(`/api/public/v1/metrics`)
+      .set(config.publicHeaders())
+      .expect(403)
+    })
+  })
+
+})

package/src/api/routes/tests/__snapshots__/datasource.spec.ts.snap

@@ -1,21 +1,21 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`/datasources fetch returns all the datasources from the server 1`] = `
-Array [
-  Object {
-    "config": Object {},
-    "entities": Array [
-      Object {
+[
+  {
+    "config": {},
+    "entities": [
+      {
         "_id": "ta_users",
         "_rev": "1-2375e1bc58aeec664dc1b1f04ad43e44",
         "createdAt": "2020-01-01T00:00:00.000Z",
         "name": "Users",
         "primaryDisplay": "email",
-        "schema": Object {
-          "email": Object {
-            "constraints": Object {
+        "schema": {
+          "email": {
+            "constraints": {
               "email": true,
-              "length": Object {
+              "length": {
                 "maximum": "",
               },
               "presence": true,
@@ -25,8 +25,8 @@ Array [
             "name": "email",
             "type": "string",
           },
-          "firstName": Object {
-            "constraints": Object {
+          "firstName": {
+            "constraints": {
               "presence": false,
               "type": "string",
             },
@@ -34,8 +34,8 @@ Array [
             "name": "firstName",
             "type": "string",
           },
-          "lastName": Object {
-            "constraints": Object {
+          "lastName": {
+            "constraints": {
               "presence": false,
               "type": "string",
             },
@@ -43,9 +43,9 @@ Array [
             "name": "lastName",
             "type": "string",
           },
-          "roleId": Object {
-            "constraints": Object {
-              "inclusion": Array [
+          "roleId": {
+            "constraints": {
+              "inclusion": [
                 "ADMIN",
                 "POWER",
                 "BASIC",
@@ -58,9 +58,9 @@ Array [
             "name": "roleId",
             "type": "options",
           },
-          "status": Object {
-            "constraints": Object {
-              "inclusion": Array [
+          "status": {
+            "constraints": {
+              "inclusion": [
                 "active",
                 "inactive",
               ],
@@ -74,15 +74,15 @@ Array [
         },
         "type": "table",
         "updatedAt": "2020-01-01T00:00:00.000Z",
-        "views": Object {},
+        "views": {},
       },
     ],
     "name": "Budibase DB",
     "source": "BUDIBASE",
     "type": "budibase",
   },
-  Object {
-    "config": Object {},
+  {
+    "config": {},
     "createdAt": "2020-01-01T00:00:00.000Z",
     "name": "Test",
     "source": "POSTGRES",

package/src/api/routes/tests/__snapshots__/view.spec.js.snap

@@ -1,8 +1,8 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`/views query returns data for the created view 1`] = `
-Array [
-  Object {
+[
+  {
     "avg": 2333.3333333333335,
     "count": 3,
     "group": null,
@@ -15,8 +15,8 @@ Array [
 `;
 
 exports[`/views query returns data for the created view using a group by 1`] = `
-Array [
-  Object {
+[
+  {
     "avg": 1500,
     "count": 2,
     "group": "One",
@@ -25,7 +25,7 @@ Array [
     "sum": 3000,
     "sumsqr": 5000000,
   },
-  Object {
+  {
     "avg": 4000,
     "count": 1,
     "group": "Two",

package/src/api/routes/tests/appSync.spec.ts

@@ -0,0 +1,31 @@
+import * as setup from "./utilities"
+import { roles, db as dbCore } from "@budibase/backend-core"
+
+describe("/api/applications/:appId/sync", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let app
+
+  afterAll(setup.afterAll)
+
+  beforeAll(async () => {
+    app = await config.init()
+    // create some users which we will use throughout the tests
+    await config.createUser({
+      email: "sync1@test.com",
+      roles: {
+        [app._id!]: roles.BUILTIN_ROLE_IDS.BASIC,
+      },
+    })
+  })
+
+  async function getUserMetadata() {
+    const { rows } = await config.searchRows(dbCore.InternalTable.USER_METADATA)
+    return rows
+  }
+
+  it("make sure that user metadata is correctly sync'd", async () => {
+    const rows = await getUserMetadata()
+    expect(rows.length).toBe(1)
+  })
+})

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

@@ -1,6 +1,7 @@
+const fetch = require("node-fetch")
+fetch.mockSearch()
 const search = require("../../controllers/row/internalSearch")
 // this will be mocked out for _search endpoint
-const fetch = require("node-fetch")
 const PARAMS = {
   tableId: "ta_12345679abcdef",
   version: "1",
@@ -20,7 +21,7 @@ function checkLucene(resp, expected, params = PARAMS) {
     expect(json.bookmark).toBe(PARAMS.bookmark)
   }
   expect(json.include_docs).toBe(true)
-  expect(json.q).toBe(`(${expected}) AND tableId:"${params.tableId}"`)
+  expect(json.q).toBe(`${expected} AND tableId:"${params.tableId}"`)
   expect(json.limit).toBe(params.limit || 50)
 }
 
@@ -59,7 +60,7 @@ describe("internal search", () => {
         "column": "1",
       }
     }, PARAMS)
-    checkLucene(response, `column:"2" OR !column:"1"`)
+    checkLucene(response, `(column:"2" OR !column:"1")`)
   })
 
   it("test AND query", async () => {
@@ -71,7 +72,7 @@ describe("internal search", () => {
         "column": "1",
       }
     }, PARAMS)
-    checkLucene(response, `*:* AND column:"2" AND !column:"1"`)
+    checkLucene(response, `(*:* AND column:"2" AND !column:"1")`)
   })
 
   it("test pagination query", async () => {
@@ -132,7 +133,7 @@ describe("internal search", () => {
         "colArr": [1, 2, 3],
       },
     }, PARAMS)
-    checkLucene(response, `*:* AND column:a AND colArr:(1 AND 2 AND 3)`, PARAMS)
+    checkLucene(response, `(*:* AND column:a AND colArr:(1 AND 2 AND 3))`, PARAMS)
   })
 
   it("test multiple of same column", async () => {
@@ -144,7 +145,7 @@ describe("internal search", () => {
         "3:column": "c",
       },
     }, PARAMS)
-    checkLucene(response, `column:"a" OR column:"b" OR column:"c"`, PARAMS)
+    checkLucene(response, `(column:"a" OR column:"b" OR column:"c")`, PARAMS)
   })
 
   it("check a weird case for lucene building", async () => {
@@ -191,6 +192,6 @@ describe("internal search", () => {
       expect(json.bookmark).toBe(PARAMS.bookmark)
     }
     expect(json.include_docs).toBe(true)
-    expect(json.q).toBe(`(*:* AND column:"1") AND tableId:${PARAMS.tableId}`)
+    expect(json.q).toBe(`*:* AND column:"1" AND tableId:${PARAMS.tableId}`)
   })
 })

package/src/app.ts

@@ -27,7 +27,7 @@ import * as api from "./api"
 import * as automations from "./automations"
 import { Thread } from "./threads"
 import * as redis from "./utilities/redis"
-import { events, logging, middleware } from "@budibase/backend-core"
+import { events, logging, middleware, timers } from "@budibase/backend-core"
 import { initialise as initialiseWebsockets } from "./websocket"
 import { startup } from "./startup"
 const Sentry = require("@sentry/node")
@@ -84,6 +84,7 @@ server.on("close", async () => {
   }
   shuttingDown = true
   console.log("Server Closed")
+  timers.cleanup()
   await automations.shutdown()
   await redis.shutdown()
   events.shutdown()

package/src/automations/automationUtils.ts

@@ -23,7 +23,7 @@ import { LoopStep, LoopStepType, LoopInput } from "../definitions/automations"
  * @returns {object} The inputs object which has had all the various types supported by this function converted to their
  * primitive types.
  */
-export function cleanInputValues(inputs: Record<string, any>, schema: any) {
+export function cleanInputValues(inputs: Record<string, any>, schema?: any) {
   if (schema == null) {
     return inputs
   }

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

@@ -0,0 +1,99 @@
+jest.mock("../../threads/automation")
+jest.mock("../../utilities/redis", () => ({
+  init: jest.fn(),
+  checkTestFlag: () => {
+    return false
+  },
+}))
+
+jest.spyOn(global.console, "error")
+
+import "../../environment"
+import * as automation from "../index"
+import * as thread from "../../threads/automation"
+import * as triggers from "../triggers"
+import { basicAutomation } from "../../tests/utilities/structures"
+import { wait } from "../../utilities"
+import { makePartial } from "../../tests/utilities"
+import { cleanInputValues } from "../automationUtils"
+import * as setup from "./utilities"
+import { Automation } from "@budibase/types"
+
+describe("Run through some parts of the automations system", () => {
+  let config = setup.getConfig()
+
+  beforeAll(async () => {
+    await automation.init()
+    await config.init()
+  })
+
+  afterAll(async () => {
+    await automation.shutdown()
+    setup.afterAll()
+  })
+
+  it("should be able to init in builder", async () => {
+    const automation: Automation = {
+      ...basicAutomation(),
+      appId: config.appId,
+    }
+    const fields: any = { a: 1, appId: config.appId }
+    await triggers.externalTrigger(automation, fields)
+    await wait(100)
+    expect(thread.execute).toHaveBeenCalled()
+  })
+
+  it("should check coercion", async () => {
+    const table = await config.createTable()
+    const automation: any = basicAutomation()
+    automation.definition.trigger.inputs.tableId = table._id
+    automation.definition.trigger.stepId = "APP"
+    automation.definition.trigger.inputs.fields = { a: "number" }
+    const fields: any = {
+      appId: config.getAppId(),
+      fields: {
+        a: "1",
+      },
+    }
+    await triggers.externalTrigger(automation, fields)
+    await wait(100)
+    expect(thread.execute).toHaveBeenCalledWith(
+      makePartial({
+        data: {
+          event: {
+            fields: {
+              a: 1,
+            },
+          },
+        },
+      }),
+      expect.any(Function)
+    )
+  })
+
+  it("should be able to clean inputs with the utilities", () => {
+    // can't clean without a schema
+    let output = cleanInputValues({ a: "1" })
+    expect(output.a).toBe("1")
+    output = cleanInputValues(
+      { a: "1", b: "true", c: "false", d: 1, e: "help" },
+      {
+        properties: {
+          a: {
+            type: "number",
+          },
+          b: {
+            type: "boolean",
+          },
+          c: {
+            type: "boolean",
+          },
+        },
+      }
+    )
+    expect(output.a).toBe(1)
+    expect(output.b).toBe(true)
+    expect(output.c).toBe(false)
+    expect(output.d).toBe(1)
+  })
+})

package/src/constants/index.ts

@@ -180,3 +180,4 @@ export enum AutomationErrors {
 // pass through the list from the auth/core lib
 export const ObjectStoreBuckets = objectStore.ObjectStoreBuckets
 export const MAX_AUTOMATION_RECURRING_ERRORS = 5
+export const GOOGLE_SHEETS_PRIMARY_KEY = "rowNumber"

package/src/definitions/openapi.ts

@@ -22,6 +22,10 @@ export interface paths {
     /** Based on application properties (currently only name) search for applications. */
     post: operations["appSearch"];
   };
+  "/metrics": {
+    /** Output metrics in OpenMetrics format compatible with Prometheus */
+    get: operations["metricsGet"];
+  };
   "/queries/{queryId}": {
     /** Queries which have been created within a Budibase app can be executed using this, */
     post: operations["queryExecute"];
@@ -844,6 +848,17 @@ export interface operations {
       };
     };
   };
+  /** Output metrics in OpenMetrics format compatible with Prometheus */
+  metricsGet: {
+    responses: {
+      /** Returns tenant metrics. */
+      200: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
   /** Queries which have been created within a Budibase app can be executed using this, */
   queryExecute: {
     parameters: {

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

@@ -1,3 +1,6 @@
+import fetch from "node-fetch"
+// @ts-ignore
+fetch.mockSearch()
 import {
   generateMakeRequest,
   MakeRequestResponse,
@@ -16,6 +19,7 @@ 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()!
 
@@ -80,16 +84,10 @@ describe("row api - postgres", () => {
             name: "id",
             type: FieldType.AUTO,
             autocolumn: true,
-            constraints: {
-              presence: true,
-            },
           },
           title: {
             name: "title",
             type: FieldType.STRING,
-            constraints: {
-              presence: true,
-            },
           },
         },
         sourceId: postgresDatasource._id,
@@ -121,16 +119,10 @@ describe("row api - postgres", () => {
           name: "id",
           type: FieldType.AUTO,
           autocolumn: true,
-          constraints: {
-            presence: true,
-          },
         },
         name: {
           name: "name",
           type: FieldType.STRING,
-          constraints: {
-            presence: true,
-          },
         },
         description: {
           name: "description",
@@ -144,7 +136,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: oneToManyRelationshipInfo.fieldName,
           name: "oneToManyRelation",
@@ -156,7 +147,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: manyToOneRelationshipInfo.fieldName,
           name: "manyToOneRelation",
@@ -168,7 +158,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: manyToManyRelationshipInfo.fieldName,
           name: "manyToManyRelation",
@@ -309,9 +298,6 @@ describe("row api - postgres", () => {
         id: {
           name: "id",
           type: FieldType.AUTO,
-          constraints: {
-            presence: true,
-          },
         },
       },
       sourceId: postgresDatasource._id,
@@ -921,47 +907,55 @@ describe("row api - postgres", () => {
             foreignRows,
             x => x.relationshipType
           )
-          expect(res.body).toEqual({
-            ...rowData,
-            [`fk_${oneToManyRelationshipInfo.table.name}_${oneToManyRelationshipInfo.fieldName}`]:
-              foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row.id,
-            [oneToManyRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row,
-                _id: expect.any(String),
-                _rev: expect.any(String),
-              },
-            ],
-            [manyToOneRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][0].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
-              },
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][1].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
-              },
+          const m2mFieldName = manyToManyRelationshipInfo.fieldName,
+            o2mFieldName = oneToManyRelationshipInfo.fieldName,
+            m2oFieldName = manyToOneRelationshipInfo.fieldName
+          const m2mRow1 = res.body[m2mFieldName].find(
+            (row: Row) => row.id === 1
+          )
+          const m2mRow2 = res.body[m2mFieldName].find(
+            (row: Row) => row.id === 2
+          )
+          expect(m2mRow1).toEqual({
+            ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][0].row,
+            [m2mFieldName]: [
               {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][2].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
+                _id: row._id,
               },
             ],
-            [manyToManyRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][0].row,
-              },
+          })
+          expect(m2mRow2).toEqual({
+            ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
+            [m2mFieldName]: [
               {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
+                _id: row._id,
               },
             ],
-            id: row.id,
-            tableId: row.tableId,
-            _id: expect.any(String),
-            _rev: expect.any(String),
           })
+          expect(res.body[m2oFieldName]).toEqual([
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][0].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][1].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][2].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+          ])
+          expect(res.body[o2mFieldName]).toEqual([
+            {
+              ...foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row,
+              _id: expect.any(String),
+              _rev: expect.any(String),
+            },
+          ])
         })
       })
     })