@budibase/server 2.7.21-alpha.1 → 2.7.21

package/src/integrations/postgres.ts

@@ -20,7 +20,7 @@ import Sql from "./base/sql"
 import { PostgresColumn } from "./base/types"
 import { escapeDangerousCharacters } from "../utilities"
 
-import { Client, ClientConfig, types } from "pg"
+import { Client, types } from "pg"
 
 // Return "date" and "timestamp" types as plain strings.
 // This lets us reference the original stored timezone.
@@ -42,8 +42,6 @@ interface PostgresConfig {
   schema: string
   ssl?: boolean
   ca?: string
-  clientKey?: string
-  clientCert?: string
   rejectUnauthorized?: boolean
 }
 
@@ -100,19 +98,6 @@ const SCHEMA: Integration = {
       required: false,
     },
     ca: {
-      display: "Server CA",
-      type: DatasourceFieldType.LONGFORM,
-      default: false,
-      required: false,
-    },
-    clientKey: {
-      display: "Client key",
-      type: DatasourceFieldType.LONGFORM,
-      default: false,
-      required: false,
-    },
-    clientCert: {
-      display: "Client cert",
       type: DatasourceFieldType.LONGFORM,
       default: false,
       required: false,
@@ -159,14 +144,12 @@ class PostgresIntegration extends Sql implements DatasourcePlus {
     super(SqlClient.POSTGRES)
     this.config = config
 
-    let newConfig: ClientConfig = {
+    let newConfig = {
       ...this.config,
       ssl: this.config.ssl
         ? {
             rejectUnauthorized: this.config.rejectUnauthorized,
             ca: this.config.ca,
-            key: this.config.clientKey,
-            cert: this.config.clientCert,
           }
         : undefined,
     }
@@ -339,8 +322,7 @@ class PostgresIntegration extends Sql implements DatasourcePlus {
       await this.openConnection()
       const columnsResponse: { rows: PostgresColumn[] } =
         await this.client.query(this.COLUMNS_SQL)
-      const names = columnsResponse.rows.map(row => row.table_name)
-      return [...new Set(names)]
+      return columnsResponse.rows.map(row => row.table_name)
     } finally {
       await this.closeConnection()
     }

package/src/middleware/currentapp.ts

@@ -103,7 +103,7 @@ export default async (ctx: UserCtx, next: any) => {
         userId,
         globalId,
         roleId,
-        role: await roles.getRole(roleId, { defaultPublic: true }),
+        role: await roles.getRole(roleId),
       }
     }
 

package/src/sdk/app/backups/exports.ts

@@ -1,4 +1,4 @@
-import { db as dbCore, encryption, objectStore } from "@budibase/backend-core"
+import { db as dbCore, objectStore } from "@budibase/backend-core"
 import { budibaseTempDir } from "../../../utilities/budibaseDir"
 import { streamFile, createTempFolder } from "../../../utilities/fileSystem"
 import { ObjectStoreBuckets } from "../../../constants"
@@ -18,8 +18,7 @@ import { join } from "path"
 import env from "../../../environment"
 
 const uuid = require("uuid/v4")
-import tar from "tar"
-
+const tar = require("tar")
 const MemoryStream = require("memorystream")
 
 interface DBDumpOpts {
@@ -31,18 +30,16 @@ interface ExportOpts extends DBDumpOpts {
   tar?: boolean
   excludeRows?: boolean
   excludeLogs?: boolean
-  encryptPassword?: string
 }
 
 function tarFilesToTmp(tmpDir: string, files: string[]) {
-  const fileName = `${uuid()}.tar.gz`
-  const exportFile = join(budibaseTempDir(), fileName)
+  const exportFile = join(budibaseTempDir(), `${uuid()}.tar.gz`)
   tar.create(
     {
       sync: true,
       gzip: true,
       file: exportFile,
-      noDirRecurse: false,
+      recursive: true,
       cwd: tmpDir,
     },
     files
@@ -127,7 +124,6 @@ export async function exportApp(appId: string, config?: ExportOpts) {
       )
     }
   }
-
   const downloadedPath = join(tmpPath, appPath)
   if (fs.existsSync(downloadedPath)) {
     const allFiles = fs.readdirSync(downloadedPath)
@@ -145,27 +141,12 @@ export async function exportApp(appId: string, config?: ExportOpts) {
     filter: defineFilter(config?.excludeRows, config?.excludeLogs),
     exportPath: dbPath,
   })
-
-  if (config?.encryptPassword) {
-    for (let file of fs.readdirSync(tmpPath)) {
-      const path = join(tmpPath, file)
-
-      await encryption.encryptFile(
-        { dir: tmpPath, filename: file },
-        config.encryptPassword
-      )
-
-      fs.rmSync(path)
-    }
-  }
-
   // if tar requested, return where the tarball is
   if (config?.tar) {
     // now the tmpPath contains both the DB export and attachments, tar this
     const tarPath = tarFilesToTmp(tmpPath, fs.readdirSync(tmpPath))
     // cleanup the tmp export files as tarball returned
     fs.rmSync(tmpPath, { recursive: true, force: true })
-
     return tarPath
   }
   // tar not requested, turn the directory where export is
@@ -180,20 +161,11 @@ export async function exportApp(appId: string, config?: ExportOpts) {
  * @param {boolean} excludeRows Flag to state whether the export should include data.
  * @returns {*} a readable stream of the backup which is written in real time
  */
-export async function streamExportApp({
-  appId,
-  excludeRows,
-  encryptPassword,
-}: {
-  appId: string
-  excludeRows: boolean
-  encryptPassword?: string
-}) {
+export async function streamExportApp(appId: string, excludeRows: boolean) {
   const tmpPath = await exportApp(appId, {
     excludeRows,
     excludeLogs: true,
     tar: true,
-    encryptPassword,
   })
   return streamFile(tmpPath)
 }

package/src/sdk/app/backups/imports.ts

@@ -1,4 +1,4 @@
-import { db as dbCore, encryption, objectStore } from "@budibase/backend-core"
+import { db as dbCore, objectStore } from "@budibase/backend-core"
 import { Database, Row } from "@budibase/types"
 import { getAutomationParams, TABLE_ROW_PREFIX } from "../../../db/utils"
 import { budibaseTempDir } from "../../../utilities/budibaseDir"
@@ -20,7 +20,6 @@ type TemplateType = {
   file?: {
     type: string
     path: string
-    password?: string
   }
   key?: string
 }
@@ -124,22 +123,6 @@ export function untarFile(file: { path: string }) {
   return tmpPath
 }
 
-async function decryptFiles(path: string, password: string) {
-  try {
-    for (let file of fs.readdirSync(path)) {
-      const inputPath = join(path, file)
-      const outputPath = inputPath.replace(/\.enc$/, "")
-      await encryption.decryptFile(inputPath, outputPath, password)
-      fs.rmSync(inputPath)
-    }
-  } catch (err: any) {
-    if (err.message === "incorrect header check") {
-      throw new Error("File cannot be imported")
-    }
-    throw err
-  }
-}
-
 export function getGlobalDBFile(tmpPath: string) {
   return fs.readFileSync(join(tmpPath, GLOBAL_DB_EXPORT_FILE), "utf8")
 }
@@ -160,9 +143,6 @@ export async function importApp(
     template.file && fs.lstatSync(template.file.path).isDirectory()
   if (template.file && (isTar || isDirectory)) {
     const tmpPath = isTar ? untarFile(template.file) : template.file.path
-    if (isTar && template.file.password) {
-      await decryptFiles(tmpPath, template.file.password)
-    }
     const contents = fs.readdirSync(tmpPath)
     // have to handle object import
     if (contents.length) {

package/src/sdk/app/datasources/datasources.ts

@@ -164,6 +164,5 @@ export function mergeConfigs(update: Datasource, old: Datasource) {
       delete update.config[key]
     }
   }
-
   return update
 }

package/src/utilities/workerRequests.ts

@@ -9,7 +9,7 @@ import {
   env as coreEnv,
 } from "@budibase/backend-core"
 import { updateAppRole } from "./global"
-import { BBContext, User, EmailInvite } from "@budibase/types"
+import { BBContext, User } from "@budibase/types"
 
 export function request(ctx?: BBContext, request?: any) {
   if (!request.headers) {
@@ -65,25 +65,15 @@ async function checkResponse(
 }
 
 // have to pass in the tenant ID as this could be coming from an automation
-export async function sendSmtpEmail({
-  to,
-  from,
-  subject,
-  contents,
-  cc,
-  bcc,
-  automation,
-  invite,
-}: {
-  to: string
-  from: string
-  subject: string
-  contents: string
-  cc: string
-  bcc: string
+export async function sendSmtpEmail(
+  to: string,
+  from: string,
+  subject: string,
+  contents: string,
+  cc: string,
+  bcc: string,
   automation: boolean
-  invite?: EmailInvite
-}) {
+) {
   // tenant ID will be set in header
   const response = await fetch(
     checkSlashesInUrl(env.WORKER_URL + `/api/global/email/send`),
@@ -98,7 +88,6 @@ export async function sendSmtpEmail({
         bcc,
         purpose: "custom",
         automation,
-        invite,
       },
     })
   )

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

@@ -1,74 +0,0 @@
-import * as workerRequests from "../../utilities/workerRequests"
-
-jest.mock("../../utilities/workerRequests", () => ({
-  sendSmtpEmail: jest.fn(),
-}))
-
-function generateResponse(to: string, from: string) {
-  return {
-    success: true,
-    response: {
-      accepted: [to],
-      envelope: {
-        from: from,
-        to: [to],
-      },
-      message: `Email sent to ${to}.`,
-    },
-  }
-}
-
-const setup = require("./utilities")
-
-describe("test the outgoing webhook action", () => {
-  let inputs
-  let config = setup.getConfig()
-  beforeAll(async () => {
-    await config.init()
-  })
-
-  afterAll(setup.afterAll)
-
-  it("should be able to run the action", async () => {
-    jest
-      .spyOn(workerRequests, "sendSmtpEmail")
-      .mockImplementationOnce(async () =>
-        generateResponse("user1@test.com", "admin@test.com")
-      )
-    const invite = {
-      startTime: new Date(),
-      endTime: new Date(),
-      summary: "summary",
-      location: "location",
-      url: "url",
-    }
-    inputs = {
-      to: "user1@test.com",
-      from: "admin@test.com",
-      subject: "hello",
-      contents: "testing",
-      cc: "cc",
-      bcc: "bcc",
-      addInvite: true,
-      ...invite,
-    }
-    let resp = generateResponse(inputs.to, inputs.from)
-    const res = await setup.runStep(
-      setup.actions.SEND_EMAIL_SMTP.stepId,
-      inputs
-    )
-    expect(res.response).toEqual(resp)
-    expect(res.success).toEqual(true)
-    expect(workerRequests.sendSmtpEmail).toHaveBeenCalledTimes(1)
-    expect(workerRequests.sendSmtpEmail).toHaveBeenCalledWith({
-      to: "user1@test.com",
-      from: "admin@test.com",
-      subject: "hello",
-      contents: "testing",
-      cc: "cc",
-      bcc: "bcc",
-      invite,
-      automation: true,
-    })
-  })
-})