@budibase/server 1.0.79 → 1.0.80-alpha.2

package/src/api/routes/utils/validators.js

@@ -0,0 +1,219 @@
+const joiValidator = require("../../../middleware/joi-validator")
+const { DataSourceOperation } = require("../../../constants")
+const { WebhookType } = require("../../../constants")
+const {
+  BUILTIN_PERMISSION_IDS,
+  PermissionLevels,
+} = require("@budibase/backend-core/permissions")
+const Joi = require("joi")
+
+const OPTIONAL_STRING = Joi.string().optional().allow(null).allow("")
+const OPTIONAL_NUMBER = Joi.number().optional().allow(null)
+
+exports.tableValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: OPTIONAL_STRING,
+    _rev: OPTIONAL_STRING,
+    type: OPTIONAL_STRING.valid("table", "internal", "external"),
+    primaryDisplay: OPTIONAL_STRING,
+    schema: Joi.object().required(),
+    name: Joi.string().required(),
+    views: Joi.object(),
+    dataImport: Joi.object(),
+  }).unknown(true))
+}
+
+exports.nameValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    name: OPTIONAL_STRING,
+  }))
+}
+
+exports.datasourceValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: Joi.string(),
+    _rev: Joi.string(),
+    type: OPTIONAL_STRING.allow("datasource_plus"),
+    relationships: Joi.array().items(Joi.object({
+      from: Joi.string().required(),
+      to: Joi.string().required(),
+      cardinality: Joi.valid("1:N", "1:1", "N:N").required()
+    })),
+  }).unknown(true))
+}
+
+function filterObject() {
+  // prettier-ignore
+  return Joi.object({
+    string: Joi.object().optional(),
+    fuzzy: Joi.object().optional(),
+    range: Joi.object().optional(),
+    equal: Joi.object().optional(),
+    notEqual: Joi.object().optional(),
+    empty: Joi.object().optional(),
+    notEmpty: Joi.object().optional(),
+    oneOf: Joi.object().optional(),
+    contains: Joi.object().optional(),
+    notContains: Joi.object().optional(),
+  }).unknown(true)
+}
+
+exports.internalSearchValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    tableId: OPTIONAL_STRING,
+    query: filterObject(),
+    limit: OPTIONAL_NUMBER,
+    sort: OPTIONAL_STRING,
+    sortOrder: OPTIONAL_STRING,
+    sortType: OPTIONAL_STRING,
+    paginate: Joi.boolean(),
+    bookmark: Joi.alternatives().try(OPTIONAL_STRING, OPTIONAL_NUMBER).optional(),
+  }))
+}
+
+exports.externalSearchValidator = () => {
+  return joiValidator.body(
+    Joi.object({
+      query: filterObject(),
+      paginate: Joi.boolean().optional(),
+      bookmark: Joi.alternatives()
+        .try(OPTIONAL_STRING, OPTIONAL_NUMBER)
+        .optional(),
+      limit: OPTIONAL_NUMBER,
+      sort: Joi.object({
+        column: Joi.string(),
+        order: OPTIONAL_STRING.valid("ascending", "descending"),
+        type: OPTIONAL_STRING.valid("string", "number"),
+      }).optional(),
+    })
+  )
+}
+
+exports.datasourceQueryValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    endpoint: Joi.object({
+      datasourceId: Joi.string().required(),
+      operation: Joi.string().required().valid(...Object.values(DataSourceOperation)),
+      entityId: Joi.string().required(),
+    }).required(),
+    resource: Joi.object({
+      fields: Joi.array().items(Joi.string()).optional(),
+    }).optional(),
+    body: Joi.object().optional(),
+    sort: Joi.object().optional(),
+    filters: filterObject().optional(),
+    paginate: Joi.object({
+      page: Joi.string().alphanum().optional(),
+      limit: Joi.number().optional(),
+    }).optional(),
+  }))
+}
+
+exports.webhookValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    live: Joi.bool(),
+    _id: OPTIONAL_STRING,
+    _rev: OPTIONAL_STRING,
+    name: Joi.string().required(),
+    bodySchema: Joi.object().optional(),
+    action: Joi.object({
+      type: Joi.string().required().valid(WebhookType.AUTOMATION),
+      target: Joi.string().required(),
+    }).required(),
+  }).unknown(true))
+}
+
+exports.roleValidator = () => {
+  const permLevelArray = Object.values(PermissionLevels)
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: OPTIONAL_STRING,
+    _rev: OPTIONAL_STRING,
+    name: Joi.string().required(),
+    // this is the base permission ID (for now a built in)
+    permissionId: Joi.string().valid(...Object.values(BUILTIN_PERMISSION_IDS)).required(),
+    permissions: Joi.object()
+      .pattern(/.*/, [Joi.string().valid(...permLevelArray)])
+      .optional(),
+    inherits: OPTIONAL_STRING,
+  }).unknown(true))
+}
+
+exports.permissionValidator = () => {
+  const permLevelArray = Object.values(PermissionLevels)
+  // prettier-ignore
+  return joiValidator.params(Joi.object({
+    level: Joi.string().valid(...permLevelArray).required(),
+    resourceId: Joi.string(),
+    roleId: Joi.string(),
+  }).unknown(true))
+}
+
+exports.screenValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    name: Joi.string().required(),
+    routing: Joi.object({
+      route: Joi.string().required(),
+      roleId: Joi.string().required().allow(""),
+    }).required().unknown(true),
+    props: Joi.object({
+      _id: Joi.string().required(),
+      _component: Joi.string().required(),
+      _children: Joi.array().required(),
+      _instanceName: Joi.string().required(),
+      _styles: Joi.object().required(),
+      type: OPTIONAL_STRING,
+      table: OPTIONAL_STRING,
+      layoutId: OPTIONAL_STRING,
+    }).required().unknown(true),
+  }).unknown(true))
+}
+
+function generateStepSchema(allowStepTypes) {
+  // prettier-ignore
+  return Joi.object({
+    stepId: Joi.string().required(),
+    id: Joi.string().required(),
+    description: Joi.string().required(),
+    name: Joi.string().required(),
+    tagline: Joi.string().required(),
+    icon: Joi.string().required(),
+    params: Joi.object(),
+    args: Joi.object(),
+    type: Joi.string().required().valid(...allowStepTypes),
+  }).unknown(true)
+}
+
+exports.automationValidator = (existing = false) => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: existing ? Joi.string().required() : OPTIONAL_STRING,
+    _rev: existing ? Joi.string().required() : OPTIONAL_STRING,
+    name: Joi.string().required(),
+    type: Joi.string().valid("automation").required(),
+    definition: Joi.object({
+      steps: Joi.array().required().items(generateStepSchema(["ACTION", "LOGIC"])),
+      trigger: generateStepSchema(["TRIGGER"]).allow(null),
+    }).required().unknown(true),
+  }).unknown(true))
+}
+
+exports.applicationValidator = () => {
+  // prettier-ignore
+  return joiValidator.body(Joi.object({
+    _id: OPTIONAL_STRING,
+    _rev: OPTIONAL_STRING,
+    name: Joi.string().required(),
+    url: OPTIONAL_STRING,
+    template: Joi.object({
+      templateString: OPTIONAL_STRING,
+    }).unknown(true),
+  }).unknown(true))
+}

