@budibase/server 0.0.32 → 0.0.999-alpha.31

package/src/api/controllers/view/viewBuilder.ts

@@ -0,0 +1,203 @@
+import { ViewFilter } from "@budibase/types"
+
+type ViewTemplateOpts = {
+  field: string
+  tableId: string
+  groupBy: string
+  filters: ViewFilter[]
+  calculation: string
+  groupByMulti: boolean
+}
+
+const TOKEN_MAP: Record<string, string> = {
+  EQUALS: "===",
+  NOT_EQUALS: "!==",
+  LT: "<",
+  LTE: "<=",
+  MT: ">",
+  MTE: ">=",
+  CONTAINS: "includes",
+  AND: "&&",
+  OR: "||",
+}
+
+const CONDITIONS: Record<string, string> = {
+  EMPTY: "EMPTY",
+  NOT_EMPTY: "NOT_EMPTY",
+  CONTAINS: "CONTAINS",
+}
+
+function isEmptyExpression(key: string) {
+  return `(
+      doc["${key}"] === undefined ||
+      doc["${key}"] === null ||
+      doc["${key}"] === "" ||
+      (Array.isArray(doc["${key}"]) && doc["${key}"].length === 0)
+  )`
+}
+
+const GROUP_PROPERTY: Record<string, { type: string }> = {
+  group: {
+    type: "string",
+  },
+}
+
+const GROUP_PROPERTY_MULTI: Record<string, { type: string }> = {
+  group: {
+    type: "array",
+  },
+}
+
+const FIELD_PROPERTY: Record<string, { type: string }> = {
+  field: {
+    type: "string",
+  },
+}
+
+const SCHEMA_MAP: Record<string, any> = {
+  sum: {
+    field: "string",
+    value: "number",
+  },
+  count: {
+    field: "string",
+    value: "number",
+  },
+  stats: {
+    sum: {
+      type: "number",
+    },
+    min: {
+      type: "number",
+    },
+    max: {
+      type: "number",
+    },
+    count: {
+      type: "number",
+    },
+    sumsqr: {
+      type: "number",
+    },
+    avg: {
+      type: "number",
+    },
+  },
+}
+
+/**
+ * Iterates through the array of filters to create a JS
+ * expression that gets used in a CouchDB view.
+ * @param {Array} filters - an array of filter objects
+ * @returns {String} JS Expression
+ */
+function parseFilterExpression(filters: ViewFilter[]) {
+  const expression = []
+
+  let first = true
+  for (let filter of filters) {
+    if (!first && filter.conjunction) {
+      expression.push(TOKEN_MAP[filter.conjunction])
+    }
+
+    if (filter.condition === CONDITIONS.CONTAINS) {
+      expression.push(
+        `doc["${filter.key}"].${TOKEN_MAP[filter.condition]}("${filter.value}")`
+      )
+    } else if (filter.condition === CONDITIONS.EMPTY) {
+      expression.push(isEmptyExpression(filter.key))
+    } else if (filter.condition === CONDITIONS.NOT_EMPTY) {
+      expression.push(`!${isEmptyExpression(filter.key)}`)
+    } else {
+      const value =
+        typeof filter.value == "string" ? `"${filter.value}"` : filter.value
+
+      expression.push(
+        `doc["${filter.key}"] ${TOKEN_MAP[filter.condition]} ${value}`
+      )
+    }
+    first = false
+  }
+
+  return expression.join(" ")
+}
+
+/**
+ * Returns a CouchDB compliant emit() expression that is used to emit the
+ * correct key/value pairs for custom views.
+ * @param {String?} field - field to use for calculations, if any
+ * @param {String?} groupBy - field to group calculation results on, if any
+ */
+function parseEmitExpression(field: string, groupBy: string) {
+  return `emit(doc["${groupBy || "_id"}"], doc["${field}"]);`
+}
+
+/**
+ * Return a fully parsed CouchDB compliant view definition
+ * that will be stored in the design document in the database.
+ *
+ * @param {Object} viewDefinition - the JSON definition for a custom view.
+ * field: field that calculations will be performed on
+ * tableId: tableId of the table this view was created from
+ * groupBy: field that calculations will be grouped by. Field must be present for this to be useful
+ * filters: Array of filter objects containing predicates that are parsed into a JS expression
+ * calculation: an optional calculation to be performed over the view data.
+ */
+export default function (
+  { field, tableId, groupBy, filters = [], calculation }: ViewTemplateOpts,
+  groupByMulti?: boolean
+) {
+  // first filter can't have a conjunction
+  if (filters && filters.length > 0 && filters[0].conjunction) {
+    delete filters[0].conjunction
+  }
+
+  let schema = null,
+    statFilter = null
+
+  let groupBySchema = groupByMulti ? GROUP_PROPERTY_MULTI : GROUP_PROPERTY
+
+  if (calculation) {
+    schema = {
+      ...(groupBy ? groupBySchema : FIELD_PROPERTY),
+      ...SCHEMA_MAP[calculation],
+    }
+    if (
+      !filters.find(
+        filter =>
+          filter.key === field && filter.condition === CONDITIONS.NOT_EMPTY
+      )
+    ) {
+      statFilter = parseFilterExpression([
+        { key: field, condition: CONDITIONS.NOT_EMPTY },
+      ])
+    }
+  }
+
+  const parsedFilters = parseFilterExpression(filters)
+  const filterExpression = parsedFilters ? `&& (${parsedFilters})` : ""
+
+  const emitExpression = parseEmitExpression(field, groupBy)
+  const tableExpression = `doc.tableId === "${tableId}"`
+  const coreExpression = statFilter
+    ? `(${tableExpression} && ${statFilter})`
+    : tableExpression
+  const reduction = field && calculation ? { reduce: `_${calculation}` } : {}
+
+  return {
+    meta: {
+      field,
+      tableId,
+      groupBy,
+      filters,
+      schema,
+      calculation,
+    },
+    map: `function (doc) {
+      if (${coreExpression} ${filterExpression}) {
+        ${emitExpression}
+      }
+    }`,
+    ...reduction,
+  }
+}

