@budibase/server 2.5.9 → 2.5.10-alpha.1

package/dist/events/docUpdates/syncUsers.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const backend_core_1 = require("@budibase/backend-core");
+const pro_1 = require("@budibase/pro");
+const types_1 = require("@budibase/types");
+const sync_1 = require("../../sdk/app/applications/sync");
+function process(updateCb) {
+    const processor = (update) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const docId = update.id;
+            const isGroup = docId.startsWith(backend_core_1.constants.DocumentType.GROUP);
+            let userIds;
+            if (isGroup) {
+                const group = yield pro_1.sdk.groups.get(docId);
+                userIds = ((_a = group.users) === null || _a === void 0 ? void 0 : _a.map(user => user._id)) || [];
+            }
+            else {
+                userIds = [docId];
+            }
+            if (userIds.length > 0) {
+                yield (0, sync_1.syncUsersToAllApps)(userIds);
+            }
+            if (updateCb) {
+                updateCb(docId);
+            }
+        }
+        catch (err) {
+            // if something not found - no changes to perform
+            if ((err === null || err === void 0 ? void 0 : err.status) === 404) {
+                return;
+            }
+            else {
+                backend_core_1.logging.logAlert("Failed to perform user/group app sync", err);
+            }
+        }
+    });
+    return { events: types_1.UserGroupSyncEvents, processor };
+}
+exports.default = process;

package/dist/events/index.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
 const BudibaseEmitter_1 = __importDefault(require("./BudibaseEmitter"));
 const emitter = new BudibaseEmitter_1.default();
+var docUpdates_1 = require("./docUpdates");
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return docUpdates_1.init; } });
 exports.default = emitter;

package/dist/integrations/base/sqlTable.js

@@ -69,10 +69,17 @@ function generateSchema(schema, table, tables, oldTable = null, renamed) {
                     if (!relatedTable) {
                         throw "Referenced table doesn't exist";
                     }
-                    schema.integer(column.foreignKey).unsigned();
+                    const relatedPrimary = relatedTable.primary[0];
+                    const externalType = relatedTable.schema[relatedPrimary].externalType;
+                    if (externalType) {
+                        schema.specificType(column.foreignKey, externalType);
+                    }
+                    else {
+                        schema.integer(column.foreignKey).unsigned();
+                    }
                     schema
                         .foreign(column.foreignKey)
-                        .references(`${tableName}.${relatedTable.primary[0]}`);
+                        .references(`${tableName}.${relatedPrimary}`);
                 }
                 break;
         }

package/dist/integrations/index.js

@@ -29,11 +29,11 @@ const firebase_1 = __importDefault(require("./firebase"));
 const redis_1 = __importDefault(require("./redis"));
 const snowflake_1 = __importDefault(require("./snowflake"));
 const oracle_1 = __importDefault(require("./oracle"));
-const plugin_1 = require("../api/controllers/plugin");
 const types_1 = require("@budibase/types");
 const fileSystem_1 = require("../utilities/fileSystem");
 const environment_1 = __importDefault(require("../environment"));
 const lodash_1 = require("lodash");