package/src/api/routes/webhook.js

@@ -1,33 +1,17 @@
 const Router = require("@koa/router")
 const controller = require("../controllers/webhook")
 const authorized = require("../../middleware/authorized")
-const joiValidator = require("../../middleware/joi-validator")
 const { BUILDER } = require("@budibase/backend-core/permissions")
-const Joi = require("joi")
+const { webhookValidator } = require("./utils/validators")
 
 const router = Router()
 
-function generateSaveValidator() {
-  // prettier-ignore
-  return joiValidator.body(Joi.object({
-    live: Joi.bool(),
-    _id: Joi.string().optional(),
-    _rev: Joi.string().optional(),
-    name: Joi.string().required(),
-    bodySchema: Joi.object().optional(),
-    action: Joi.object({
-      type: Joi.string().required().valid(controller.WebhookType.AUTOMATION),
-      target: Joi.string().required(),
-    }).required(),
-  }).unknown(true))
-}
-
 router
   .get("/api/webhooks", authorized(BUILDER), controller.fetch)
   .put(
     "/api/webhooks",
     authorized(BUILDER),
-    generateSaveValidator(),
+    webhookValidator(),
     controller.save
   )
   .delete("/api/webhooks/:id/:rev", authorized(BUILDER), controller.destroy)

package/src/automations/steps/filter.js

