@budibase/server 2.2.26 → 2.2.27

package/src/api/routes/public/applications.ts

@@ -1,6 +1,7 @@
 import controller from "../../controllers/public/applications"
 import Endpoint from "./utils/Endpoint"
 const { nameValidator, applicationValidator } = require("../utils/validators")
+import { db } from "@budibase/backend-core"
 
 const read = [],
   write = []
@@ -94,6 +95,49 @@ write.push(
  */
 write.push(new Endpoint("delete", "/applications/:appId", controller.destroy))
 
+/**
+ * @openapi
+ * /applications/{appId}/unpublish:
+ *   post:
+ *     operationId: unpublish
+ *     summary: Unpublish an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appIdUrl'
+ *     responses:
+ *       204:
+ *         description: The app was published successfully.
+ */
+write.push(
+  new Endpoint("post", "/applications/:appId/unpublish", controller.unpublish)
+)
+
+/**
+ * @openapi
+ * /applications/{appId}/publish:
+ *   post:
+ *     operationId: publish
+ *     summary: Unpublish an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appIdUrl'
+ *     responses:
+ *       200:
+ *         description: Returns the deployment object.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/deploymentOutput'
+ *             examples:
+ *               deployment:
+ *                 $ref: '#/components/examples/deploymentOutput'
+ */
+write.push(
+  new Endpoint("post", "/applications/:appId/publish", controller.publish)
+)
+
 /**
  * @openapi
  * /applications/{appId}:

package/src/api/routes/public/middleware/mapper.ts

@@ -54,9 +54,13 @@ function processQueries(ctx: any) {
 }
 
 export default async (ctx: any, next: any) => {
+  if (!ctx.body) {
+    return await next()
+  }
   let urlParts = ctx.url.split("/")
   urlParts = urlParts.slice(4, urlParts.length)
   let body = {}
+
   switch (urlParts[0]) {
     case Resources.APPLICATION:
       body = processApplications(ctx)

package/src/api/routes/query.ts

@@ -58,4 +58,4 @@ router
     queryController.executeV2 as any
   )
 
-export = router
+export default router

package/src/api/routes/role.ts

@@ -21,4 +21,4 @@ router
     controller.destroy
   )
 
-export = router
+export default router

package/src/api/routes/routing.ts

@@ -11,4 +11,4 @@ router
   // gets the full structure, not just the correct screen ID for user role
   .get("/api/routing", authorized(permissions.BUILDER), controller.fetch)
 
-export = router
+export default router

package/src/api/routes/row.ts

@@ -3,7 +3,7 @@ import * as rowController from "../controllers/row"
 import authorized from "../../middleware/authorized"
 import { paramResource, paramSubResource } from "../../middleware/resourceId"
 import { permissions } from "@budibase/backend-core"
-const { internalSearchValidator } = require("./utils/validators")
+import { internalSearchValidator } from "./utils/validators"
 const { PermissionType, PermissionLevel } = permissions
 
 const router: Router = new Router()

package/src/api/routes/screen.ts

@@ -20,4 +20,4 @@ router
     controller.destroy
   )
 
-export = router
+export default router

package/src/api/routes/script.ts

@@ -7,4 +7,4 @@ const router: Router = new Router()
 
 router.post("/api/script", authorized(permissions.BUILDER), controller.save)
 
-export = router
+export default router

package/src/api/routes/static.ts

@@ -3,7 +3,7 @@ import * as controller from "../controllers/static"
 import { budibaseTempDir } from "../../utilities/budibaseDir"
 import authorized from "../../middleware/authorized"
 import { permissions } from "@budibase/backend-core"
-import * as env from "../../environment"
+import env from "../../environment"
 import { paramResource } from "../../middleware/resourceId"
 const { BUILDER, PermissionType, PermissionLevel } = permissions
 
@@ -62,4 +62,4 @@ router
     controller.getSignedUploadURL
   )
 
-export = router
+export default router

package/src/api/routes/table.ts

@@ -67,10 +67,7 @@ router
    * structure, and the "updated", new column name should also be supplied. The schema should also be updated, this field
    * lets the server know that a field hasn't just been deleted, that the data has moved to a new name, this will fix
    * the rows in the table. This functionality is only available for internal tables.
-   * @apiParam (Body) {object} [dataImport] When creating an internal table it can be built from a CSV, by using the
-   * CSV validation endpoint. Send the CSV data to the validation endpoint, then put the results of that call
-   * into this property, along with the CSV and a table/rows will be built from it. This is not supported when updating
-   * or for external tables.
+   * @apiParam (Body) {object[]} [rows] When creating a table using a compatible data source, an array of objects to be imported into the new table can be provided.
    *
    * @apiParamExample {json} Example:
    * {
@@ -99,15 +96,7 @@ router
    *     "old": "columnName",
    *     "updated": "newColumnName",
    *   },
-   *   "dataImport": {
-   *     "csvString": "column\nvalue",
-   *     "primaryDisplay": "column",
-   *     "schema": {
-   *       "column": {
-   *         "type": "string"
-   *       }
-   *     }
-   *   }
+   *   "rows": []
    * }
    *
    * @apiSuccess {object} table The response body will contain the table structure after being cleaned up and
@@ -121,30 +110,20 @@ router
     tableValidator(),
     tableController.save
   )
-  /**
-   * @api {post} /api/tables/csv/validate Validate a CSV for a table
-   * @apiName Validate a CSV for a table
-   * @apiGroup tables
-   * @apiPermission builder
-   * @apiDescription When creating a new table, or importing a CSV to an existing table the CSV must be validated and
-   * converted into a Budibase schema; this endpoint does this.
-   *
-   * @apiParam (Body) {string} csvString The CSV which is to be validated as a string.
-   * @apiParam (Body) {object} [schema] When a CSV has been validated it is possible to re-validate after changing the
-   * type of a field, by default everything will be strings as there is no way to infer types. The returned schema can
-   * be updated and then returned to the endpoint to re-validate and check if the type will work for the CSV, e.g.
-   * using a number instead of strings.
-   * @apiParam (Body) {string} [tableId] If importing data to an existing table this will pull the current table and
-   * remove any fields from the CSV schema which do not exist on the table/don't match the type of the table. When
-   * importing a CSV to an existing table only fields that are present on the table can be imported.
-   *
-   * @apiSuccess {object} schema The response body will contain a "schema" object that represents the schema found for
-   * the CSV - this will be in the same format used for table schema.s
-   */
   .post(
-    "/api/tables/csv/validate",
+    "/api/convert/csvToJson",
+    authorized(BUILDER),
+    tableController.csvToJson
+  )
+  .post(
+    "/api/tables/validateNewTableImport",
+    authorized(BUILDER),
+    tableController.validateNewTableImport
+  )
+  .post(
+    "/api/tables/validateExistingTableImport",
     authorized(BUILDER),
-    tableController.validateCSVSchema
+    tableController.validateExistingTableImport
   )
   /**
    * @api {post} /api/tables/:tableId/:revId Delete a table
@@ -177,9 +156,7 @@ router
    *
    * @apiParam {string} tableId The ID of the table which the data should be imported to.
    *
-   * @apiParam (Body) {object} dataImport This is the same as the structure used when creating an internal table with
-   * a CSV, it will have the "schema" returned from the CSV validation endpoint and the "csvString" which is to be
-   * turned into rows.
+   * @apiParam (Body) {object[]} rows An array of objects representing the rows to be imported, key-value pairs not matching the table schema will be ignored.
    *
    * @apiSuccess {string} message A message stating that the data was imported successfully.
    */
@@ -190,4 +167,4 @@ router
     tableController.bulkImport
   )
 
