@budibase/server 2.1.32-alpha.1 → 2.1.32-alpha.10

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

@@ -1,20 +1,15 @@
-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")
+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 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")
 
-const router = new Router()
+export const router: Router = new Router()
 
 router.get("/health", ctx => (ctx.status = 200))
 router.get("/version", ctx => (ctx.body = pkg.version))
@@ -42,7 +37,7 @@ router
   // re-direct before any middlewares occur
   .redirect("/", "/builder")
   .use(
-    buildAuthMiddleware(null, {
+    auth.buildAuthMiddleware(null, {
       publicAllowed: true,
     })
   )
@@ -50,19 +45,20 @@ 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(
-    buildTenancyMiddleware(null, null, {
+    auth.buildTenancyMiddleware(null, null, {
       noTenancyRequired: true,
     })
   )
   .use(pro.licensing())
+  // @ts-ignore
   .use(currentApp)
-  .use(auditLog)
+  .use(auth.auditLog)
 
 // error handling middleware
 router.use(async (ctx, next) => {
   try {
     await next()
-  } catch (err) {
+  } catch (err: any) {
     ctx.status = err.status || err.statusCode || 500
     const error = errors.getPublicError(err)
     ctx.body = {
@@ -91,6 +87,3 @@ 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.ts

@@ -0,0 +1,9 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/analytics"
+
+const router: Router = new Router()
+
+router.get("/api/bbtel", controller.isEnabled)
+router.post("/api/bbtel/ping", controller.ping)
+
+export = router

package/src/api/routes/apikeys.ts

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

package/src/api/routes/application.ts

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

package/src/api/routes/auth.ts

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

package/src/api/routes/automation.ts

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

package/src/api/routes/backup.ts

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

package/src/api/routes/cloud.ts

@@ -0,0 +1,18 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/cloud"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+
+const router: Router = new Router()
+
+router
+  .get(
+    "/api/cloud/export",
+    authorized(permissions.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)
+
+export = router

package/src/api/routes/component.ts

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

package/src/api/routes/datasource.ts

@@ -0,0 +1,60 @@
+import Router from "@koa/router"
+import * as datasourceController from "../controllers/datasource"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+import {
+  datasourceValidator,
+  datasourceQueryValidator,
+} from "./utils/validators"
+
+const router: Router = new Router()
+
+router
+  .get(
+    "/api/datasources",
+    authorized(permissions.BUILDER),
+    datasourceController.fetch
+  )
+  .get(
+    "/api/datasources/:datasourceId",
+    authorized(
+      permissions.PermissionType.TABLE,
+      permissions.PermissionLevel.READ
+    ),
+    datasourceController.find
+  )
+  .put(
+    "/api/datasources/:datasourceId",
+    authorized(
+      permissions.PermissionType.TABLE,
+      permissions.PermissionLevel.READ
+    ),
+    datasourceController.update
+  )
+  .post(
+    "/api/datasources/query",
+    authorized(
+      permissions.PermissionType.TABLE,
+      permissions.PermissionLevel.READ
+    ),
+    datasourceQueryValidator(),
+    datasourceController.query
+  )
+  .post(
+    "/api/datasources/:datasourceId/schema",
+    authorized(permissions.BUILDER),
+    datasourceController.buildSchemaFromDb
+  )
+  .post(
+    "/api/datasources",
+    authorized(permissions.BUILDER),
+    datasourceValidator(),
+    datasourceController.save
+  )
+  .delete(
+    "/api/datasources/:datasourceId/:revId",
+    authorized(permissions.BUILDER),
+    datasourceController.destroy
+  )
+
+export = router

package/src/api/routes/deploy.ts

@@ -0,0 +1,21 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/deploy"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+
+const router: Router = new Router()
+
+router
+  .get(
+    "/api/deployments",
+    authorized(permissions.BUILDER),
+    controller.fetchDeployments
+  )
+  .get(
+    "/api/deploy/:deploymentId",
+    authorized(permissions.BUILDER),
+    controller.deploymentProgress
+  )
+  .post("/api/deploy", authorized(permissions.BUILDER), controller.deployApp)
+
+export = router

package/src/api/routes/dev.ts

@@ -0,0 +1,38 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/dev"
+import env from "../../environment"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+
+const router: Router = new Router()
+
+function redirectPath(path: string) {
+  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(permissions.BUILDER),
+    controller.getBudibaseVersion
+  )
+  .delete(
+    "/api/dev/:appId/lock",
+    authorized(permissions.BUILDER),
+    controller.clearLock
+  )
+  .post(
+    "/api/dev/:appId/revert",
+    authorized(permissions.BUILDER),
+    controller.revert
+  )
+
+export = router

package/src/api/routes/integration.ts

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

package/src/api/routes/layout.ts

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

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

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

package/src/api/routes/migrations.ts

@@ -0,0 +1,14 @@
+import Router from "@koa/router"
+import * as migrationsController from "../controllers/migrations"
+import { auth } from "@budibase/backend-core"
+
+const router: Router = new Router()
+
+router
+  .post("/api/migrations/run", auth.internalApi, migrationsController.migrate)
+  .get(
+    "/api/migrations/definitions",
+    auth.internalApi,
+    migrationsController.fetchDefinitions
+  )
+export = router

package/src/api/routes/permission.ts

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

package/src/api/routes/plugin.ts

@@ -1,14 +1,22 @@
 import Router from "@koa/router"
 import * as controller from "../controllers/plugin"
 import authorized from "../../middleware/authorized"
-import { BUILDER } from "@budibase/backend-core/permissions"
+import { permissions } from "@budibase/backend-core"
 
-const router = new Router()
+const router: Router = new Router()
 
 router
-  .post("/api/plugin/upload", authorized(BUILDER), controller.upload)
-  .post("/api/plugin", authorized(BUILDER), controller.create)
-  .get("/api/plugin", authorized(BUILDER), controller.fetch)
-  .delete("/api/plugin/:pluginId", authorized(BUILDER), controller.destroy)
+  .post(
+    "/api/plugin/upload",
+    authorized(permissions.BUILDER),
+    controller.upload
+  )
+  .post("/api/plugin", authorized(permissions.BUILDER), controller.create)
+  .get("/api/plugin", authorized(permissions.BUILDER), controller.fetch)
+  .delete(
+    "/api/plugin/:pluginId",
+    authorized(permissions.BUILDER),
+    controller.destroy
+  )
 
 export default router

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

@@ -1,22 +1,19 @@
-const Router = require("@koa/router")
-const queryController = require("../controllers/query")
-const authorized = require("../../middleware/authorized")
-const {
-  PermissionLevel,
-  PermissionType,
-  BUILDER,
-} = require("@budibase/backend-core/permissions")
-const {
+import Router from "@koa/router"
+import * as queryController from "../controllers/query"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+import {
   bodyResource,
   bodySubResource,
   paramResource,
-} = require("../../middleware/resourceId")
-const {
+} from "../../middleware/resourceId"
+import {
   generateQueryPreviewValidation,
   generateQueryValidation,
-} = require("../controllers/query/validation")
+} from "../controllers/query/validation"
+const { BUILDER, PermissionType, PermissionLevel } = permissions
 
-const router = new Router()
+const router: Router = new Router()
 
 router
   .get("/api/queries", authorized(BUILDER), queryController.fetch)
@@ -48,17 +45,17 @@ router
     authorized(PermissionType.QUERY, PermissionLevel.WRITE),
     queryController.executeV1
   )
-  .post(
-    "/api/v2/queries/:queryId",
-    paramResource("queryId"),
-    authorized(PermissionType.QUERY, PermissionLevel.WRITE),
-    queryController.executeV2
-  )
   .delete(
     "/api/queries/:queryId/:revId",
     paramResource("queryId"),
     authorized(BUILDER),
     queryController.destroy
   )
+  .post(
+    "/api/v2/queries/:queryId",
+    paramResource("queryId"),
+    authorized(PermissionType.QUERY, PermissionLevel.WRITE),
+    queryController.executeV2 as any
+  )
 
-module.exports = router
+export = router