@@ -16,10 +16,11 @@ exports.FilterConditions = FilterConditions
 exports.PrettyFilterConditions = PrettyFilterConditions
 
 exports.definition = {
-  name: "Filter",
+  name: "Condition",
   tagline: "{{inputs.field}} {{inputs.condition}} {{inputs.value}}",
   icon: "Branch2",
-  description: "Filter any automations which do not meet certain conditions",
+  description:
+    "Conditionally halt automations which do not meet certain conditions",
   type: "LOGIC",
   internal: true,
   stepId: "FILTER",

package/src/automations/steps/queryRows.js

@@ -74,7 +74,7 @@ exports.definition = {
 async function getTable(appId, tableId) {
   const ctx = buildCtx(appId, null, {
     params: {
-      id: tableId,
+      tableId,
     },
   })
   await tableController.find(ctx)

package/src/automations/utils.js

@@ -5,7 +5,7 @@ const CouchDB = require("../db")
 const { queue } = require("./bullboard")
 const newid = require("../db/newid")
 const { updateEntityMetadata } = require("../utilities")
-const { MetadataTypes } = require("../constants")
+const { MetadataTypes, WebhookType } = require("../constants")
 const { getProdAppID } = require("@budibase/backend-core/db")
 const { cloneDeep } = require("lodash/fp")
 const { getAppDB, getAppId } = require("@budibase/backend-core/context")
@@ -159,7 +159,7 @@ exports.checkForWebhooks = async ({ oldAuto, newAuto }) => {
       request: {
         body: new webhooks.Webhook(
           "Automation webhook",
-          webhooks.WebhookType.AUTOMATION,
+          WebhookType.AUTOMATION,
           newAuto._id
         ),
       },

package/src/constants/index.js

@@ -186,5 +186,9 @@ exports.BuildSchemaErrors = {
   INVALID_COLUMN: "invalid_column",
 }
 
+exports.WebhookType = {
+  AUTOMATION: "automation",
+}
+
 // pass through the list from the auth/core lib
 exports.ObjectStoreBuckets = ObjectStoreBuckets

package/src/db/utils.js

@@ -146,6 +146,18 @@ exports.getRowParams = (tableId = null, rowId = null, otherProps = {}) => {
   return getDocParams(DocumentTypes.ROW, endOfKey, otherProps)
 }
 
+/**
+ * Given a row ID this will find the table ID within it (only works for internal tables).
+ * @param {string} rowId The ID of the row.
+ * @returns {string} The table ID.
+ */
+exports.getTableIDFromRowID = rowId => {
+  const components = rowId
+    .split(DocumentTypes.TABLE + SEPARATOR)[1]
+    .split(SEPARATOR)
+  return `${DocumentTypes.TABLE}${SEPARATOR}${components[0]}`
+}
+
 /**
  * Gets a new row ID for the specified table.
  * @param {string} tableId The table which the row is being created for.

package/src/definitions/common.ts

@@ -5,6 +5,10 @@ export interface Base {
   _rev?: string
 }
 
+export interface Application extends Base {
+  appId?: string
+}
+
 export interface FieldSchema {
   // TODO: replace with field types enum when done
   type: string

package/src/definitions/datasource.ts

@@ -153,6 +153,7 @@ export interface QueryJson {
     datasourceId: string
     entityId: string
     operation: Operation
+    schema?: string
   }
   resource: {
     fields: string[]