-export = router
+export default router

package/src/api/routes/templates.ts

@@ -13,4 +13,4 @@ router
     controller.downloadTemplate
   )
 
-export = router
+export default router

package/src/api/routes/tests/{application.spec.js → application.spec.ts}

@@ -11,14 +11,11 @@ jest.mock("../../../utilities/redis", () => ({
   checkDebounce: jest.fn(),
   shutdown: jest.fn(),
 }))
-
-const {
-  clearAllApps,
-  checkBuilderEndpoint,
-} = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-const { AppStatus } = require("../../../db/utils")
-const { events } = require("@budibase/backend-core")
+import { clearAllApps, checkBuilderEndpoint } from "./utilities/TestFunctions"
+import * as setup from "./utilities"
+import { AppStatus } from "../../../db/utils"
+import { events } from "@budibase/backend-core"
+import env from "../../../environment"
 
 describe("/applications", () => {
   let request = setup.getRequest()
@@ -162,33 +159,30 @@ describe("/applications", () => {
     })
   })
 
-  describe("delete", () => {
-    it("should delete app", async () => {
-      await config.createApp("to-delete")
+  describe("publish", () => {
+    it("should publish app with dev app ID", async () => {
       const appId = config.getAppId()
       await request
-        .delete(`/api/applications/${appId}`)
+        .post(`/api/applications/${appId}/publish`)
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
-      expect(events.app.deleted).toBeCalledTimes(1)
+      expect(events.app.published).toBeCalledTimes(1)
     })
 
-    it("should unpublish app", async () => {
-      await config.createApp("to-unpublish")
+    it("should publish app with prod app ID", async () => {
       const appId = config.getProdAppId()
       await request
-        .delete(`/api/applications/${appId}?unpublish=true`)
+        .post(`/api/applications/${appId}/publish`)
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
-      expect(events.app.unpublished).toBeCalledTimes(1)
+      expect(events.app.published).toBeCalledTimes(1)
     })
   })
 
   describe("manage client library version", () => {
     it("should be able to update the app client library version", async () => {
-      console.log(config.getAppId())
       await request
         .post(`/api/applications/${config.getAppId()}/client/update`)
         .set(config.defaultHeaders())
@@ -196,6 +190,7 @@ describe("/applications", () => {
         .expect(200)
       expect(events.app.versionUpdated).toBeCalledTimes(1)
     })
+
     it("should be able to revert the app client library version", async () => {
       // We need to first update the version so that we can then revert
       await request
@@ -234,4 +229,85 @@ describe("/applications", () => {
       expect(getRes.body.application.updatedAt).toBeDefined()
     })
   })
+
+  describe("sync", () => {
+    it("app should sync correctly", async () => {
+      const res = await request
+        .post(`/api/applications/${config.getAppId()}/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toEqual("App sync completed successfully.")
+    })
+
+    it("app should not sync if production", async () => {
+      const res = await request
+        .post(`/api/applications/app_123456/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(400)
+      expect(res.body.message).toEqual(
+        "This action cannot be performed for production apps"
+      )
+    })
+
+    it("app should not sync if sync is disabled", async () => {
+      env._set("DISABLE_AUTO_PROD_APP_SYNC", true)
+      const res = await request
+        .post(`/api/applications/${config.getAppId()}/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toEqual(
+        "App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable."
+      )
+      env._set("DISABLE_AUTO_PROD_APP_SYNC", false)
+    })
+  })
+
+  describe("unpublish", () => {
+    it("should unpublish app with dev app ID", async () => {
+      const appId = config.getAppId()
+      await request
+        .post(`/api/applications/${appId}/unpublish`)
+        .set(config.defaultHeaders())
+        .expect(204)
+      expect(events.app.unpublished).toBeCalledTimes(1)
+    })
+
+    it("should unpublish app with prod app ID", async () => {
+      const appId = config.getProdAppId()
+      await request
+        .post(`/api/applications/${appId}/unpublish`)
+        .set(config.defaultHeaders())
+        .expect(204)
+      expect(events.app.unpublished).toBeCalledTimes(1)
+    })
+  })
+
+  describe("delete", () => {
+    it("should delete published app and dev apps with dev app ID", async () => {
+      await config.createApp("to-delete")
+      const appId = config.getAppId()
+      await request
+        .delete(`/api/applications/${appId}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.deleted).toBeCalledTimes(1)
+      expect(events.app.unpublished).toBeCalledTimes(1)
+    })
+
+    it("should delete published app and dev app with prod app ID", async () => {
+      await config.createApp("to-delete")
+      const appId = config.getProdAppId()
+      await request
+        .delete(`/api/applications/${appId}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.deleted).toBeCalledTimes(1)
+      expect(events.app.unpublished).toBeCalledTimes(1)
+    })
+  })
 })

package/src/api/routes/tests/{backup.spec.js → backup.spec.ts}

@@ -8,10 +8,10 @@ jest.mock("@budibase/backend-core", () => {
   }
 })
 
-const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-const { events } = require("@budibase/backend-core")
-
+import * as setup from "./utilities"
+import { events } from "@budibase/backend-core"
+import sdk from "../../../sdk"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
 describe("/backups", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
@@ -30,7 +30,7 @@ describe("/backups", () => {
         .expect(200)
       expect(res.text).toBeDefined()
       expect(res.headers["content-type"]).toEqual("application/gzip")
-      expect(events.app.exported.mock.calls.length).toBe(1)
+      expect(events.app.exported).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -41,4 +41,15 @@ describe("/backups", () => {
       })
     })
   })
-})
+
+  describe("calculateBackupStats", () => {
+    it("should be able to calculate the backup statistics", async () => {
+      config.createAutomation()
+      config.createScreen()
+      let res = await sdk.backups.calculateBackupStats(config.getAppId())
+      expect(res.automations).toEqual(1)
+      expect(res.datasources).toEqual(1)
+      expect(res.screens).toEqual(1)
+    })
+  })
+})

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

@@ -0,0 +1,65 @@
+import { db as dbCore } from "@budibase/backend-core"
+import { AppStatus } from "../../../db/utils"
+
+import * as setup from "./utilities"
+
+describe("/cloud", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+  })
+
+  afterEach(async () => {
+    // clear all mocks
+    jest.clearAllMocks()
+  })
+
+  describe("import", () => {
+    it("should be able to import apps", async () => {
+      // first we need to delete any existing apps on the system so it looks clean otherwise the
+      // import will not run
+      await request
+        .post(
+          `/api/applications/${dbCore.getProdAppID(
+            config.getAppId()
+          )}/unpublish`
+        )
+        .set(config.defaultHeaders())
+        .expect(204)
+      await request
+        .delete(`/api/applications/${config.getAppId()}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // get a count of apps before the import
+      const preImportApps = await request
+        .get(`/api/applications?status=${AppStatus.ALL}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // Perform the import
+      const res = await request
+        .post(`/api/cloud/import`)
+        .attach("importFile", "src/api/routes/tests/data/export-test.tar.gz")
+        .set(config.defaultHeaders())
+        .expect(200)
+      expect(res.body.message).toEqual("Apps successfully imported.")
+
+      // get a count of apps after the import
+      const postImportApps = await request
+        .get(`/api/applications?status=${AppStatus.ALL}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // There are two apps in the file that was imported so check for this
+      expect(postImportApps.body.length).toEqual(2)
+    })
+  })
+})

package/src/api/routes/tests/{datasource.spec.js → datasource.spec.ts}

@@ -1,16 +1,17 @@
 jest.mock("pg")
+import * as setup from "./utilities"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
+import { checkCacheForDynamicVariable } from "../../../threads/utils"
+import { context, events } from "@budibase/backend-core"
+import sdk from "../../../sdk"
 
-let setup = require("./utilities")
 let { basicDatasource } = setup.structures
-let { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const pg = require("pg")
-const { checkCacheForDynamicVariable } = require("../../../threads/utils")
-const { events } = require("@budibase/backend-core") 
 
 describe("/datasources", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
-  let datasource
+  let datasource: any
 
   afterAll(setup.afterAll)
 
@@ -26,7 +27,7 @@ describe("/datasources", () => {
         .post(`/api/datasources`)
         .send(basicDatasource())
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.datasource.name).toEqual("Test")
@@ -42,7 +43,7 @@ describe("/datasources", () => {
         .put(`/api/datasources/${datasource._id}`)
         .send(datasource)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.datasource.name).toEqual("Updated Test")
@@ -51,25 +52,34 @@ describe("/datasources", () => {
     })
 
     describe("dynamic variables", () => {
-      async function preview(datasource, fields) {
+      async function preview(
+        datasource: any,
+        fields: { path: string; queryString: string }
+      ) {
         return config.previewQuery(request, config, datasource, fields)
       }
 
       it("should invalidate changed or removed variables", async () => {
         const { datasource, query } = await config.dynamicVariableDatasource()
         // preview once to cache variables
-        await preview(datasource, { path: "www.test.com", queryString: "test={{ variable3 }}" })
+        await preview(datasource, {
+          path: "www.test.com",
+          queryString: "test={{ variable3 }}",
+        })
         // check variables in cache
-        let contents = await checkCacheForDynamicVariable(query._id, "variable3")
+        let contents = await checkCacheForDynamicVariable(
+          query._id,
+          "variable3"
+        )
         expect(contents.rows.length).toEqual(1)
-        
+
         // update the datasource to remove the variables
         datasource.config.dynamicVariables = []
         const res = await request
           .put(`/api/datasources/${datasource._id}`)
           .send(datasource)
           .set(config.defaultHeaders())
-          .expect('Content-Type', /json/)
+          .expect("Content-Type", /json/)
           .expect(200)
         expect(res.body.errors).toBeUndefined()
 
@@ -85,7 +95,7 @@ describe("/datasources", () => {
       const res = await request
         .get(`/api/datasources`)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       const datasources = res.body
@@ -160,7 +170,7 @@ describe("/datasources", () => {
       const res = await request
         .get(`/api/datasources`)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.length).toEqual(1)
@@ -174,6 +184,38 @@ describe("/datasources", () => {
         url: `/api/datasources/${datasource._id}/${datasource._rev}`,
       })
     })
+  })
+
+  describe("check secret replacement", () => {
+    async function makeDatasource() {
+      datasource = basicDatasource()
+      datasource.datasource.config.password = "testing"
+      const res = await request
+        .post(`/api/datasources`)
+        .send(datasource)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      return res.body.datasource
+    }
+
+    it("should save a datasource with password", async () => {
+      const datasource = await makeDatasource()
+      expect(datasource.config.password).toBe("--secret-value--")
+    })
 
+    it("should not the password on update with the --secret-value--", async () => {
+      const datasource = await makeDatasource()
+      await request
+        .put(`/api/datasources/${datasource._id}`)
+        .send(datasource)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      await context.doInAppContext(config.getAppId(), async () => {
+        const dbDatasource: any = await sdk.datasources.get(datasource._id)
+        expect(dbDatasource.config.password).toBe("testing")
+      })
+    })
   })
 })

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

@@ -42,7 +42,7 @@ describe("run misc tests", () => {
   })
 
   describe("test table utilities", () => {
-    it("should be able to import a CSV", async () => {
+    it("should be able to import data", async () => {
       return config.doInContext(null, async () => {
         const table = await config.createTable({
           name: "table",
@@ -75,17 +75,11 @@ describe("run misc tests", () => {
             },
           },
         })
-        const dataImport = {
-          csvString: "a,b,c,d\n1,2,3,4",
-          schema: {},
-        }
-        for (let col of ["a", "b", "c", "d"]) {
-          dataImport.schema[col] = { type: "string" }
-        }
+
         await tableUtils.handleDataImport(
           { userId: "test" },
           table,
-          dataImport
+          [{ a: '1', b: '2', c: '3', d: '4'}]
         )
         const rows = await config.getRows()
         expect(rows[0].a).toEqual("1")
@@ -94,4 +88,4 @@ describe("run misc tests", () => {
       })
     })
   })
-})
+})