@budibase/server 2.1.32-alpha.7 → 2.1.32

package/src/api/controllers/view/{utils.ts → utils.js}

@@ -1,17 +1,16 @@
-import {
+const {
   ViewName,
   generateMemoryViewID,
   getMemoryViewParams,
   DocumentType,
   SEPARATOR,
-} from "../../../db/utils"
-import env from "../../../environment"
-import { context } from "@budibase/backend-core"
-import viewBuilder from "./viewBuilder"
-import { Database } from "@budibase/types"
+} = require("../../../db/utils")
+const env = require("../../../environment")
+const { getAppDB } = require("@budibase/backend-core/context")
+const viewBuilder = require("./viewBuilder")
 
-export async function getView(viewName: string) {
-  const db = context.getAppDB()
+exports.getView = async viewName => {
+  const db = getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     return designDoc.views[viewName]
@@ -24,7 +23,7 @@ export async function getView(viewName: string) {
     try {
       const viewDoc = await db.get(generateMemoryViewID(viewName))
       return viewDoc.view
-    } catch (err: any) {
+    } catch (err) {
       // Return null when PouchDB doesn't found the view
       if (err.status === 404) {
         return null
@@ -35,15 +34,14 @@ export async function getView(viewName: string) {
   }
 }
 
-export async function getViews() {
-  const db = context.getAppDB()
+exports.getViews = async () => {
+  const db = getAppDB()
   const response = []
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     for (let name of Object.keys(designDoc.views)) {
       // Only return custom views, not built ins
-      const viewNames = Object.values(ViewName) as string[]
-      if (viewNames.indexOf(name) !== -1) {
+      if (Object.values(ViewName).indexOf(name) !== -1) {
         continue
       }
       response.push({
@@ -69,12 +67,8 @@ export async function getViews() {
   return response
 }
 
-export async function saveView(
-  originalName: string | null,
-  viewName: string,
-  viewTemplate: any
-) {
-  const db = context.getAppDB()
+exports.saveView = async (originalName, viewName, viewTemplate) => {
+  const db = getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     designDoc.views = {
@@ -89,7 +83,7 @@ export async function saveView(
   } else {
     const id = generateMemoryViewID(viewName)
     const originalId = originalName ? generateMemoryViewID(originalName) : null
-    const viewDoc: any = {
+    const viewDoc = {
       _id: id,
       view: viewTemplate,
       name: viewName,
@@ -111,8 +105,8 @@ export async function saveView(
   }
 }
 
-export async function deleteView(viewName: string) {
-  const db = context.getAppDB()
+exports.deleteView = async viewName => {
+  const db = getAppDB()
   if (env.SELF_HOSTED) {
     const designDoc = await db.get("_design/database")
     const view = designDoc.views[viewName]
@@ -127,7 +121,7 @@ export async function deleteView(viewName: string) {
   }
 }
 
-export async function migrateToInMemoryView(db: Database, viewName: string) {
+exports.migrateToInMemoryView = async (db, viewName) => {
   // delete the view initially
   const designDoc = await db.get("_design/database")
   // run the view back through the view builder to update it
@@ -137,7 +131,7 @@ export async function migrateToInMemoryView(db: Database, viewName: string) {
   await exports.saveView(db, null, viewName, view)
 }
 
-export async function migrateToDesignView(db: Database, viewName: string) {
+exports.migrateToDesignView = async (db, viewName) => {
   let view = await db.get(generateMemoryViewID(viewName))
   const designDoc = await db.get("_design/database")
   designDoc.views[viewName] = viewBuilder(view.view.meta)
@@ -145,7 +139,7 @@ export async function migrateToDesignView(db: Database, viewName: string) {
   await db.remove(view._id, view._rev)
 }
 
-export async function getFromDesignDoc(db: Database, viewName: string) {
+exports.getFromDesignDoc = async (db, viewName) => {
   const designDoc = await db.get("_design/database")
   let view = designDoc.views[viewName]
   if (view == null) {
@@ -154,7 +148,7 @@ export async function getFromDesignDoc(db: Database, viewName: string) {
   return view
 }
 
-export async function getFromMemoryDoc(db: Database, viewName: string) {
+exports.getFromMemoryDoc = async (db, viewName) => {
   let view = await db.get(generateMemoryViewID(viewName))
   if (view) {
     view = view.view

package/src/api/{index.ts → index.js}

@@ -1,15 +1,20 @@
-import Router from "@koa/router"
-import { errors, auth } from "@budibase/backend-core"
-import currentApp from "../middleware/currentapp"
-import zlib from "zlib"
-import { mainRoutes, staticRoutes, publicRoutes } from "./routes"
-import pkg from "../../package.json"
-import env from "../environment"
-import { middleware as pro } from "@budibase/pro"
-export { shutdown } from "./routes/public"
+const Router = require("@koa/router")
+const {
+  buildAuthMiddleware,
+  auditLog,
+  buildTenancyMiddleware,
+} = require("@budibase/backend-core/auth")
+const { errors } = require("@budibase/backend-core")
+const currentApp = require("../middleware/currentapp")
 const compress = require("koa-compress")
+const zlib = require("zlib")
+const { mainRoutes, staticRoutes, publicRoutes } = require("./routes")
+const pkg = require("../../package.json")
+const env = require("../environment")
+const { middleware: pro } = require("@budibase/pro")
+const { shutdown } = require("./routes/public")
 
-export const router: Router = new Router()
+const router = new Router()
 
 router.get("/health", ctx => (ctx.status = 200))
 router.get("/version", ctx => (ctx.body = pkg.version))
@@ -37,7 +42,7 @@ router
   // re-direct before any middlewares occur
   .redirect("/", "/builder")
   .use(
-    auth.buildAuthMiddleware(null, {
+    buildAuthMiddleware(null, {
       publicAllowed: true,
     })
   )
@@ -45,20 +50,19 @@ router
   // the server can be public anywhere, so nowhere should throw errors
   // if the tenancy has not been set, it'll have to be discovered at application layer
   .use(
-    auth.buildTenancyMiddleware(null, null, {
+    buildTenancyMiddleware(null, null, {
       noTenancyRequired: true,
     })
   )
   .use(pro.licensing())
-  // @ts-ignore
   .use(currentApp)
-  .use(auth.auditLog)
+  .use(auditLog)
 
 // error handling middleware
 router.use(async (ctx, next) => {
   try {
     await next()
-  } catch (err: any) {
+  } catch (err) {
     ctx.status = err.status || err.statusCode || 500
     const error = errors.getPublicError(err)
     ctx.body = {
@@ -87,3 +91,6 @@ router.use(publicRoutes.allowedMethods())
 // WARNING - static routes will catch everything else after them this must be last
 router.use(staticRoutes.routes())
 router.use(staticRoutes.allowedMethods())
+
+module.exports.router = router
+module.exports.shutdown = shutdown

package/src/api/routes/analytics.js

@@ -0,0 +1,9 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/analytics")
+
+const router = new Router()
+
+router.get("/api/bbtel", controller.isEnabled)
+router.post("/api/bbtel/ping", controller.ping)
+
+module.exports = router

package/src/api/routes/apikeys.js

@@ -0,0 +1,12 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/apikeys")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+router
+  .get("/api/keys", authorized(BUILDER), controller.fetch)
+  .put("/api/keys/:key", authorized(BUILDER), controller.update)
+
+module.exports = router

package/src/api/routes/application.ts

@@ -1,20 +1,16 @@
 import Router from "@koa/router"
 import * as controller from "../controllers/application"
 import authorized from "../../middleware/authorized"
-import { permissions } from "@budibase/backend-core"
+import { BUILDER } from "@budibase/backend-core/permissions"
 import { applicationValidator } from "./utils/validators"
 
-const router: Router = new Router()
+const router = new Router()
 
 router
-  .post(
-    "/api/applications/:appId/sync",
-    authorized(permissions.BUILDER),
-    controller.sync
-  )
+  .post("/api/applications/:appId/sync", authorized(BUILDER), controller.sync)
   .post(
     "/api/applications",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     applicationValidator(),
     controller.create
   )
@@ -23,24 +19,20 @@ router
   .get("/api/applications/:appId/appPackage", controller.fetchAppPackage)
   .put(
     "/api/applications/:appId",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     applicationValidator({ isCreate: false }),
     controller.update
   )
   .post(
     "/api/applications/:appId/client/update",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     controller.updateClient
   )
   .post(
     "/api/applications/:appId/client/revert",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     controller.revertClient
   )
-  .delete(
-    "/api/applications/:appId",
-    authorized(permissions.BUILDER),
-    controller.destroy
-  )
+  .delete("/api/applications/:appId", authorized(BUILDER), controller.destroy)
 
-export = router
+export default router

package/src/api/routes/auth.ts

@@ -1,8 +1,8 @@
 import Router from "@koa/router"
 import * as controller from "../controllers/auth"
 
-const router: Router = new Router()
+const router = new Router()
 
 router.get("/api/self", controller.fetchSelf)
 
-export = router
+export default router

package/src/api/routes/automation.js

@@ -0,0 +1,85 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/automation")
+const authorized = require("../../middleware/authorized")
+const {
+  BUILDER,
+  PermissionLevels,
+  PermissionTypes,
+} = require("@budibase/backend-core/permissions")
+const { bodyResource, paramResource } = require("../../middleware/resourceId")
+const {
+  middleware: appInfoMiddleware,
+  AppType,
+} = require("../../middleware/appInfo")
+const { automationValidator } = require("./utils/validators")
+
+const router = new Router()
+
+router
+  .get(
+    "/api/automations/trigger/list",
+    authorized(BUILDER),
+    controller.getTriggerList
+  )
+  .get(
+    "/api/automations/action/list",
+    authorized(BUILDER),
+    controller.getActionList
+  )
+  .get(
+    "/api/automations/definitions/list",
+    authorized(BUILDER),
+    controller.getDefinitionList
+  )
+  .get("/api/automations", authorized(BUILDER), controller.fetch)
+  .get(
+    "/api/automations/:id",
+    paramResource("id"),
+    authorized(BUILDER),
+    controller.find
+  )
+  .put(
+    "/api/automations",
+    bodyResource("_id"),
+    authorized(BUILDER),
+    automationValidator(true),
+    controller.update
+  )
+  .post(
+    "/api/automations",
+    authorized(BUILDER),
+    automationValidator(false),
+    controller.create
+  )
+  .post(
+    "/api/automations/logs/search",
+    authorized(BUILDER),
+    controller.logSearch
+  )
+  .delete(
+    "/api/automations/logs",
+    authorized(BUILDER),
+    controller.clearLogError
+  )
+  .delete(
+    "/api/automations/:id/:rev",
+    paramResource("id"),
+    authorized(BUILDER),
+    controller.destroy
+  )
+  .post(
+    "/api/automations/:id/trigger",
+    appInfoMiddleware({ appType: AppType.PROD }),
+    paramResource("id"),
+    authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE),
+    controller.trigger
+  )
+  .post(
+    "/api/automations/:id/test",
+    appInfoMiddleware({ appType: AppType.DEV }),
+    paramResource("id"),
+    authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE),
+    controller.test
+  )
+
+module.exports = router

package/src/api/routes/backup.ts

@@ -1,14 +1,10 @@
 import Router from "@koa/router"
 import * as controller from "../controllers/backup"
 import authorized from "../../middleware/authorized"
-import { permissions } from "@budibase/backend-core"
+import { BUILDER } from "@budibase/backend-core/permissions"
 
-const router: Router = new Router()
+const router = new Router()
 
-router.get(
-  "/api/backups/export",
-  authorized(permissions.BUILDER),
-  controller.exportAppDump
-)
+router.get("/api/backups/export", authorized(BUILDER), controller.exportAppDump)
 
-export = router
+export default router

package/src/api/routes/cloud.js

@@ -0,0 +1,14 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/cloud")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+router
+  .get("/api/cloud/export", authorized(BUILDER), controller.exportApps)
+  // has to be public, only run if apps don't exist
+  .post("/api/cloud/import", controller.importApps)
+  .get("/api/cloud/import/complete", controller.hasBeenImported)
+
+module.exports = router

package/src/api/routes/component.js

@@ -0,0 +1,14 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/component")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+router.get(
+  "/api/:appId/components/definitions",
+  authorized(BUILDER),
+  controller.fetchAppComponentDefinitions
+)
+
+module.exports = router

package/src/api/routes/datasource.js

@@ -0,0 +1,51 @@
+const Router = require("@koa/router")
+const datasourceController = require("../controllers/datasource")
+const authorized = require("../../middleware/authorized")
+const {
+  BUILDER,
+  PermissionLevels,
+  PermissionTypes,
+} = require("@budibase/backend-core/permissions")
+const {
+  datasourceValidator,
+  datasourceQueryValidator,
+} = require("./utils/validators")
+
+const router = new Router()
+
+router
+  .get("/api/datasources", authorized(BUILDER), datasourceController.fetch)
+  .get(
+    "/api/datasources/:datasourceId",
+    authorized(PermissionTypes.TABLE, PermissionLevels.READ),
+    datasourceController.find
+  )
+  .put(
+    "/api/datasources/:datasourceId",
+    authorized(PermissionTypes.TABLE, PermissionLevels.READ),
+    datasourceController.update
+  )
+  .post(
+    "/api/datasources/query",
+    authorized(PermissionTypes.TABLE, PermissionLevels.READ),
+    datasourceQueryValidator(),
+    datasourceController.query
+  )
+  .post(
+    "/api/datasources/:datasourceId/schema",
+    authorized(BUILDER),
+    datasourceController.buildSchemaFromDb
+  )
+  .post(
+    "/api/datasources",
+    authorized(BUILDER),
+    datasourceValidator(),
+    datasourceController.save
+  )
+  .delete(
+    "/api/datasources/:datasourceId/:revId",
+    authorized(BUILDER),
+    datasourceController.destroy
+  )
+
+module.exports = router

package/src/api/routes/deploy.js

@@ -0,0 +1,17 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/deploy")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+router
+  .get("/api/deployments", authorized(BUILDER), controller.fetchDeployments)
+  .get(
+    "/api/deploy/:deploymentId",
+    authorized(BUILDER),
+    controller.deploymentProgress
+  )
+  .post("/api/deploy", authorized(BUILDER), controller.deployApp)
+
+module.exports = router

package/src/api/routes/dev.js

@@ -0,0 +1,26 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/dev")
+const env = require("../../environment")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+function redirectPath(path) {
+  router
+    .get(`/api/${path}/:devPath(.*)`, controller.buildRedirectGet(path))
+    .post(`/api/${path}/:devPath(.*)`, controller.buildRedirectPost(path))
+    .delete(`/api/${path}/:devPath(.*)`, controller.buildRedirectDelete(path))
+}
+
+if (env.isDev() || env.isTest()) {
+  redirectPath("global")
+  redirectPath("system")
+}
+
+router
+  .get("/api/dev/version", authorized(BUILDER), controller.getBudibaseVersion)
+  .delete("/api/dev/:appId/lock", authorized(BUILDER), controller.clearLock)
+  .post("/api/dev/:appId/revert", authorized(BUILDER), controller.revert)
+
+module.exports = router

package/src/api/routes/integration.js

@@ -0,0 +1,12 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/integration")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+
+const router = new Router()
+
+router
+  .get("/api/integrations", authorized(BUILDER), controller.fetch)
+  .get("/api/integrations/:type", authorized(BUILDER), controller.find)
+
+module.exports = router

package/src/api/routes/layout.js

@@ -0,0 +1,16 @@
+const Router = require("@koa/router")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+const controller = require("../controllers/layout")
+
+const router = new Router()
+
+router
+  .post("/api/layouts", authorized(BUILDER), controller.save)
+  .delete(
+    "/api/layouts/:layoutId/:layoutRev",
+    authorized(BUILDER),
+    controller.destroy
+  )
+
+module.exports = router

package/src/api/routes/{metadata.ts → metadata.js}

@@ -1,38 +1,38 @@
-import Router from "@koa/router"
-import * as controller from "../controllers/metadata"
-import {
-  middleware as appInfoMiddleware,
+const Router = require("@koa/router")
+const controller = require("../controllers/metadata")
+const {
+  middleware: appInfoMiddleware,
   AppType,
-} from "../../middleware/appInfo"
-import authorized from "../../middleware/authorized"
-import { permissions } from "@budibase/backend-core"
+} = require("../../middleware/appInfo")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
 
-const router: Router = new Router()
+const router = new Router()
 
 router
   .post(
     "/api/metadata/:type/:entityId",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     appInfoMiddleware({ appType: AppType.DEV }),
     controller.saveMetadata
   )
   .delete(
     "/api/metadata/:type/:entityId",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     appInfoMiddleware({ appType: AppType.DEV }),
     controller.deleteMetadata
   )
   .get(
     "/api/metadata/type",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     appInfoMiddleware({ appType: AppType.DEV }),
     controller.getTypes
   )
   .get(
     "/api/metadata/:type/:entityId",
-    authorized(permissions.BUILDER),
+    authorized(BUILDER),
     appInfoMiddleware({ appType: AppType.DEV }),
     controller.getMetadata
   )
 
-export = router
+module.exports = router

package/src/api/routes/migrations.js

@@ -0,0 +1,14 @@
+const Router = require("@koa/router")
+const migrationsController = require("../controllers/migrations")
+const router = new Router()
+const { internalApi } = require("@budibase/backend-core/auth")
+
+router
+  .post("/api/migrations/run", internalApi, migrationsController.migrate)
+  .get(
+    "/api/migrations/definitions",
+    internalApi,
+    migrationsController.fetchDefinitions
+  )
+
+module.exports = router

package/src/api/routes/permission.js

@@ -0,0 +1,33 @@
+const Router = require("@koa/router")
+const controller = require("../controllers/permission")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+const { permissionValidator } = require("./utils/validators")
+
+const router = new Router()
+
+router
+  .get("/api/permission/builtin", authorized(BUILDER), controller.fetchBuiltin)
+  .get("/api/permission/levels", authorized(BUILDER), controller.fetchLevels)
+  .get("/api/permission", authorized(BUILDER), controller.fetch)
+  .get(
+    "/api/permission/:resourceId",
+    authorized(BUILDER),
+    controller.getResourcePerms
+  )
+  // adding a specific role/level for the resource overrides the underlying access control
+  .post(
+    "/api/permission/:roleId/:resourceId/:level",
+    authorized(BUILDER),
+    permissionValidator(),
+    controller.addPermission
+  )
+  // deleting the level defaults it back the underlying access control for the resource
+  .delete(
+    "/api/permission/:roleId/:resourceId/:level",
+    authorized(BUILDER),
+    permissionValidator(),
+    controller.removePermission
+  )
+
+module.exports = router