package/src/api/controllers/webhook.ts

@@ -0,0 +1,100 @@
+import { getWebhookParams } from "../../db/utils"
+import * as triggers from "../../automations/triggers"
+import { db as dbCore, context } from "@budibase/backend-core"
+import {
+  Webhook,
+  WebhookActionType,
+  BBContext,
+  Automation,
+} from "@budibase/types"
+import sdk from "../../sdk"
+const toJsonSchema = require("to-json-schema")
+const validate = require("jsonschema").validate
+
+const AUTOMATION_DESCRIPTION = "Generated from Webhook Schema"
+
+export async function fetch(ctx: BBContext) {
+  const db = context.getAppDB()
+  const response = await db.allDocs(
+    getWebhookParams(null, {
+      include_docs: true,
+    })
+  )
+  ctx.body = response.rows.map((row: any) => row.doc)
+}
+
+export async function save(ctx: BBContext) {
+  const webhook = await sdk.automations.webhook.save(ctx.request.body)
+  ctx.body = {
+    message: "Webhook created successfully",
+    webhook,
+  }
+}
+
+export async function destroy(ctx: BBContext) {
+  ctx.body = await sdk.automations.webhook.destroy(
+    ctx.params.id,
+    ctx.params.rev
+  )
+}
+
+export async function buildSchema(ctx: BBContext) {
+  await context.doInAppContext(ctx.params.instance, async () => {
+    const db = context.getAppDB()
+    const webhook = (await db.get(ctx.params.id)) as Webhook
+    webhook.bodySchema = toJsonSchema(ctx.request.body)
+    // update the automation outputs
+    if (webhook.action.type === WebhookActionType.AUTOMATION) {
+      let automation = (await db.get(webhook.action.target)) as Automation
+      const autoOutputs = automation.definition.trigger.schema.outputs
+      let properties = webhook.bodySchema.properties
+      // reset webhook outputs
+      autoOutputs.properties = {
+        body: autoOutputs.properties.body,
+      }
+      for (let prop of Object.keys(properties)) {
+        autoOutputs.properties[prop] = {
+          type: properties[prop].type,
+          description: AUTOMATION_DESCRIPTION,
+        }
+      }
+      await db.put(automation)
+    }
+    ctx.body = await db.put(webhook)
+  })
+}
+
+export async function trigger(ctx: BBContext) {
+  const prodAppId = dbCore.getProdAppID(ctx.params.instance)
+  await context.doInAppContext(prodAppId, async () => {
+    try {
+      const db = context.getAppDB()
+      const webhook = (await db.get(ctx.params.id)) as Webhook
+      // validate against the schema
+      if (webhook.bodySchema) {
+        validate(ctx.request.body, webhook.bodySchema)
+      }
+      const target = await db.get(webhook.action.target)
+      if (webhook.action.type === WebhookActionType.AUTOMATION) {
+        // trigger with both the pure request and then expand it
+        // incase the user has produced a schema to bind to
+        await triggers.externalTrigger(target, {
+          body: ctx.request.body,
+          ...ctx.request.body,
+          appId: prodAppId,
+        })
+      }
+      ctx.status = 200
+      ctx.body = {
+        message: "Webhook trigger fired successfully",
+      }
+    } catch (err: any) {
+      if (err.status === 404) {
+        ctx.status = 200
+        ctx.body = {
+          message: "Application not deployed yet.",
+        }
+      }
+    }
+  })
+}