+const sdk_1 = __importDefault(require("../sdk"));
 const DEFINITIONS = {
     [types_1.SourceName.POSTGRES]: postgres_1.default.schema,
     [types_1.SourceName.DYNAMODB]: dynamodb_1.default.schema,
@@ -91,7 +91,7 @@ function getDefinitions() {
     return __awaiter(this, void 0, void 0, function* () {
         const pluginSchemas = {};
         if (environment_1.default.SELF_HOSTED) {
-            const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
+            const plugins = yield sdk_1.default.plugins.fetch(types_1.PluginType.DATASOURCE);
             // extract the actual schema from each custom
             for (let plugin of plugins) {
                 const sourceId = plugin.name;
@@ -111,7 +111,7 @@ function getIntegration(integration) {
             return INTEGRATIONS[integration];
         }
         if (environment_1.default.SELF_HOSTED) {
-            const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
+            const plugins = yield sdk_1.default.plugins.fetch(types_1.PluginType.DATASOURCE);
             for (let plugin of plugins) {
                 if (plugin.name === integration) {
                     // need to use commonJS require due to its dynamic runtime nature

package/dist/integrations/microsoftSqlServer.js

@@ -206,8 +206,11 @@ class SqlServerIntegration extends sql_1.default {
                     if (typeof name !== "string") {
                         continue;
                     }
-                    schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find(col => col === name), name: name, constraints: {
-                            presence: requiredColumns.find(col => col === name),
+                    const hasDefault = def.COLUMN_DEFAULT;
+                    const isAuto = !!autoColumns.find(col => col === name);
+                    const required = !!requiredColumns.find(col => col === name);
+                    schema[name] = Object.assign(Object.assign({ autocolumn: isAuto, name: name, constraints: {
+                            presence: required && !isAuto && !hasDefault,
                         } }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
                 }
                 tables[tableName] = {

package/dist/integrations/mysql.js

@@ -186,12 +186,14 @@ class MySQLIntegration extends sql_1.default {
                         if (column.Key === "PRI" && primaryKeys.indexOf(column.Key) === -1) {
                             primaryKeys.push(columnName);
                         }
-                        const constraints = {
-                            presence: column.Null !== "YES",
-                        };
+                        const hasDefault = column.Default != null;
                         const isAuto = typeof column.Extra === "string" &&
                             (column.Extra === "auto_increment" ||
                                 column.Extra.toLowerCase().includes("generated"));
+                        const required = column.Null !== "YES";
+                        const constraints = {
+                            presence: required && !isAuto && !hasDefault,
+                        };
                         schema[columnName] = Object.assign(Object.assign({ name: columnName, autocolumn: isAuto, constraints }, (0, utils_1.convertSqlType)(column.Type)), { externalType: column.Type });
                     }
                     if (!tables[tableName]) {

package/dist/integrations/postgres.js

@@ -227,13 +227,15 @@ class PostgresIntegration extends sql_1.default {
                     const identity = !!(column.identity_generation ||
                         column.identity_start ||
                         column.identity_increment);
-                    const constraints = {
-                        presence: column.is_nullable === "NO",
-                    };
-                    const hasDefault = typeof column.column_default === "string" &&
+                    const hasDefault = column.column_default != null;
+                    const hasNextVal = typeof column.column_default === "string" &&
                         column.column_default.startsWith("nextval");
                     const isGenerated = column.is_generated && column.is_generated !== "NEVER";
-                    const isAuto = hasDefault || identity || isGenerated;
+                    const isAuto = hasNextVal || identity || isGenerated;
+                    const required = column.is_nullable === "NO";
+                    const constraints = {
+                        presence: required && !hasDefault && !isGenerated,
+                    };
                     tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName, constraints }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
                 }
                 const final = (0, utils_1.finaliseExternalTables)(tables, entities);

package/dist/integrations/redis.js

@@ -38,6 +38,12 @@ const SCHEMA = {
             type: "password",
             required: false,
         },
+        db: {
+            type: "number",
+            required: false,
+            display: "DB",
+            default: 0,
+        },
     },
     query: {
         create: {
@@ -90,6 +96,7 @@ class RedisIntegration {
             port: this.config.port,
             username: this.config.username,
             password: this.config.password,
+            db: this.config.db,
         });
     }
     disconnect() {

package/dist/integrations/rest.js

@@ -166,6 +166,10 @@ class RestIntegration {
                     }
                     raw = rawXml;
                 }
+                else if (contentType.includes("application/pdf")) {
+                    data = yield response.arrayBuffer(); // Save PDF as ArrayBuffer
+                    raw = Buffer.from(data);
+                }
                 else {
                     data = yield response.text();
                     raw = data;

package/dist/migrations/functions/syncQuotas.js

@@ -37,6 +37,7 @@ const usageQuotas_1 = require("./usageQuotas");
 const syncApps = __importStar(require("./usageQuotas/syncApps"));
 const syncRows = __importStar(require("./usageQuotas/syncRows"));
 const syncPlugins = __importStar(require("./usageQuotas/syncPlugins"));
+const syncUsers = __importStar(require("./usageQuotas/syncUsers"));
 /**
  * Synchronise quotas to the state of the db.
  */
@@ -45,6 +46,7 @@ const run = () => __awaiter(void 0, void 0, void 0, function* () {
         yield syncApps.run();
         yield syncRows.run();
         yield syncPlugins.run();
+        yield syncUsers.run();
     }));
 });
 exports.run = run;

package/dist/migrations/functions/usageQuotas/syncApps.js

@@ -18,8 +18,7 @@ const run = () => __awaiter(void 0, void 0, void 0, function* () {
     const devApps = yield backend_core_1.db.getAllApps({ dev: true });
     const appCount = devApps ? devApps.length : 0;
     // sync app count
-    const tenantId = backend_core_1.tenancy.getTenantId();
-    console.log(`[Tenant: ${tenantId}] Syncing app count: ${appCount}`);
+    console.log(`Syncing app count: ${appCount}`);
     yield pro_1.quotas.setUsage(appCount, types_1.StaticQuotaName.APPS, types_1.QuotaUsageType.STATIC);
 });
 exports.run = run;

package/dist/migrations/functions/usageQuotas/syncRows.js

@@ -27,8 +27,7 @@ const run = () => __awaiter(void 0, void 0, void 0, function* () {
         rowCount += rows.length;
     });
     // sync row count
-    const tenantId = backend_core_1.tenancy.getTenantId();
-    console.log(`[Tenant: ${tenantId}] Syncing row count: ${rowCount}`);
+    console.log(`Syncing row count: ${rowCount}`);
     yield pro_1.quotas.setUsagePerApp(counts, types_1.StaticQuotaName.ROWS, types_1.QuotaUsageType.STATIC);
 });
 exports.run = run;

package/dist/migrations/functions/usageQuotas/syncUsers.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const pro_1 = require("@budibase/pro");
+const types_1 = require("@budibase/types");
+const run = () => __awaiter(void 0, void 0, void 0, function* () {
+    const userCount = yield backend_core_1.users.getUserCount();
+    console.log(`Syncing user count: ${userCount}`);
+    yield pro_1.quotas.setUsage(userCount, types_1.StaticQuotaName.USERS, types_1.QuotaUsageType.STATIC);
+});
+exports.run = run;

package/dist/sdk/app/applications/sync.js

@@ -12,10 +12,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncApp = void 0;
+exports.syncApp = exports.syncUsersToAllApps = void 0;
 const environment_1 = __importDefault(require("../../../environment"));
 const backend_core_1 = require("@budibase/backend-core");
+const pro_1 = require("@budibase/pro");
 const __1 = __importDefault(require("../../"));
+const global_1 = require("../../../utilities/global");
+const utils_1 = require("../../../db/utils");
+function syncUsersToApp(appId, users, groups) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield backend_core_1.db.dbExists(appId))) {
+            return;
+        }
+        yield backend_core_1.context.doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+            const db = backend_core_1.context.getAppDB();
+            for (let user of users) {
+                let ctxUser = user;
+                let deletedUser = false;
+                const metadataId = (0, utils_1.generateUserMetadataID)(user._id);
+                if (user.deleted) {
+                    deletedUser = true;
+                }
+                // make sure role is correct
+                if (!deletedUser) {
+                    ctxUser = yield (0, global_1.processUser)(ctxUser, { appId, groups });
+                }
+                let roleId = ctxUser.roleId;
+                if (roleId === backend_core_1.roles.BUILTIN_ROLE_IDS.PUBLIC) {
+                    roleId = undefined;
+                }
+                let metadata;
+                try {
+                    metadata = yield db.get(metadataId);
+                }
+                catch (err) {
+                    if (err.status !== 404) {
+                        throw err;
+                    }
+                    // no metadata and user is to be deleted, can skip
+                    // no role - user isn't in app anyway
+                    if (!roleId) {
+                        continue;
+                    }
+                    else if (!deletedUser) {
+                        // doesn't exist yet, creating it
+                        metadata = {
+                            tableId: utils_1.InternalTables.USER_METADATA,
+                        };
+                    }
+                }
+                // the user doesn't exist, or doesn't have a role anymore
+                // get rid of their metadata
+                if (deletedUser || !roleId) {
+                    yield db.remove(metadata);
+                    continue;
+                }
+                // assign the roleId for the metadata doc
+                if (roleId) {
+                    metadata.roleId = roleId;
+                }
+                let combined = __1.default.users.combineMetadataAndUser(ctxUser, metadata);
+                // if no combined returned, there are no updates to make
+                if (combined) {
+                    yield db.put(combined);
+                }
+            }
+        }));
+    });
+}
+function syncUsersToAllApps(userIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // list of users, if one has been deleted it will be undefined in array
+        const users = (yield (0, global_1.getGlobalUsers)(userIds, {
+            noProcessing: true,
+        }));
+        const groups = yield pro_1.sdk.groups.fetch();
+        const finalUsers = [];
+        for (let userId of userIds) {
+            const user = users.find(user => user._id === userId);
+            if (!user) {
+                finalUsers.push({ _id: userId, deleted: true });
+            }
+            else {
+                finalUsers.push(user);
+            }
+        }
+        const devAppIds = yield backend_core_1.db.getDevAppIDs();
+        let promises = [];
+        for (let devAppId of devAppIds) {
+            const prodAppId = backend_core_1.db.getProdAppID(devAppId);
+            for (let appId of [prodAppId, devAppId]) {
+                promises.push(syncUsersToApp(appId, finalUsers, groups));
+            }
+        }
+        const resp = yield Promise.allSettled(promises);
+        const failed = resp.filter(promise => promise.status === "rejected");
+        if (failed.length > 0) {
+            const reasons = failed.map(fail => fail.reason);
+            backend_core_1.logging.logAlert("Failed to sync users to apps", reasons);
+        }
+    });
+}
+exports.syncUsersToAllApps = syncUsersToAllApps;
 function syncApp(appId, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         if (environment_1.default.DISABLE_AUTO_PROD_APP_SYNC) {
@@ -31,31 +129,27 @@ function syncApp(appId, opts) {
         // specific case, want to make sure setup is skipped
         const prodDb = backend_core_1.context.getProdAppDB({ skip_setup: true });
         const exists = yield prodDb.exists();
-        if (!exists) {
-            // the database doesn't exist. Don't replicate
-            return {
-                message: "App sync not required, app not deployed.",
-            };
-        }
-        const replication = new backend_core_1.db.Replication({
-            source: prodAppId,
-            target: appId,
-        });
         let error;
-        try {
-            const replOpts = replication.appReplicateOpts();
-            if (opts === null || opts === void 0 ? void 0 : opts.automationOnly) {
-                replOpts.filter = (doc) => doc._id.startsWith(backend_core_1.db.DocumentType.AUTOMATION);
+        if (exists) {
+            const replication = new backend_core_1.db.Replication({
+                source: prodAppId,
+                target: appId,
+            });
+            try {
+                const replOpts = replication.appReplicateOpts();
+                if (opts === null || opts === void 0 ? void 0 : opts.automationOnly) {
+                    replOpts.filter = (doc) => doc._id.startsWith(backend_core_1.db.DocumentType.AUTOMATION);
+                }
+                yield replication.replicate(replOpts);
+            }
+            catch (err) {
+                error = err;
+            }
+            finally {
+                yield replication.close();
             }
-            yield replication.replicate(replOpts);
-        }
-        catch (err) {
-            error = err;
-        }
-        finally {
-            yield replication.close();
         }
-        // sync the users
+        // sync the users - kept for safe keeping
         yield __1.default.users.syncGlobalUsers();
         if (error) {
             throw error;

package/dist/sdk/app/backups/exports.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamExportApp = exports.exportMultipleApps = exports.exportApp = exports.exportDB = void 0;
+exports.streamExportApp = exports.exportApp = exports.exportDB = void 0;
 const backend_core_1 = require("@budibase/backend-core");
 const budibaseDir_1 = require("../../../utilities/budibaseDir");
 const fileSystem_1 = require("../../../utilities/fileSystem");
@@ -73,11 +73,14 @@ function exportDB(dbName, opts = {}) {
     });
 }
 exports.exportDB = exportDB;
-function defineFilter(excludeRows) {
+function defineFilter(excludeRows, excludeLogs) {
     const ids = [utils_1.USER_METDATA_PREFIX, utils_1.LINK_USER_METADATA_PREFIX];
     if (excludeRows) {
         ids.push(utils_1.TABLE_ROW_PREFIX);
     }
+    if (excludeLogs) {
+        ids.push(utils_1.AUTOMATION_LOG_PREFIX);
+    }
     return (doc) => !ids.map(key => doc._id.includes(key)).reduce((prev, curr) => prev || curr);
 }
 /**
@@ -119,7 +122,10 @@ function exportApp(appId, config) {
         }
         // enforce an export of app DB to the tmp path
         const dbPath = (0, path_1.join)(tmpPath, constants_2.DB_EXPORT_FILE);
-        yield exportDB(appId, Object.assign(Object.assign({}, config), { filter: defineFilter(config === null || config === void 0 ? void 0 : config.excludeRows), exportPath: dbPath }));
+        yield exportDB(appId, {
+            filter: defineFilter(config === null || config === void 0 ? void 0 : config.excludeRows, config === null || config === void 0 ? void 0 : config.excludeLogs),
+            exportPath: dbPath,
+        });
         // if tar requested, return where the tarball is
         if (config === null || config === void 0 ? void 0 : config.tar) {
             // now the tmpPath contains both the DB export and attachments, tar this
@@ -135,40 +141,6 @@ function exportApp(appId, config) {
     });
 }
 exports.exportApp = exportApp;
-/**
- * Export all apps + global DB (if supplied) to a single tarball, this includes
- * the attachments for each app as well.
- * @param {object[]} appMetadata The IDs and names of apps to export.
- * @param {string} globalDbContents The contents of the global DB to export as well.
- * @return {string} The path to the tarball.
- */
-function exportMultipleApps(appMetadata, globalDbContents) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tmpPath = (0, path_1.join)((0, budibaseDir_1.budibaseTempDir)(), uuid());
-        fs_1.default.mkdirSync(tmpPath);
-        let exportPromises = [];
-        // export each app to a directory, then move it into the complete export
-        const exportAndMove = (appId, appName) => __awaiter(this, void 0, void 0, function* () {
-            const path = yield exportApp(appId);
-            yield fs_1.default.promises.rename(path, (0, path_1.join)(tmpPath, appName));
-        });
-        for (let metadata of appMetadata) {
-            exportPromises.push(exportAndMove(metadata.appId, metadata.name));
-        }
-        // wait for all exports to finish
-        yield Promise.all(exportPromises);
-        // add the global DB contents
-        if (globalDbContents) {
-            fs_1.default.writeFileSync((0, path_1.join)(tmpPath, constants_2.GLOBAL_DB_EXPORT_FILE), globalDbContents);
-        }
-        const appNames = appMetadata.map(metadata => metadata.name);
-        const tarPath = tarFilesToTmp(tmpPath, [...appNames, constants_2.GLOBAL_DB_EXPORT_FILE]);
-        // clear up the tmp path now tarball generated
-        fs_1.default.rmSync(tmpPath, { recursive: true, force: true });
-        return tarPath;
-    });
-}
-exports.exportMultipleApps = exportMultipleApps;
 /**
  * Streams a backup of the database state for an app
  * @param {string} appId The ID of the app which is to be backed up.
@@ -177,7 +149,11 @@ exports.exportMultipleApps = exportMultipleApps;
  */
 function streamExportApp(appId, excludeRows) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tmpPath = yield exportApp(appId, { excludeRows, tar: true });
+        const tmpPath = yield exportApp(appId, {
+            excludeRows,
+            excludeLogs: true,
+            tar: true,
+        });
         return (0, fileSystem_1.streamFile)(tmpPath);
     });
 }

