@budibase/server 1.0.79-alpha.7 → 1.0.79

package/src/api/routes/table.js

@@ -7,10 +7,25 @@ const {
   PermissionLevels,
   PermissionTypes,
 } = require("@budibase/backend-core/permissions")
-const { tableValidator } = require("./utils/validators")
+const joiValidator = require("../../middleware/joi-validator")
+const Joi = require("joi")
 
 const router = Router()
 
+function generateSaveValidator() {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: Joi.string(),
+    _rev: Joi.string(),
+    type: Joi.string().valid("table", "internal", "external"),
+    primaryDisplay: Joi.string(),
+    schema: Joi.object().required(),
+    name: Joi.string().required(),
+    views: Joi.object(),
+    dataImport: Joi.object(),
+  }).unknown(true))
+}
+
 router
   /**
    * @api {get} /api/tables Fetch all tables
@@ -38,8 +53,8 @@ router
    * @apiSuccess {object[]} body The response body will be the table that was found.
    */
   .get(
-    "/api/tables/:tableId",
-    paramResource("tableId"),
+    "/api/tables/:id",
+    paramResource("id"),
     authorized(PermissionTypes.TABLE, PermissionLevels.READ),
     tableController.find
   )
@@ -121,7 +136,7 @@ router
     // allows control over updating a table
     bodyResource("_id"),
     authorized(BUILDER),