package/src/api/index.ts

@@ -0,0 +1,63 @@
+import Router from "@koa/router"
+import { auth, middleware } 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")
+
+export const router: Router = new Router()
+
+router.get("/health", ctx => (ctx.status = 200))
+router.get("/version", ctx => (ctx.body = pkg.version))
+
+router.use(middleware.errorHandling)
+
+router
+  .use(
+    compress({
+      threshold: 2048,
+      gzip: {
+        flush: zlib.constants.Z_SYNC_FLUSH,
+      },
+      deflate: {
+        flush: zlib.constants.Z_SYNC_FLUSH,
+      },
+      br: false,
+    })
+  )
+  // re-direct before any middlewares occur
+  .redirect("/", "/builder")
+  .use(
+    auth.buildAuthMiddleware([], {
+      publicAllowed: true,
+    })
+  )
+  // nothing in the server should allow query string tenants
+  // 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([], [], {
+      noTenancyRequired: true,
+    })
+  )
+  .use(pro.licensing())
+  // @ts-ignore
+  .use(currentApp)
+  .use(auth.auditLog)
+
+// authenticated routes
+for (let route of mainRoutes) {
+  router.use(route.routes())
+  router.use(route.allowedMethods())
+}
+
+router.use(publicRoutes.routes())
+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())

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 default 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 default router

package/src/api/routes/application.ts

@@ -0,0 +1,57 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/application"
+import * as deploymentController from "../controllers/deploy"
+import authorized from "../../middleware/authorized"
+import { permissions } from "@budibase/backend-core"
+import { applicationValidator } from "./utils/validators"
+
+const router: Router = new Router()
+
+router
+  .post(
+    "/api/applications/:appId/sync",
+    authorized(permissions.BUILDER),
+    controller.sync
+  )
+  .post(
+    "/api/applications",
+    authorized(permissions.BUILDER),
+    applicationValidator(),
+    controller.create
+  )
+  .get("/api/applications/:appId/definition", controller.fetchAppDefinition)
+  .get("/api/applications", controller.fetch)
+  .get("/api/applications/:appId/appPackage", controller.fetchAppPackage)
+  .put(
+    "/api/applications/:appId",
+    authorized(permissions.BUILDER),
+    applicationValidator({ isCreate: false }),
+    controller.update
+  )
+  .post(
+    "/api/applications/:appId/client/update",
+    authorized(permissions.BUILDER),
+    controller.updateClient
+  )
+  .post(
+    "/api/applications/:appId/client/revert",
+    authorized(permissions.BUILDER),
+    controller.revertClient
+  )
+  .post(
+    "/api/applications/:appId/publish",
+    authorized(permissions.BUILDER),
+    deploymentController.publishApp
+  )
+  .post(
+    "/api/applications/:appId/unpublish",
+    authorized(permissions.BUILDER),
+    controller.unpublish
+  )
+  .delete(
+    "/api/applications/:appId",
+    authorized(permissions.BUILDER),
+    controller.destroy
+  )
+
+export default router

package/src/api/routes/auth.ts

@@ -0,0 +1,8 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/auth"
+
+const router: Router = new Router()
+
+router.get("/api/self", controller.fetchSelf)
+
+export default 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(false),
+    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 default router

package/src/api/routes/backup.ts

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

package/src/api/routes/deploy.ts

@@ -0,0 +1,20 @@
+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
+  )
+
+export default router