package/dist/sdk/index.js

@@ -11,6 +11,7 @@ const datasources_1 = __importDefault(require("./app/datasources"));
 const queries_1 = __importDefault(require("./app/queries"));
 const rows_1 = __importDefault(require("./app/rows"));
 const users_1 = __importDefault(require("./users"));
+const plugins_1 = __importDefault(require("./plugins"));
 const sdk = {
     backups: backups_1.default,
     tables: tables_1.default,
@@ -20,6 +21,7 @@ const sdk = {
     users: users_1.default,
     datasources: datasources_1.default,
     queries: queries_1.default,
+    plugins: plugins_1.default,
 };
 // default export for TS
 exports.default = sdk;

package/dist/sdk/plugins/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = __importStar(require("./plugins"));
+exports.default = Object.assign({}, plugins);

package/dist/sdk/plugins/plugins.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUploaded = exports.fetch = void 0;
+const types_1 = require("@budibase/types");
+const backend_core_1 = require("@budibase/backend-core");
+const file_1 = require("../../api/controllers/plugin/file");
+const environment_1 = __importDefault(require("../../environment"));
+const websockets_1 = require("../../websockets");
+const pro_1 = require("@budibase/pro");
+function fetch(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.tenancy.getGlobalDB();
+        const response = yield db.allDocs(backend_core_1.db.getPluginParams(null, {
+            include_docs: true,
+        }));
+        let plugins = response.rows.map((row) => row.doc);
+        plugins = backend_core_1.objectStore.enrichPluginURLs(plugins);
+        if (type) {
+            return plugins.filter((plugin) => { var _a; return ((_a = plugin.schema) === null || _a === void 0 ? void 0 : _a.type) === type; });
+        }
+        else {
+            return plugins;
+        }
+    });
+}
+exports.fetch = fetch;
+function processUploaded(plugin, source) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { metadata, directory } = yield (0, file_1.fileUpload)(plugin);
+        backend_core_1.plugins.validate(metadata === null || metadata === void 0 ? void 0 : metadata.schema);
+        // Only allow components in cloud
+        if (!environment_1.default.SELF_HOSTED && ((_a = metadata === null || metadata === void 0 ? void 0 : metadata.schema) === null || _a === void 0 ? void 0 : _a.type) !== types_1.PluginType.COMPONENT) {
+            throw new Error("Only component plugins are supported outside of self-host");
+        }
+        const doc = yield pro_1.sdk.plugins.storePlugin(metadata, directory, source);
+        websockets_1.clientAppSocket.emit("plugin-update", { name: doc.name, hash: doc.hash });
+        return doc;
+    });
+}
+exports.processUploaded = processUploaded;