-    tableValidator(),
+    generateSaveValidator(),
     tableController.save
   )
   /**

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

@@ -2,18 +2,6 @@ const TestConfig = require("../../../../tests/utilities/TestConfiguration")
 const structures = require("../../../../tests/utilities/structures")
 const env = require("../../../../environment")
 
-function user() {
-  return {
-    _id: "user",
-    _rev: "rev",
-    createdAt: Date.now(),
-    email: "test@test.com",
-    roles: {},
-    tenantId: "default",
-    status: "active",
-  }
-}
-
 jest.mock("../../../../utilities/workerRequests", () => ({
   getGlobalUsers: jest.fn(() => {
     return {
@@ -25,18 +13,6 @@ jest.mock("../../../../utilities/workerRequests", () => ({
       _id: "us_uuid1",
     }
   }),
-  allGlobalUsers: jest.fn(() => {
-    return [user()]
-  }),
-  readGlobalUser: jest.fn(() => {
-    return user()
-  }),
-  saveGlobalUser: jest.fn(() => {
-    return { _id: "user", _rev: "rev" }
-  }),
-  deleteGlobalUser: jest.fn(() => {
-    return { message: "deleted user" }
-  }),
   removeAppFromUserRoles: jest.fn(),
 }))
 

package/src/api/routes/webhook.js

@@ -1,17 +1,33 @@
 const Router = require("@koa/router")
 const controller = require("../controllers/webhook")
 const authorized = require("../../middleware/authorized")
+const joiValidator = require("../../middleware/joi-validator")
 const { BUILDER } = require("@budibase/backend-core/permissions")
-const { webhookValidator } = require("./utils/validators")
+const Joi = require("joi")
 
 const router = Router()
 
+function generateSaveValidator() {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    live: Joi.bool(),
+    _id: Joi.string().optional(),
+    _rev: Joi.string().optional(),
+    name: Joi.string().required(),
+    bodySchema: Joi.object().optional(),
+    action: Joi.object({
+      type: Joi.string().required().valid(controller.WebhookType.AUTOMATION),
+      target: Joi.string().required(),
+    }).required(),
+  }).unknown(true))
+}
+
 router
   .get("/api/webhooks", authorized(BUILDER), controller.fetch)
   .put(
     "/api/webhooks",
     authorized(BUILDER),
-    webhookValidator(),
+    generateSaveValidator(),
     controller.save
   )
   .delete("/api/webhooks/:id/:rev", authorized(BUILDER), controller.destroy)

package/src/automations/steps/filter.js

@@ -16,11 +16,10 @@ exports.FilterConditions = FilterConditions
 exports.PrettyFilterConditions = PrettyFilterConditions
 
 exports.definition = {
-  name: "Condition",
+  name: "Filter",
   tagline: "{{inputs.field}} {{inputs.condition}} {{inputs.value}}",
   icon: "Branch2",
-  description:
-    "Conditionally halt automations which do not meet certain conditions",
+  description: "Filter any automations which do not meet certain conditions",
   type: "LOGIC",
   internal: true,
   stepId: "FILTER",

package/src/automations/steps/queryRows.js

@@ -74,7 +74,7 @@ exports.definition = {
 async function getTable(appId, tableId) {
   const ctx = buildCtx(appId, null, {
     params: {
-      tableId,
+      id: tableId,
     },
   })
   await tableController.find(ctx)

package/src/automations/utils.js

@@ -5,7 +5,7 @@ const CouchDB = require("../db")
 const { queue } = require("./bullboard")
 const newid = require("../db/newid")
 const { updateEntityMetadata } = require("../utilities")
-const { MetadataTypes, WebhookType } = require("../constants")
+const { MetadataTypes } = require("../constants")
 const { getProdAppID } = require("@budibase/backend-core/db")
 const { cloneDeep } = require("lodash/fp")
 const { getAppDB, getAppId } = require("@budibase/backend-core/context")
@@ -159,7 +159,7 @@ exports.checkForWebhooks = async ({ oldAuto, newAuto }) => {
       request: {
         body: new webhooks.Webhook(
           "Automation webhook",
-          WebhookType.AUTOMATION,
+          webhooks.WebhookType.AUTOMATION,
           newAuto._id
         ),
       },

package/src/constants/index.js

@@ -186,9 +186,5 @@ exports.BuildSchemaErrors = {
   INVALID_COLUMN: "invalid_column",
 }
 
-exports.WebhookType = {
-  AUTOMATION: "automation",
-}
-
 // pass through the list from the auth/core lib
 exports.ObjectStoreBuckets = ObjectStoreBuckets

package/src/db/utils.js

@@ -146,18 +146,6 @@ exports.getRowParams = (tableId = null, rowId = null, otherProps = {}) => {
   return getDocParams(DocumentTypes.ROW, endOfKey, otherProps)
 }
 
-/**
- * Given a row ID this will find the table ID within it (only works for internal tables).
- * @param {string} rowId The ID of the row.
- * @returns {string} The table ID.
- */
-exports.getTableIDFromRowID = rowId => {
-  const components = rowId
-    .split(DocumentTypes.TABLE + SEPARATOR)[1]
-    .split(SEPARATOR)
-  return `${DocumentTypes.TABLE}${SEPARATOR}${components[0]}`
-}
-
 /**
  * Gets a new row ID for the specified table.
  * @param {string} tableId The table which the row is being created for.

package/src/definitions/common.ts

@@ -5,10 +5,6 @@ export interface Base {
   _rev?: string
 }
 
-export interface Application extends Base {
-  appId?: string
-}
-
 export interface FieldSchema {
   // TODO: replace with field types enum when done
   type: string

package/src/integrations/mysql.ts

@@ -16,7 +16,7 @@ import {
 import { DatasourcePlus } from "./base/datasourcePlus"
 
 module MySQLModule {
-  const mysql = require("mysql2")
+  const mysql = require("mysql2/promise")
   const Sql = require("./base/sql")
 
   interface MySQLConfig {
@@ -29,7 +29,7 @@ module MySQLModule {
   }
 
   const SCHEMA: Integration = {
-    docs: "https://github.com/mysqljs/mysql",
+    docs: "https://github.com/sidorares/node-mysql2",
     plus: true,
     friendlyName: "MySQL",
     description:
@@ -80,36 +80,9 @@ module MySQLModule {
     },
   }
 
-  function internalQuery(
-    client: any,
-    query: SqlQuery,
-    connect: boolean = true
-  ): Promise<any[] | any> {
-    // Node MySQL is callback based, so we must wrap our call in a promise
-    return new Promise((resolve, reject) => {
-      if (connect) {
-        client.connect()
-      }
-      return client.query(
-        query.sql,
-        query.bindings || {},
-        (error: any, results: object[]) => {
-          if (error) {
-            reject(error)
-          } else {
-            resolve(results)
-          }
-          if (connect) {
-            client.end()
-          }
-        }
-      )
-    })
-  }
-
   class MySQLIntegration extends Sql implements DatasourcePlus {
     private config: MySQLConfig
-    private readonly client: any
+    private client: any
     public tables: Record<string, Table> = {}
     public schemaErrors: Record<string, string> = {}
 
@@ -119,93 +92,127 @@ module MySQLModule {
       if (config.ssl && Object.keys(config.ssl).length === 0) {
         delete config.ssl
       }
-      this.client = mysql.createConnection(config)
+      this.config = config
+    }
+
+    async connect() {
+      this.client = await mysql.createConnection(this.config)
+    }
+
+    async disconnect() {
+      await this.client.end()
+    }
+
+    async internalQuery(
+      query: SqlQuery,
+      connect: boolean = true
+    ): Promise<any[] | any> {
+      try {
+        if (connect) {
+          await this.connect()
+        }
+        // Node MySQL is callback based, so we must wrap our call in a promise
+        const response = await this.client.query(
+          query.sql,
+          query.bindings || []
+        )
+        return response[0]
+      } finally {
+        if (connect) {
+          await this.disconnect()
+        }
+      }
     }
 
     async buildSchema(datasourceId: string, entities: Record<string, Table>) {
       const tables: { [key: string]: Table } = {}
       const database = this.config.database
-      this.client.connect()
-
-      // get the tables first
-      const tablesResp = await internalQuery(
-        this.client,
-        { sql: "SHOW TABLES;" },
-        false
-      )
-      const tableNames = tablesResp.map(
-        (obj: any) =>
-          obj[`Tables_in_${database}`] ||
-          obj[`Tables_in_${database.toLowerCase()}`]
-      )
-      for (let tableName of tableNames) {
-        const primaryKeys = []
-        const schema: TableSchema = {}
-        const descResp = await internalQuery(
-          this.client,
-          { sql: `DESCRIBE \`${tableName}\`;` },
+      await this.connect()
+
+      try {
+        // get the tables first
+        const tablesResp = await this.internalQuery(
+          { sql: "SHOW TABLES;" },
           false
         )
-        for (let column of descResp) {
-          const columnName = column.Field
-          if (column.Key === "PRI" && primaryKeys.indexOf(column.Key) === -1) {
-            primaryKeys.push(columnName)
-          }
-          const constraints = {
-            presence: column.Null !== "YES",
-          }
-          const isAuto: boolean =
-            typeof column.Extra === "string" &&
-            (column.Extra === "auto_increment" ||
-              column.Extra.toLowerCase().includes("generated"))
-          schema[columnName] = {
-            name: columnName,
-            autocolumn: isAuto,
-            type: convertSqlType(column.Type),
-            constraints,
+        const tableNames = tablesResp.map(
+          (obj: any) =>
+            obj[`Tables_in_${database}`] ||
+            obj[`Tables_in_${database.toLowerCase()}`]
+        )
+        for (let tableName of tableNames) {
+          const primaryKeys = []
+          const schema: TableSchema = {}
+          const descResp = await this.internalQuery(
+            { sql: `DESCRIBE \`${tableName}\`;` },
+            false
+          )
+          for (let column of descResp) {
+            const columnName = column.Field
+            if (
+              column.Key === "PRI" &&
+              primaryKeys.indexOf(column.Key) === -1
+            ) {
+              primaryKeys.push(columnName)
+            }
+            const constraints = {
+              presence: column.Null !== "YES",
+            }
+            const isAuto: boolean =
+              typeof column.Extra === "string" &&
+              (column.Extra === "auto_increment" ||
+                column.Extra.toLowerCase().includes("generated"))
+            schema[columnName] = {
+              name: columnName,
+              autocolumn: isAuto,
+              type: convertSqlType(column.Type),
+              constraints,
+            }
           }
-        }
-        if (!tables[tableName]) {
-          tables[tableName] = {
-            _id: buildExternalTableId(datasourceId, tableName),
-            primary: primaryKeys,
-            name: tableName,
-            schema,
+          if (!tables[tableName]) {
+            tables[tableName] = {
+              _id: buildExternalTableId(datasourceId, tableName),
+              primary: primaryKeys,
+              name: tableName,
+              schema,
+            }
           }
         }
+      } finally {
+        await this.disconnect()
       }
-
-      this.client.end()
       const final = finaliseExternalTables(tables, entities)
       this.tables = final.tables
       this.schemaErrors = final.errors
     }
 
     async create(query: SqlQuery | string) {
-      const results = await internalQuery(this.client, getSqlQuery(query))
+      const results = await this.internalQuery(getSqlQuery(query))
       return results.length ? results : [{ created: true }]
     }
 
     async read(query: SqlQuery | string) {
-      return internalQuery(this.client, getSqlQuery(query))
+      return this.internalQuery(getSqlQuery(query))
     }
 
     async update(query: SqlQuery | string) {
-      const results = await internalQuery(this.client, getSqlQuery(query))
+      const results = await this.internalQuery(getSqlQuery(query))
       return results.length ? results : [{ updated: true }]
     }
 
     async delete(query: SqlQuery | string) {
-      const results = await internalQuery(this.client, getSqlQuery(query))
+      const results = await this.internalQuery(getSqlQuery(query))
       return results.length ? results : [{ deleted: true }]
     }
 
     async query(json: QueryJson) {
-      this.client.connect()
-      const queryFn = (query: any) => internalQuery(this.client, query, false)
-      const output = await this.queryWithReturning(json, queryFn)
-      this.client.end()
-      return output
+      await this.connect()
+      try {
+        const queryFn = (query: any) => this.internalQuery(query, false)
+        return await this.queryWithReturning(json, queryFn)
+      } finally {
+        await this.disconnect()
+      }
     }
   }
 

package/src/integrations/tests/mysql.spec.js

@@ -19,7 +19,7 @@ describe("MySQL Integration", () => {
     await config.integration.create({
       sql
     })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, {}, expect.any(Function))
+    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
 
   it("calls the read method with the correct params", async () => {
@@ -27,7 +27,7 @@ describe("MySQL Integration", () => {
     await config.integration.read({
       sql
     })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, {}, expect.any(Function))
+    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
 
   it("calls the update method with the correct params", async () => {
@@ -35,7 +35,7 @@ describe("MySQL Integration", () => {
     await config.integration.update({
       sql
     })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, {}, expect.any(Function))
+    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
 
   it("calls the delete method with the correct params", async () => {
@@ -43,7 +43,7 @@ describe("MySQL Integration", () => {
     await config.integration.delete({
       sql
     })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, {}, expect.any(Function))
+    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
 
   describe("no rows returned", () => {

package/src/integrations/utils.ts

@@ -40,7 +40,7 @@ const SQL_TYPE_MAP = {
 export enum SqlClients {
   MS_SQL = "mssql",
   POSTGRES = "pg",
-  MY_SQL = "mysql",
+  MY_SQL = "mysql2",
   ORACLE = "oracledb",
 }
 

package/src/tests/utilities/TestConfiguration.js

@@ -25,8 +25,6 @@ const { createASession } = require("@budibase/backend-core/sessions")
 const { user: userCache } = require("@budibase/backend-core/cache")
 const newid = require("../../db/newid")
 const context = require("@budibase/backend-core/context")
-const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db")
-const { encrypt } = require("@budibase/backend-core/encryption")
 
 const GLOBAL_USER_ID = "us_uuid1"
 const EMAIL = "babs@babs.com"
@@ -49,10 +47,6 @@ class TestConfiguration {
     return this.request
   }
 
-  getApp() {
-    return this.app
-  }
-
   getAppId() {
     return this.appId
   }
@@ -89,20 +83,6 @@ class TestConfiguration {
     }
   }
 
-  async generateApiKey(userId = GLOBAL_USER_ID) {
-    const db = getGlobalDB(TENANT_ID)
-    const id = generateDevInfoID(userId)
-    let devInfo
-    try {
-      devInfo = await db.get(id)
-    } catch (err) {
-      devInfo = { _id: id, userId }
-    }
-    devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
-    await db.put(devInfo)
-    return devInfo.apiKey
-  }
-
   async globalUser({
     id = GLOBAL_USER_ID,
     builder = true,
@@ -155,7 +135,7 @@ class TestConfiguration {
     cleanup(this.allApps.map(app => app.appId))
   }
 
-  defaultHeaders(extras = {}) {
+  defaultHeaders() {
     const auth = {
       userId: GLOBAL_USER_ID,
       sessionId: "sessionid",
@@ -174,7 +154,6 @@ class TestConfiguration {
         `${Cookies.CurrentApp}=${appToken}`,
       ],
       [Headers.CSRF_TOKEN]: CSRF_TOKEN,
-      ...extras,
     }
     if (this.appId) {
       headers[Headers.APP_ID] = this.appId
@@ -247,7 +226,7 @@ class TestConfiguration {
 
   async getTable(tableId = null) {
     tableId = tableId || this.table._id
-    return this._req(null, { tableId }, controllers.table.find)
+    return this._req(null, { id: tableId }, controllers.table.find)
   }
 
   async createLinkedTable(relationshipType = null, links = ["link"]) {

package/src/utilities/workerRequests.js

@@ -26,31 +26,11 @@ function request(ctx, request) {
     delete request.body
   }
   if (ctx && ctx.headers) {
-    request.headers = ctx.headers
+    request.headers.cookie = ctx.headers.cookie
   }
   return request
 }
 
-async function checkResponse(response, errorMsg, { ctx } = {}) {
-  if (response.status !== 200) {
-    let error
-    try {
-      error = await response.json()
-    } catch (err) {
-      error = await response.text()
-    }
-    const msg = `Unable to ${errorMsg} - ${
-      error.message ? error.message : error
-    }`
-    if (ctx) {
-      ctx.throw(400, msg)
-    } else {
-      throw msg
-    }
-  }
-  return response.json()
-}
-
 exports.request = request
 
 // have to pass in the tenant ID as this could be coming from an automation
@@ -70,17 +50,25 @@ exports.sendSmtpEmail = async (to, from, subject, contents, automation) => {
       },
     })
   )
-  return checkResponse(response, "send email")
+
+  if (response.status !== 200) {
+    const error = await response.text()
+    throw `Unable to send email - ${error}`
+  }
+  return response.json()
 }
 
 exports.getGlobalSelf = async (ctx, appId = null) => {
-  const endpoint = `/api/global/self`
+  const endpoint = `/api/global/users/self`
   const response = await fetch(
     checkSlashesInUrl(env.WORKER_URL + endpoint),
     // we don't want to use API key when getting self
     request(ctx, { method: "GET" })
   )
-  let json = await checkResponse(response, "get self globally", { ctx })
+  if (response.status !== 200) {
+    ctx.throw(400, "Unable to get self globally.")
+  }
+  let json = await response.json()
   if (appId) {
     json = updateAppRole(json)
   }
@@ -95,45 +83,8 @@ exports.removeAppFromUserRoles = async (ctx, appId) => {
       method: "DELETE",
     })
   )
-  return checkResponse(response, "remove app role")
-}
-
-exports.allGlobalUsers = async ctx => {
-  const response = await fetch(
-    checkSlashesInUrl(env.WORKER_URL + "/api/global/users"),
-    // we don't want to use API key when getting self
-    request(ctx, { method: "GET" })
-  )
-  return checkResponse(response, "get users", { ctx })
-}
-
-exports.saveGlobalUser = async ctx => {
-  const response = await fetch(
-    checkSlashesInUrl(env.WORKER_URL + "/api/global/users"),
-    // we don't want to use API key when getting self
-    request(ctx, { method: "POST", body: ctx.request.body })
-  )
-  return checkResponse(response, "save user", { ctx })
-}
-
-exports.deleteGlobalUser = async ctx => {
-  const response = await fetch(
-    checkSlashesInUrl(
-      env.WORKER_URL + `/api/global/users/${ctx.params.userId}`
-    ),
-    // we don't want to use API key when getting self
-    request(ctx, { method: "DELETE" })
-  )
-  return checkResponse(response, "delete user", { ctx, body: ctx.request.body })
-}
-
-exports.readGlobalUser = async ctx => {
-  const response = await fetch(
-    checkSlashesInUrl(
-      env.WORKER_URL + `/api/global/users/${ctx.params.userId}`
-    ),
-    // we don't want to use API key when getting self
-    request(ctx, { method: "GET" })
-  )
-  return checkResponse(response, "get user", { ctx })
+  if (response.status !== 200) {
+    throw "Unable to remove app role"
+  }
+  return response.json()
 }