@budibase/server 1.0.79 → 1.0.80-alpha.2

package/dist/api/routes/table.js

@@ -4,22 +4,8 @@ const tableController = require("../controllers/table");
 const authorized = require("../../middleware/authorized");
 const { paramResource, bodyResource } = require("../../middleware/resourceId");
 const { BUILDER, PermissionLevels, PermissionTypes, } = require("@budibase/backend-core/permissions");
-const joiValidator = require("../../middleware/joi-validator");
-const Joi = require("joi");
+const { tableValidator } = require("./utils/validators");
 const router = Router();
-function generateSaveValidator() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        _id: Joi.string(),
-        _rev: Joi.string(),
-        type: Joi.string().valid("table", "internal", "external"),
-        primaryDisplay: Joi.string(),
-        schema: Joi.object().required(),
-        name: Joi.string().required(),
-        views: Joi.object(),
-        dataImport: Joi.object(),
-    }).unknown(true));
-}
 router
     /**
      * @api {get} /api/tables Fetch all tables
@@ -46,7 +32,7 @@ router
      *
      * @apiSuccess {object[]} body The response body will be the table that was found.
      */
-    .get("/api/tables/:id", paramResource("id"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), tableController.find)
+    .get("/api/tables/:tableId", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), tableController.find)
     /**
      * @api {post} /api/tables Save a table
      * @apiName Save a table
@@ -122,7 +108,7 @@ router
      */
     .post("/api/tables", 
 // allows control over updating a table
-bodyResource("_id"), authorized(BUILDER), generateSaveValidator(), tableController.save)
+bodyResource("_id"), authorized(BUILDER), tableValidator(), tableController.save)
     /**
      * @api {post} /api/tables/csv/validate Validate a CSV for a table
      * @apiName Validate a CSV for a table

package/dist/api/routes/tests/utilities/index.js

@@ -11,6 +11,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const TestConfig = require("../../../../tests/utilities/TestConfiguration");
 const structures = require("../../../../tests/utilities/structures");
 const env = require("../../../../environment");
+function user() {
+    return {
+        _id: "user",
+        _rev: "rev",
+        createdAt: Date.now(),
+        email: "test@test.com",
+        roles: {},
+        tenantId: "default",
+        status: "active",
+    };
+}
 jest.mock("../../../../utilities/workerRequests", () => ({
     getGlobalUsers: jest.fn(() => {
         return {
@@ -22,6 +33,18 @@ jest.mock("../../../../utilities/workerRequests", () => ({
             _id: "us_uuid1",
         };
     }),
+    allGlobalUsers: jest.fn(() => {
+        return [user()];
+    }),
+    readGlobalUser: jest.fn(() => {
+        return user();
+    }),
+    saveGlobalUser: jest.fn(() => {
+        return { _id: "user", _rev: "rev" };
+    }),
+    deleteGlobalUser: jest.fn(() => {
+        return { message: "deleted user" };
+    }),
     removeAppFromUserRoles: jest.fn(),
 }));
 exports.delay = ms => new Promise(resolve => setTimeout(resolve, ms));

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

@@ -0,0 +1,200 @@
+"use strict";
+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/dist/api/routes/webhook.js

@@ -2,27 +2,12 @@
 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(), controller.save)
+    .put("/api/webhooks", authorized(BUILDER), webhookValidator(), controller.save)
     .delete("/api/webhooks/:id/:rev", authorized(BUILDER), controller.destroy)
     .post("/api/webhooks/schema/:instance/:id", authorized(BUILDER), controller.buildSchema)
     // this shouldn't have authorisation, right now its always public

package/dist/automations/steps/filter.js

@@ -23,10 +23,10 @@ const PrettyFilterConditions = {
 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/dist/automations/steps/queryRows.js

@@ -81,7 +81,7 @@ function getTable(appId, tableId) {
     return __awaiter(this, void 0, void 0, function* () {
         const ctx = buildCtx(appId, null, {
             params: {
-                id: tableId,
+                tableId,
             },
         });
         yield tableController.find(ctx);

package/dist/automations/utils.js

@@ -15,7 +15,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");
@@ -145,7 +145,7 @@ exports.checkForWebhooks = ({ oldAuto, newAuto }) => __awaiter(void 0, void 0, v
         const ctx = {
             appId,
             request: {
-                body: new webhooks.Webhook("Automation webhook", webhooks.WebhookType.AUTOMATION, newAuto._id),
+                body: new webhooks.Webhook("Automation webhook", WebhookType.AUTOMATION, newAuto._id),
             },
         };
         yield webhooks.save(ctx);

package/dist/constants/index.js

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

package/dist/db/utils.js

@@ -114,6 +114,17 @@ exports.getRowParams = (tableId = null, rowId = null, otherProps = {}) => {
     const endOfKey = rowId == null ? `${tableId}${SEPARATOR}` : rowId;
     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/dist/definitions/openapi.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/environment.js

@@ -37,6 +37,7 @@ module.exports = {
     INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,
     MULTI_TENANCY: process.env.MULTI_TENANCY,
     HTTP_MIGRATIONS: process.env.HTTP_MIGRATIONS,
+    API_REQ_LIMIT_PER_SEC: process.env.API_REQ_LIMIT_PER_SEC,
     // environment
     NODE_ENV: process.env.NODE_ENV,
     JEST_WORKER_ID: process.env.JEST_WORKER_ID,

package/dist/integrations/base/sql.js

@@ -232,6 +232,9 @@ class InternalBuilder {
     create(knex, json, opts) {
         const { endpoint, body } = json;
         let query = knex(endpoint.entityId);
+        if (endpoint.schema) {
+            query = query.withSchema(endpoint.schema);
+        }
         const parsedBody = parseBody(body);
         // make sure no null values in body for creation
         for (let [key, value] of Object.entries(parsedBody)) {
@@ -250,6 +253,9 @@ class InternalBuilder {
     bulkCreate(knex, json) {
         const { endpoint, body } = json;
         let query = knex(endpoint.entityId);
+        if (endpoint.schema) {
+            query = query.withSchema(endpoint.schema);
+        }
         if (!Array.isArray(body)) {
             return query;
         }
@@ -257,7 +263,7 @@ class InternalBuilder {
         return query.insert(parsedBody);
     }
     read(knex, json, limit) {
-        let { endpoint, resource, filters, sort, paginate, relationships } = json;
+        let { endpoint, resource, filters, paginate, relationships } = json;
         const tableName = endpoint.entityId;
         // select all if not specified
         if (!resource) {
@@ -285,6 +291,9 @@ class InternalBuilder {
         }
         // start building the query
         let query = knex(tableName).limit(foundLimit);
+        if (endpoint.schema) {
+            query = query.withSchema(endpoint.schema);
+        }
         if (foundOffset) {
             query = query.offset(foundOffset);
         }
@@ -307,6 +316,9 @@ class InternalBuilder {
     update(knex, json, opts) {
         const { endpoint, body, filters } = json;
         let query = knex(endpoint.entityId);
+        if (endpoint.schema) {
+            query = query.withSchema(endpoint.schema);
+        }
         const parsedBody = parseBody(body);
         query = this.addFilters(query, filters, { tableName: endpoint.entityId });
         // mysql can't use returning
@@ -320,6 +332,9 @@ class InternalBuilder {
     delete(knex, json, opts) {
         const { endpoint, filters } = json;
         let query = knex(endpoint.entityId);
+        if (endpoint.schema) {
+            query = query.withSchema(endpoint.schema);
+        }
         query = this.addFilters(query, filters, { tableName: endpoint.entityId });
         // mysql can't use returning
         if (opts.disableReturning) {

package/dist/integrations/base/sqlTable.js

@@ -87,17 +87,17 @@ function generateSchema(schema, table, tables, oldTable = null) {
     return schema;
 }
 function buildCreateTable(knex, table, tables) {
-    return knex.schema.createTable(table.name, schema => {
+    return knex.createTable(table.name, schema => {
         generateSchema(schema, table, tables);
     });
 }
 function buildUpdateTable(knex, table, tables, oldTable) {
-    return knex.schema.alterTable(table.name, schema => {
+    return knex.alterTable(table.name, schema => {
         generateSchema(schema, table, tables, oldTable);
     });
 }
 function buildDeleteTable(knex, table) {
-    return knex.schema.dropTable(table.name);
+    return knex.dropTable(table.name);
 }
 class SqlTableQueryBuilder {
     // pass through client to get flavour of SQL
@@ -115,7 +115,11 @@ class SqlTableQueryBuilder {
         return json.endpoint.operation;
     }
     _tableQuery(json) {
-        const client = knex_1.knex({ client: this.sqlClient });
+        var _a;
+        let client = knex_1.knex({ client: this.sqlClient }).schema;
+        if ((_a = json === null || json === void 0 ? void 0 : json.endpoint) === null || _a === void 0 ? void 0 : _a.schema) {
+            client = client.withSchema(json.endpoint.schema);
+        }
         let query;
         if (!json.table || !json.meta || !json.meta.tables) {
             throw "Cannot execute without table being specified";

package/dist/integrations/googlesheets.js

@@ -97,6 +97,9 @@ var GoogleSheetsModule;
             const spreadsheetId = this.cleanSpreadsheetUrl(this.config.spreadsheetId);
             this.client = new google_spreadsheet_1.GoogleSpreadsheet(spreadsheetId);
         }
+        getBindingIdentifier() {
+            return "";
+        }
         /**
          * Pull the spreadsheet ID out from a valid google sheets URL
          * @param spreadsheetId - the URL or standard spreadsheetId of the google sheet