package/dist/sdk/users/utils.js

@@ -34,6 +34,10 @@ function combineMetadataAndUser(user, metadata) {
     if (found) {
         newDoc._rev = found._rev;
     }
+    // clear fields that shouldn't be in metadata
+    delete newDoc.password;
+    delete newDoc.forceResetPassword;
+    delete newDoc.roles;
     if (found == null || !(0, lodash_1.isEqual)(newDoc, found)) {
         return Object.assign(Object.assign({}, found), newDoc);
     }
@@ -53,10 +57,9 @@ function syncGlobalUsers() {
     return __awaiter(this, void 0, void 0, function* () {
         // sync user metadata
         const db = backend_core_1.context.getAppDB();
-        const [users, metadata] = yield Promise.all([
-            (0, global_1.getGlobalUsers)(),
-            rawUserMetadata(),
-        ]);
+        const resp = yield Promise.all([(0, global_1.getGlobalUsers)(), rawUserMetadata()]);
+        const users = resp[0];
+        const metadata = resp[1];
         const toWrite = [];
         for (let user of users) {
             const combined = combineMetadataAndUser(user, metadata);
@@ -64,6 +67,20 @@ function syncGlobalUsers() {
                 toWrite.push(combined);
             }
         }
+        let foundEmails = [];
+        for (let data of metadata) {
+            if (!data._id) {
+                continue;
+            }
+            const alreadyExisting = data.email && foundEmails.indexOf(data.email) !== -1;
+            const globalId = (0, utils_1.getGlobalIDFromUserMetadataID)(data._id);
+            if (!users.find(user => user._id === globalId) || alreadyExisting) {
+                toWrite.push(Object.assign(Object.assign({}, data), { _deleted: true }));
+            }
+            if (data.email) {
+                foundEmails.push(data.email);
+            }
+        }
         yield db.bulkDocs(toWrite);
     });
 }