@budibase/server 2.7.15 → 2.7.16-alpha.1

package/dist/query.js

@@ -11,8 +11,8 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -563,13 +563,13 @@ var init_plan = __esm({
 var isStaticQuota, isMonthlyQuota, isConstantQuota;
 var init_quota = __esm({
   "../types/src/sdk/licensing/quota.ts"() {
-    isStaticQuota = (quotaType, usageType, name) => {
+    isStaticQuota = (quotaType, usageType, name2) => {
       return quotaType === "usage" /* USAGE */ && usageType === "static" /* STATIC */;
     };
-    isMonthlyQuota = (quotaType, usageType, name) => {
+    isMonthlyQuota = (quotaType, usageType, name2) => {
       return quotaType === "usage" /* USAGE */ && usageType === "monthly" /* MONTHLY */;
     };
-    isConstantQuota = (quotaType, name) => {
+    isConstantQuota = (quotaType, name2) => {
       return quotaType === "constant" /* CONSTANT */;
     };
   }
@@ -679,8 +679,8 @@ var init_locks = __esm({
 var isDocument;
 var init_db = __esm({
   "../types/src/sdk/db.ts"() {
-    isDocument = (doc) => {
-      return typeof doc === "object" && doc._id && doc._rev;
+    isDocument = (doc2) => {
+      return typeof doc2 === "object" && doc2._id && doc2._rev;
     };
   }
 });
@@ -838,6 +838,7 @@ var init_automation2 = __esm({
       AutomationIOType2["NUMBER"] = "number";
       AutomationIOType2["ARRAY"] = "array";
       AutomationIOType2["JSON"] = "json";
+      AutomationIOType2["DATE"] = "date";
       return AutomationIOType2;
     })(AutomationIOType || {});
     AutomationCustomIOType = /* @__PURE__ */ ((AutomationCustomIOType2) => {
@@ -1954,27 +1955,27 @@ function init(opts) {
 }
 function getPouchDB(dbName, opts) {
   checkInitialised();
-  const db = new Pouch(dbName, opts);
-  const dbPut = db.put;
-  db.put = async (doc, options2 = {}) => {
-    if (!doc.createdAt) {
-      doc.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    doc.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return dbPut(doc, options2);
+  const db2 = new Pouch(dbName, opts);
+  const dbPut = db2.put;
+  db2.put = async (doc2, options2 = {}) => {
+    if (!doc2.createdAt) {
+      doc2.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    doc2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return dbPut(doc2, options2);
   };
-  db.exists = async () => {
-    const info = await db.info();
+  db2.exists = async () => {
+    const info = await db2.info();
     return !info.error;
   };
-  return db;
+  return db2;
 }
-async function closePouchDB(db) {
-  if (!db || environment_default2.isTest()) {
+async function closePouchDB(db2) {
+  if (!db2 || environment_default2.isTest()) {
     return;
   }
   try {
-    return await db.close();
+    return await db2.close();
   } catch (err) {
   }
 }
@@ -2125,14 +2126,14 @@ var init_DatabaseImpl = __esm({
         }
       }
       async get(id) {
-        const db = await this.checkSetup();
+        const db2 = await this.checkSetup();
         if (!id) {
           throw new Error("Unable to get doc without a valid _id.");
         }
-        return this.updateOutput(() => db.get(id));
+        return this.updateOutput(() => db2.get(id));
       }
-      async remove(idOrDoc, rev) {
-        const db = await this.checkSetup();
+      async remove(idOrDoc, rev2) {
+        const db2 = await this.checkSetup();
         let _id;
         let _rev;
         if (isDocument(idOrDoc)) {
@@ -2140,12 +2141,12 @@ var init_DatabaseImpl = __esm({
           _rev = idOrDoc._rev;
         } else {
           _id = idOrDoc;
-          _rev = rev;
+          _rev = rev2;
         }
         if (!_id || !_rev) {
           throw new Error("Unable to remove doc without a valid _id and _rev.");
         }
-        return this.updateOutput(() => db.destroy(_id, _rev));
+        return this.updateOutput(() => db2.destroy(_id, _rev));
       }
       async post(document, opts) {
         if (!document._id) {
@@ -2157,7 +2158,7 @@ var init_DatabaseImpl = __esm({
         if (!document._id) {
           throw new Error("Cannot store document without _id field.");
         }
-        const db = await this.checkSetup();
+        const db2 = await this.checkSetup();
         if (!document.createdAt) {
           document.createdAt = (/* @__PURE__ */ new Date()).toISOString();
         }
@@ -2174,20 +2175,20 @@ var init_DatabaseImpl = __esm({
             }
           }
         }
-        return this.updateOutput(() => db.insert(document));
+        return this.updateOutput(() => db2.insert(document));
       }
       async bulkDocs(documents) {
-        const db = await this.checkSetup();
-        return this.updateOutput(() => db.bulk({ docs: documents }));
+        const db2 = await this.checkSetup();
+        return this.updateOutput(() => db2.bulk({ docs: documents }));
       }
       async allDocs(params2) {
-        const db = await this.checkSetup();
-        return this.updateOutput(() => db.list(params2));
+        const db2 = await this.checkSetup();
+        return this.updateOutput(() => db2.list(params2));
       }
       async query(viewName, params2) {
-        const db = await this.checkSetup();
+        const db2 = await this.checkSetup();
         const [database, view] = viewName.split("/");
-        return this.updateOutput(() => db.view(database, view, params2));
+        return this.updateOutput(() => db2.view(database, view, params2));
       }
       async destroy() {
         try {
@@ -2201,8 +2202,8 @@ var init_DatabaseImpl = __esm({
         }
       }
       async compact() {
-        const db = await this.checkSetup();
-        return this.updateOutput(() => db.compact());
+        const db2 = await this.checkSetup();
+        return this.updateOutput(() => db2.compact());
       }
       // All below functions are in-frequently called, just utilise PouchDB
       // for them as it implements them better than we can
@@ -2245,8 +2246,8 @@ function getDB(dbName, opts) {
   return new DatabaseImpl(dbName, opts);
 }
 async function doWithDB(dbName, cb, opts = {}) {
-  const db = getDB(dbName, opts);
-  return await cb(db);
+  const db2 = getDB(dbName, opts);
+  return await cb(db2);
 }
 function allDbs() {
   if (!environment_default2.isTest()) {
@@ -2594,11 +2595,11 @@ function getRedisOptions() {
   }
   return { opts, host, port: parseInt(port), redisProtocolUrl };
 }
-function addDbPrefix(db, key) {
-  if (key.includes(db)) {
+function addDbPrefix(db2, key) {
+  if (key.includes(db2)) {
     return key;
   }
-  return `${db}${SEPARATOR2}${key}`;
+  return `${db2}${SEPARATOR2}${key}`;
 }
 function removeDbPrefix(key) {
   let parts = key.split(SEPARATOR2);
@@ -2818,8 +2819,8 @@ var init_redis = __esm({
       CONNECTED = true;
     }
     RedisWrapper = class {
-      constructor(db, selectDb = null) {
-        this._db = db;
+      constructor(db2, selectDb = null) {
+        this._db = db2;
         this._select = selectDb || DEFAULT_SELECT_DB;
       }
       getClient() {
@@ -2839,8 +2840,8 @@ var init_redis = __esm({
         this.getClient().disconnect();
       }
       async scan(key = "") {
-        const db = this._db;
-        key = `${db}${SEPARATOR2}${key}`;
+        const db2 = this._db;
+        key = `${db2}${SEPARATOR2}${key}`;
         let stream3;
         if (CLUSTERED) {
           let node = this.getClient().nodes("master");
@@ -2851,16 +2852,16 @@ var init_redis = __esm({
         return promisifyStream(stream3, this.getClient());
       }
       async keys(pattern) {
-        const db = this._db;
-        return this.getClient().keys(addDbPrefix(db, pattern));
+        const db2 = this._db;
+        return this.getClient().keys(addDbPrefix(db2, pattern));
       }
       async exists(key) {
-        const db = this._db;
-        return await this.getClient().exists(addDbPrefix(db, key));
+        const db2 = this._db;
+        return await this.getClient().exists(addDbPrefix(db2, key));
       }
       async get(key) {
-        const db = this._db;
-        let response = await this.getClient().get(addDbPrefix(db, key));
+        const db2 = this._db;
+        let response = await this.getClient().get(addDbPrefix(db2, key));
         if (response != null && response.key) {
           response.key = key;
         }
@@ -2871,11 +2872,11 @@ var init_redis = __esm({
         }
       }
       async bulkGet(keys2) {
-        const db = this._db;
+        const db2 = this._db;
         if (keys2.length === 0) {
           return {};
         }
-        const prefixedKeys = keys2.map((key) => addDbPrefix(db, key));
+        const prefixedKeys = keys2.map((key) => addDbPrefix(db2, key));
         let response = await this.getClient().mget(prefixedKeys);
         if (Array.isArray(response)) {
           let final = {};
@@ -2898,29 +2899,29 @@ var init_redis = __esm({
         }
       }
       async store(key, value, expirySeconds = null) {
-        const db = this._db;
+        const db2 = this._db;
         if (typeof value === "object") {
           value = JSON.stringify(value);
         }
-        const prefixedKey = addDbPrefix(db, key);
+        const prefixedKey = addDbPrefix(db2, key);
         await this.getClient().set(prefixedKey, value);
         if (expirySeconds) {
           await this.getClient().expire(prefixedKey, expirySeconds);
         }
       }
       async getTTL(key) {
-        const db = this._db;
-        const prefixedKey = addDbPrefix(db, key);
+        const db2 = this._db;
+        const prefixedKey = addDbPrefix(db2, key);
         return this.getClient().ttl(prefixedKey);
       }
       async setExpiry(key, expirySeconds) {
-        const db = this._db;
-        const prefixedKey = addDbPrefix(db, key);
+        const db2 = this._db;
+        const prefixedKey = addDbPrefix(db2, key);
         await this.getClient().expire(prefixedKey, expirySeconds);
       }
       async delete(key) {
-        const db = this._db;
-        await this.getClient().del(addDbPrefix(db, key));
+        const db2 = this._db;
+        await this.getClient().del(addDbPrefix(db2, key));
       }
       async clear() {
         let items = await this.scan();
@@ -3296,8 +3297,8 @@ function logAlert(message, e) {
   }
   console.error(`bb-alert: ${message}`, e);
 }
-function logAlertWithInfo(message, db, id, error) {
-  message = `${message} - db: ${db} - doc: ${id} - error: `;
+function logAlertWithInfo(message, db2, id, error) {
+  message = `${message} - db: ${db2} - doc: ${id} - error: `;
   logAlert(message, error);
 }
 function logWarn(message) {
@@ -3334,8 +3335,8 @@ var init_logging = __esm({
 var require_Helper = __commonJS({
   "../string-templates/src/helpers/Helper.js"(exports2, module2) {
     var Helper = class {
-      constructor(name, fn, useValueFallback = true) {
-        this.name = name;
+      constructor(name2, fn, useValueFallback = true) {
+        this.name = name2;
         this.fn = fn;
         this.useValueFallback = useValueFallback;
       }
@@ -3504,18 +3505,18 @@ var require_external = __commonJS({
     exports2.externalCollections = EXTERNAL_FUNCTION_COLLECTIONS;
     exports2.addedHelpers = ADDED_HELPERS;
     exports2.registerAll = (handlebars) => {
-      for (let [name, helper] of Object.entries(ADDED_HELPERS)) {
-        handlebars.registerHelper(name, helper);
+      for (let [name2, helper] of Object.entries(ADDED_HELPERS)) {
+        handlebars.registerHelper(name2, helper);
       }
       let externalNames = [];
       for (let collection of EXTERNAL_FUNCTION_COLLECTIONS) {
         let hbsHelperInfo = helpers[collection]();
         for (let entry of Object.entries(hbsHelperInfo)) {
-          const name = entry[0];
-          if (HelperFunctionBuiltin.indexOf(name) !== -1 || externalNames.indexOf(name) !== -1) {
+          const name2 = entry[0];
+          if (HelperFunctionBuiltin.indexOf(name2) !== -1 || externalNames.indexOf(name2) !== -1) {
             continue;
           }
-          externalNames.push(name);
+          externalNames.push(name2);
         }
         helpers[collection]({
           handlebars
@@ -3524,11 +3525,11 @@ var require_external = __commonJS({
       exports2.externalHelperNames = externalNames.concat(Object.keys(ADDED_HELPERS));
     };
     exports2.unregisterAll = (handlebars) => {
-      for (let name of Object.keys(ADDED_HELPERS)) {
-        handlebars.unregisterHelper(name);
+      for (let name2 of Object.keys(ADDED_HELPERS)) {
+        handlebars.unregisterHelper(name2);
       }
-      for (let name of module2.exports.externalHelperNames) {
-        handlebars.unregisterHelper(name);
+      for (let name2 of module2.exports.externalHelperNames) {
+        handlebars.unregisterHelper(name2);
       }
       exports2.externalHelperNames = [];
     };
@@ -3642,12 +3643,12 @@ var require_javascript = __commonJS({
         throw new Error("JS disabled in environment.");
       }
       try {
-        const js = `function run(){${atob(handlebars)}};run();`;
+        const js2 = `function run(){${atob(handlebars)}};run();`;
         const sandboxContext = {
           $: (path2) => getContextValue(path2, cloneDeep7(context)),
           helpers: getHelperList()
         };
-        const res = { data: runJS(js, sandboxContext) };
+        const res = { data: runJS(js2, sandboxContext) };
         return `{{${LITERAL_MARKER} js_result-${JSON.stringify(res)}}}`;
       } catch (error) {
         return "Error while executing JS";
@@ -3760,8 +3761,8 @@ var require_preprocessor = __commonJS({
       FINALISE: "finalise"
     };
     var Preprocessor = class {
-      constructor(name, fn) {
-        this.name = name;
+      constructor(name2, fn) {
+        this.name = name2;
         this.fn = fn;
       }
       process(fullString, statement, opts) {
@@ -3825,8 +3826,8 @@ var require_postprocessor = __commonJS({
       CONVERT_LITERALS: "convert-literals"
     };
     var Postprocessor = class {
-      constructor(name, fn) {
-        this.name = name;
+      constructor(name2, fn) {
+        this.name = name2;
         this.fn = fn;
       }
       process(statement) {
@@ -5468,10 +5469,10 @@ var require_src = __commonJS({
     };
     module2.exports.convertToJS = (hbs) => {
       const blocks = exports2.findHBSBlocks(hbs);
-      let js = "return `", prevBlock = null;
+      let js2 = "return `", prevBlock = null;
       const variables = {};
       if (blocks.length === 0) {
-        js += hbs;
+        js2 += hbs;
       }
       let count = 1;
       for (let block of blocks) {
@@ -5483,15 +5484,15 @@ var require_src = __commonJS({
         prevBlock = block;
         const { variable, value } = convertHBSBlock(block, count++);
         variables[variable] = value;
-        js += `${stringPart.split()}\${${variable}}`;
+        js2 += `${stringPart.split()}\${${variable}}`;
       }
       let varBlock = "";
       for (let [variable, value] of Object.entries(variables)) {
         varBlock += `const ${variable} = ${value};
 `;
       }
-      js += "`;";
-      return `${varBlock}${js}`;
+      js2 += "`;";
+      return `${varBlock}${js2}`;
     };
   }
 });
@@ -5518,12 +5519,12 @@ var require_src2 = __commonJS({
     if (!process.env.NO_JS) {
       const { VM: VM2 } = require("vm2");
       const { setJSRunner } = require_javascript();
-      setJSRunner((js, context) => {
+      setJSRunner((js2, context) => {
         const vm = new VM2({
           sandbox: context,
           timeout: 1e3
         });
-        return vm.run(js);
+        return vm.run(js2);
       });
     }
   }
@@ -5874,8 +5875,8 @@ async function lookupTenantId(userId) {
   return user.tenantId;
 }
 async function getUserDoc(emailOrId) {
-  const db = getPlatformDB();
-  return db.get(emailOrId);
+  const db2 = getPlatformDB();
+  return db2.get(emailOrId);
 }
 function newUserIdDoc(id, tenantId) {
   return {
@@ -5891,14 +5892,14 @@ function newUserEmailDoc(userId, email, tenantId) {
   };
 }
 async function addUserDoc(emailOrId, newDocFn) {
-  const db = getPlatformDB();
+  const db2 = getPlatformDB();
   let user;
   try {
-    await db.get(emailOrId);
+    await db2.get(emailOrId);
   } catch (e) {
     if (e.status === 404) {
       user = newDocFn();
-      await db.put(user);
+      await db2.put(user);
     } else {
       throw e;
     }
@@ -5911,9 +5912,9 @@ async function addUser(tenantId, userId, email) {
   ]);
 }
 async function removeUser(user) {
-  const db = getPlatformDB();
+  const db2 = getPlatformDB();
   const keys2 = [user._id, user.email];
-  const userDocs = await db.allDocs({
+  const userDocs = await db2.allDocs({
     keys: keys2,
     include_docs: true
   });
@@ -5923,7 +5924,7 @@ async function removeUser(user) {
       _deleted: true
     };
   });
-  await db.bulkDocs(toDelete);
+  await db2.bulkDocs(toDelete);
 }
 
 // ../backend-core/src/platform/tenants.ts
@@ -6008,18 +6009,18 @@ async function newRedlock(opts = {}) {
 }
 function getLockName(opts) {
   const prefix = opts.systemLock ? "system" : getTenantId();
-  let name = `lock:${prefix}_${opts.name}`;
+  let name2 = `lock:${prefix}_${opts.name}`;
   if (opts.resource) {
-    name = name + `_${opts.resource}`;
+    name2 = name2 + `_${opts.resource}`;
   }
-  return name;
+  return name2;
 }
 async function doWithLock(opts, task) {
   const redlock = await getClient(opts.type, opts.customOptions);
   let lock;
   try {
-    const name = getLockName(opts);
-    lock = await redlock.lock(name, opts.ttl);
+    const name2 = getLockName(opts);
+    lock = await redlock.lock(name2, opts.ttl);
     const result = await task();
     return { executed: true, result };
   } catch (e) {
@@ -6129,8 +6130,8 @@ var getAccount = async (email) => {
 // ../backend-core/src/cache/user.ts
 var EXPIRY_SECONDS = 3600;
 async function populateFromDB(userId, tenantId) {
-  const db = getTenantDB(tenantId);
-  const user = await db.get(userId);
+  const db2 = getTenantDB(tenantId);
+  const user = await db2.get(userId);
   user.budibaseAccess = true;
   if (!environment_default2.SELF_HOSTED && !environment_default2.DISABLE_ACCOUNT_PORTAL) {
     const account = await getAccount(user.email);
@@ -6319,8 +6320,8 @@ function generateRoleID(id) {
 var generateDevInfoID = (userId) => {
   return `${"devinfo" /* DEV_INFO */}${SEPARATOR}${userId}`;
 };
-var generatePluginID = (name) => {
-  return `${"plg" /* PLUGIN */}${SEPARATOR}${name}`;
+var generatePluginID = (name2) => {
+  return `${"plg" /* PLUGIN */}${SEPARATOR}${name2}`;
 };
 
 // ../backend-core/src/docIds/params.ts
@@ -6405,8 +6406,8 @@ function getStartEndKeyURL(baseKey, tenantId) {
   const tenancy2 = tenantId ? `${SEPARATOR}${tenantId}` : "";
   return `startkey="${baseKey}${tenancy2}"&endkey="${baseKey}${tenancy2}${UNICODE_MAX}"`;
 }
-var getPluginParams = (pluginId, otherProps = {}) => {
-  return getDocParams("plg" /* PLUGIN */, pluginId, otherProps);
+var getPluginParams = (pluginId2, otherProps = {}) => {
+  return getDocParams("plg" /* PLUGIN */, pluginId2, otherProps);
 };
 
 // ../backend-core/src/db/utils.ts
@@ -6513,8 +6514,8 @@ function isSameAppID(appId1, appId2) {
 async function dbExists(dbName) {
   return doWithDB(
     dbName,
-    async (db) => {
-      return await db.exists();
+    async (db2) => {
+      return await db2.exists();
     },
     { skip_setup: true }
   );
@@ -6533,7 +6534,7 @@ function pagination(data, pageSize, {
   const hasNextPage = data.length > pageSize;
   let nextPage = void 0;
   if (!getKey) {
-    getKey = (doc) => property ? doc == null ? void 0 : doc[property] : doc == null ? void 0 : doc._id;
+    getKey = (doc2) => property ? doc2 == null ? void 0 : doc2[property] : doc2 == null ? void 0 : doc2._id;
   }
   if (hasNextPage) {
     nextPage = getKey(data[pageSize]);
@@ -6558,23 +6559,23 @@ function DesignDoc() {
     views: {}
   };
 }
-async function removeDeprecated(db, viewName) {
+async function removeDeprecated(db2, viewName) {
   if (!DeprecatedViews[viewName]) {
     return;
   }
   try {
-    const designDoc = await db.get(DESIGN_DB);
+    const designDoc = await db2.get(DESIGN_DB);
     for (let deprecatedNames of DeprecatedViews[viewName]) {
       delete designDoc.views[deprecatedNames];
     }
-    await db.put(designDoc);
+    await db2.put(designDoc);
   } catch (err) {
   }
 }
-async function createView(db, viewJs, viewName) {
+async function createView(db2, viewJs, viewName) {
   let designDoc;
   try {
-    designDoc = await db.get(DESIGN_DB);
+    designDoc = await db2.get(DESIGN_DB);
   } catch (err) {
     designDoc = DesignDoc();
   }
@@ -6586,26 +6587,26 @@ async function createView(db, viewJs, viewName) {
     [viewName]: view
   };
   try {
-    await db.put(designDoc);
+    await db2.put(designDoc);
   } catch (err) {
     if (err.status === 409) {
-      return await createView(db, viewJs, viewName);
+      return await createView(db2, viewJs, viewName);
     } else {
       throw err;
     }
   }
 }
 var createNewUserEmailView = async () => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const viewJs = `function(doc) {
     if (doc._id.startsWith("${"us" /* USER */}${SEPARATOR}")) {
       emit(doc.email.toLowerCase(), doc._id)
     }
   }`;
-  await createView(db, viewJs, "by_email2" /* USER_BY_EMAIL */);
+  await createView(db2, viewJs, "by_email2" /* USER_BY_EMAIL */);
 };
 var createUserAppView = async () => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const viewJs = `function(doc) {
     if (doc._id.startsWith("${"us" /* USER */}${SEPARATOR}") && doc.roles) {
       for (let prodAppId of Object.keys(doc.roles)) {
@@ -6614,46 +6615,46 @@ var createUserAppView = async () => {
       }
     }
   }`;
-  await createView(db, viewJs, "by_app" /* USER_BY_APP */);
+  await createView(db2, viewJs, "by_app" /* USER_BY_APP */);
 };
 var createApiKeyView = async () => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const viewJs = `function(doc) {
     if (doc._id.startsWith("${"devinfo" /* DEV_INFO */}") && doc.apiKey) {
       emit(doc.apiKey, doc.userId)
     }
   }`;
-  await createView(db, viewJs, "by_api_key" /* BY_API_KEY */);
+  await createView(db2, viewJs, "by_api_key" /* BY_API_KEY */);
 };
 var createUserBuildersView = async () => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const viewJs = `function(doc) {
     if (doc.builder && doc.builder.global === true) {
       emit(doc._id, doc._id)
     }
   }`;
-  await createView(db, viewJs, "by_builders" /* USER_BY_BUILDERS */);
+  await createView(db2, viewJs, "by_builders" /* USER_BY_BUILDERS */);
 };
-async function queryViewRaw(viewName, params2, db, createFunc, opts) {
+async function queryViewRaw(viewName, params2, db2, createFunc, opts) {
   try {
-    const response = await db.query(`database/${viewName}`, params2);
+    const response = await db2.query(`database/${viewName}`, params2);
     return response;
   } catch (err) {
     const pouchNotFound = err && err.name === "not_found";
     const couchNotFound = err && err.status === 404;
     if (pouchNotFound || couchNotFound) {
-      await removeDeprecated(db, viewName);
+      await removeDeprecated(db2, viewName);
       await createFunc();
-      return queryViewRaw(viewName, params2, db, createFunc, opts);
+      return queryViewRaw(viewName, params2, db2, createFunc, opts);
     } else if (err.status === 409) {
-      return queryViewRaw(viewName, params2, db, createFunc, opts);
+      return queryViewRaw(viewName, params2, db2, createFunc, opts);
     } else {
       throw err;
     }
   }
 }
-var queryView = async (viewName, params2, db, createFunc, opts) => {
-  const response = await queryViewRaw(viewName, params2, db, createFunc, opts);
+var queryView = async (viewName, params2, db2, createFunc, opts) => {
+  const response = await queryViewRaw(viewName, params2, db2, createFunc, opts);
   const rows2 = response.rows;
   const docs = rows2.map(
     (row) => params2.include_docs ? row.doc : row.value
@@ -6666,8 +6667,8 @@ var queryView = async (viewName, params2, db, createFunc, opts) => {
 };
 async function createPlatformView(viewJs, viewName) {
   try {
-    await doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db) => {
-      await createView(db, viewJs, viewName);
+    await doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db2) => {
+      await createView(db2, viewJs, viewName);
     });
   } catch (e) {
     if (e.status === 409 && environment_default2.isTest()) {
@@ -6697,9 +6698,9 @@ var queryPlatformView = async (viewName, params2, opts) => {
     ["account_by_email" /* ACCOUNT_BY_EMAIL */]: createPlatformAccountEmailView,
     ["platform_users_lowercase" /* PLATFORM_USERS_LOWERCASE */]: createPlatformUserView
   };
-  return doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db) => {
+  return doWithDB(StaticDatabases.PLATFORM_INFO.name, async (db2) => {
     const createFn = CreateFuncByName2[viewName];
-    return queryView(viewName, params2, db, createFn, opts);
+    return queryView(viewName, params2, db2, createFn, opts);
   });
 };
 var CreateFuncByName = {
@@ -6708,17 +6709,17 @@ var CreateFuncByName = {
   ["by_builders" /* USER_BY_BUILDERS */]: createUserBuildersView,
   ["by_app" /* USER_BY_APP */]: createUserAppView
 };
-var queryGlobalView = async (viewName, params2, db, opts) => {
-  if (!db) {
-    db = getGlobalDB();
+var queryGlobalView = async (viewName, params2, db2, opts) => {
+  if (!db2) {
+    db2 = getGlobalDB();
   }
   const createFn = CreateFuncByName[viewName];
-  return queryView(viewName, params2, db, createFn, opts);
+  return queryView(viewName, params2, db2, createFn, opts);
 };
 async function queryGlobalViewRaw(viewName, params2, opts) {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const createFn = CreateFuncByName[viewName];
-  return queryViewRaw(viewName, params2, db, createFn, opts);
+  return queryViewRaw(viewName, params2, db2, createFn, opts);
 }
 
 // ../backend-core/src/db/index.ts
@@ -6733,8 +6734,8 @@ var Replication = class {
    * @param {String} source - the DB you want to replicate or rollback to
    * @param {String} target - the DB you want to replicate to, or rollback from
    */
-  constructor({ source, target }) {
-    this.source = getPouchDB(source);
+  constructor({ source: source2, target }) {
+    this.source = getPouchDB(source2);
     this.target = getPouchDB(target);
   }
   close() {
@@ -6769,8 +6770,8 @@ var Replication = class {
   }
   appReplicateOpts() {
     return {
-      filter: (doc) => {
-        return doc._id !== "app_metadata" /* APP_METADATA */;
+      filter: (doc2) => {
+        return doc2._id !== "app_metadata" /* APP_METADATA */;
       }
     };
   }
@@ -6858,9 +6859,9 @@ var _QueryBuilder = class {
     __privateSet(this, _indexBuilder, builderFn);
     return this;
   }
-  setVersion(version) {
-    if (version != null) {
-      __privateSet(this, _version, version);
+  setVersion(version2) {
+    if (version2 != null) {
+      __privateSet(this, _version, version2);
     }
     return this;
   }
@@ -7353,10 +7354,10 @@ __export(searchIndexes_exports, {
 init_src();
 init_context2();
 async function createUserIndex() {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   let designDoc;
   try {
-    designDoc = await db.get("_design/database");
+    designDoc = await db2.get("_design/database");
   } catch (err) {
     if (err.status === 404) {
       designDoc = { _id: "_design/database" };
@@ -7402,7 +7403,7 @@ async function createUserIndex() {
       }
     }
   };
-  await db.put(designDoc);
+  await db2.put(designDoc);
 }
 
 // ../backend-core/src/cache/appMetadata.ts
@@ -7413,42 +7414,42 @@ var EXPIRY_SECONDS2 = 3600;
 async function populateFromDB2(appId) {
   return doWithDB(
     appId,
-    (db) => {
-      return db.get("app_metadata" /* APP_METADATA */);
+    (db2) => {
+      return db2.get("app_metadata" /* APP_METADATA */);
     },
     { skip_setup: true }
   );
 }
-function isInvalid(metadata) {
-  return !metadata || metadata.state === AppState.INVALID;
+function isInvalid(metadata2) {
+  return !metadata2 || metadata2.state === AppState.INVALID;
 }
 async function getAppMetadata(appId) {
   const client3 = await getAppClient();
-  let metadata = await client3.get(appId);
-  if (!metadata) {
+  let metadata2 = await client3.get(appId);
+  if (!metadata2) {
     let expiry = EXPIRY_SECONDS2;
     try {
-      metadata = await populateFromDB2(appId);
+      metadata2 = await populateFromDB2(appId);
     } catch (err) {
       if (err && err.status === 404) {
-        metadata = { state: AppState.INVALID };
+        metadata2 = { state: AppState.INVALID };
         expiry = void 0;
       } else {
         throw err;
       }
     }
-    if (isInvalid(metadata)) {
+    if (isInvalid(metadata2)) {
       const temp = await client3.get(appId);
       if (temp) {
-        metadata = temp;
+        metadata2 = temp;
       }
     }
-    await client3.store(appId, metadata, expiry);
+    await client3.store(appId, metadata2, expiry);
   }
-  if (isInvalid(metadata)) {
+  if (isInvalid(metadata2)) {
     throw { status: 404, message: "No app metadata found" };
   }
-  return metadata;
+  return metadata2;
 }
 async function invalidateAppMetadata(appId, newMetadata) {
   if (!appId) {
@@ -7479,21 +7480,21 @@ async function getCache() {
   }
   return CACHE;
 }
-function makeCacheKey(db, key) {
-  return db.name + key;
+function makeCacheKey(db2, key) {
+  return db2.name + key;
 }
-function makeCacheItem(doc, lastWrite = null) {
-  return { doc, lastWrite: lastWrite || Date.now() };
+function makeCacheItem(doc2, lastWrite = null) {
+  return { doc: doc2, lastWrite: lastWrite || Date.now() };
 }
-async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
+async function put(db2, doc2, writeRateMs = DEFAULT_WRITE_RATE_MS) {
   const cache2 = await getCache();
-  const key = doc._id;
+  const key = doc2._id;
   let cacheItem;
   if (key) {
-    cacheItem = await cache2.get(makeCacheKey(db, key));
+    cacheItem = await cache2.get(makeCacheKey(db2, key));
   }
   const updateDb = !cacheItem || cacheItem.lastWrite < Date.now() - writeRateMs;
-  let output = doc;
+  let output = doc2;
   if (updateDb) {
     const lockResponse = await doWithLock(
       {
@@ -7504,15 +7505,15 @@ async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
       },
       async () => {
         const writeDb = async (toWrite) => {
-          const response = await db.put(toWrite, { force: true });
+          const response = await db2.put(toWrite, { force: true });
           output = {
-            ...doc,
+            ...doc2,
             _id: response.id,
             _rev: response.rev
           };
         };
         try {
-          await writeDb(doc);
+          await writeDb(doc2);
         } catch (err) {
           if (err.status !== 409) {
             throw err;
@@ -7528,47 +7529,47 @@ async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
   }
   cacheItem = makeCacheItem(output, updateDb ? null : cacheItem == null ? void 0 : cacheItem.lastWrite);
   if (output._id) {
-    await cache2.store(makeCacheKey(db, output._id), cacheItem);
+    await cache2.store(makeCacheKey(db2, output._id), cacheItem);
   }
   return { ok: true, id: output._id, rev: output._rev };
 }
-async function get2(db, id) {
+async function get2(db2, id) {
   const cache2 = await getCache();
-  const cacheKey = makeCacheKey(db, id);
+  const cacheKey = makeCacheKey(db2, id);
   let cacheItem = await cache2.get(cacheKey);
   if (!cacheItem) {
-    const doc = await db.get(id);
-    cacheItem = makeCacheItem(doc);
+    const doc2 = await db2.get(id);
+    cacheItem = makeCacheItem(doc2);
     await cache2.store(cacheKey, cacheItem);
   }
   return cacheItem.doc;
 }
-async function remove(db, docOrId, rev) {
+async function remove(db2, docOrId, rev2) {
   const cache2 = await getCache();
   if (!docOrId) {
     throw new Error("No ID/Rev provided.");
   }
   const id = typeof docOrId === "string" ? docOrId : docOrId._id;
-  rev = typeof docOrId === "string" ? rev : docOrId._rev;
+  rev2 = typeof docOrId === "string" ? rev2 : docOrId._rev;
   try {
-    await cache2.delete(makeCacheKey(db, id));
+    await cache2.delete(makeCacheKey(db2, id));
   } finally {
-    await db.remove(id, rev);
+    await db2.remove(id, rev2);
   }
 }
 var Writethrough = class {
-  constructor(db, writeRateMs = DEFAULT_WRITE_RATE_MS) {
-    this.db = db;
+  constructor(db2, writeRateMs = DEFAULT_WRITE_RATE_MS) {
+    this.db = db2;
     this.writeRateMs = writeRateMs;
   }
-  async put(doc) {
-    return put(this.db, doc, this.writeRateMs);
+  async put(doc2) {
+    return put(this.db, doc2, this.writeRateMs);
   }
   async get(id) {
     return get2(this.db, id);
   }
-  async remove(docOrId, rev) {
-    return remove(this.db, docOrId, rev);
+  async remove(docOrId, rev2) {
+    return remove(this.db, docOrId, rev2);
   }
 };
 
@@ -7580,9 +7581,9 @@ function generateConfigID(type) {
   return `${"config" /* CONFIG */}${SEPARATOR}${type}`;
 }
 async function getConfig(type) {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   try {
-    return await db.get(generateConfigID(type));
+    return await db2.get(generateConfigID(type));
   } catch (e) {
     if (e.status === 404) {
       return;
@@ -7591,8 +7592,8 @@ async function getConfig(type) {
   }
 }
 async function save(config) {
-  const db = getGlobalDB();
-  return db.put(config);
+  const db2 = getGlobalDB();
+  return db2.put(config);
 }
 async function getSettingsConfigDoc() {
   let config = await getConfig("settings" /* SETTINGS */);
@@ -8041,7 +8042,7 @@ __export(utils_exports2, {
   compare: () => compare,
   getAppIdFromCtx: () => getAppIdFromCtx,
   getCookie: () => getCookie,
-  hash: () => hash,
+  hash: () => hash2,
   isAudited: () => isAudited,
   isClient: () => isClient,
   isPublicApiRequest: () => isPublicApiRequest,
@@ -8062,7 +8063,7 @@ init_environment2();
 init_newid();
 var bcrypt = environment_default2.JS_BCRYPT ? require("bcryptjs") : require("bcrypt");
 var SALT_ROUNDS = environment_default2.SALT_ROUNDS || 10;
-async function hash(data) {
+async function hash2(data) {
   const salt = await bcrypt.genSalt(SALT_ROUNDS);
   return bcrypt.hash(data, salt);
 }
@@ -8178,14 +8179,14 @@ function isValidInternalAPIKey(apiKey) {
   }
   return false;
 }
-function getCookie(ctx, name) {
-  const cookie = ctx.cookies.get(name);
+function getCookie(ctx, name2) {
+  const cookie = ctx.cookies.get(name2);
   if (!cookie) {
     return cookie;
   }
   return openJwt(cookie);
 }
-function setCookie(ctx, value, name = "builder", opts = { sign: true }) {
+function setCookie(ctx, value, name2 = "builder", opts = { sign: true }) {
   if (value && opts && opts.sign) {
     value = jwt.sign(value, environment_default2.JWT_SECRET);
   }
@@ -8198,10 +8199,10 @@ function setCookie(ctx, value, name = "builder", opts = { sign: true }) {
   if (environment_default2.COOKIE_DOMAIN) {
     config.domain = environment_default2.COOKIE_DOMAIN;
   }
-  ctx.cookies.set(name, value, config);
+  ctx.cookies.set(name2, value, config);
 }
-function clearCookie(ctx, name) {
-  setCookie(ctx, null, name);
+function clearCookie(ctx, name2) {
+  setCookie(ctx, null, name2);
 }
 function isClient(ctx) {
   return ctx.headers["x-budibase-type" /* TYPE */] === "client";
@@ -8235,8 +8236,8 @@ var InMemoryQueue = class {
    * @param {object|null} opts This is not used by the in memory queue as there is no real use
    * case when in memory, but is the same API as Bull
    */
-  constructor(name, opts = null) {
-    this._name = name;
+  constructor(name2, opts = null) {
+    this._name = name2;
     this._opts = opts;
     this._messages = [];
     this._emitter = new import_events2.default.EventEmitter();
@@ -8669,13 +8670,13 @@ var getInstallFromDB = async () => {
     }
   );
 };
-var updateVersion = async (version) => {
+var updateVersion = async (version2) => {
   try {
     await doWithDB(
       StaticDatabases.PLATFORM_INFO.name,
       async (platformDb) => {
         const install = await getInstall();
-        install.version = version;
+        install.version = version2;
         await platformDb.put(install);
         await bustCache("installation" /* INSTALLATION */);
       }
@@ -8777,13 +8778,13 @@ var identifyInstallationGroup = async (installId, timestamp) => {
   const id = installId;
   const type = "installation" /* INSTALLATION */;
   const hosting = getHostingFromEnv();
-  const version = environment_default2.VERSION;
+  const version2 = environment_default2.VERSION;
   const environment3 = getDeploymentEnvironment();
   const group = {
     id,
     type,
     hosting,
-    version,
+    version: version2,
     environment: environment3
   };
   await identifyGroup(group, timestamp);
@@ -8908,7 +8909,7 @@ var getEventTenantId = async (tenantId) => {
 var getUniqueTenantId = async (tenantId) => {
   return doInTenant(tenantId, () => {
     return withCache("uniqueTenantId" /* UNIQUE_TENANT_ID */, 86400 /* ONE_DAY */, async () => {
-      const db = getGlobalDB();
+      const db2 = getGlobalDB();
       const config = await getSettingsConfigDoc();
       let uniqueTenantId;
       if (config.config.uniqueTenantId) {
@@ -8916,7 +8917,7 @@ var getUniqueTenantId = async (tenantId) => {
       } else {
         uniqueTenantId = `${newid()}_${tenantId}`;
         config.config.uniqueTenantId = uniqueTenantId;
-        await db.put(config);
+        await db2.put(config);
         return uniqueTenantId;
       }
     });
@@ -8956,10 +8957,10 @@ __export(backfill_exports, {
 init_src();
 init_context2();
 var start = async (events2) => {
-  const metadata = {
+  const metadata2 = {
     eventWhitelist: events2
   };
-  return saveBackfillMetadata(metadata);
+  return saveBackfillMetadata(metadata2);
 };
 var recordEvent2 = async (event, properties) => {
   const eventKey2 = getEventKey(event, properties);
@@ -9269,11 +9270,11 @@ var app_default = {
 
 // ../backend-core/src/events/publishers/auth.ts
 init_src();
-async function login(source, email) {
+async function login(source2, email) {
   const identity = await identification_default.getCurrentIdentity();
   const properties = {
     userId: identity.id,
-    source,
+    source: source2,
     audited: {
       email
     }
@@ -10062,9 +10063,9 @@ var view_default = {
 
 // ../backend-core/src/events/publishers/installation.ts
 init_src();
-async function versionChecked(version) {
+async function versionChecked(version2) {
   const properties = {
-    currentVersion: version
+    currentVersion: version2
   };
   await publishEvent("installation:version:checked" /* INSTALLATION_VERSION_CHECKED */, properties);
 }
@@ -10283,13 +10284,13 @@ async function appBackupRestored(backup) {
   };
   await publishEvent("app:backup:restored" /* APP_BACKUP_RESTORED */, properties);
 }
-async function appBackupTriggered(appId, backupId, type, trigger, name) {
+async function appBackupTriggered(appId, backupId, type, trigger, name2) {
   const properties = {
     appId,
     backupId,
     type,
     trigger,
-    name
+    name: name2
   };
   await publishEvent("app:backup:triggered" /* APP_BACKUP_TRIGGERED */, properties);
 }
@@ -10300,16 +10301,16 @@ var backup_default = {
 
 // ../backend-core/src/events/publishers/environmentVariable.ts
 init_src();
-async function created14(name, environments) {
+async function created14(name2, environments) {
   const properties = {
-    name,
+    name: name2,
     environments
   };
   await publishEvent("environment_variable:created" /* ENVIRONMENT_VARIABLE_CREATED */, properties);
 }
-async function deleted14(name) {
+async function deleted14(name2) {
   const properties = {
-    name
+    name: name2
   };
   await publishEvent("environment_variable:deleted" /* ENVIRONMENT_VARIABLE_DELETED */, properties);
 }
@@ -10430,8 +10431,8 @@ function removeUserPassword(users2) {
   return users2;
 }
 var bulkGetGlobalUsersById = async (userIds, opts) => {
-  const db = getGlobalDB();
-  let users2 = (await db.allDocs({
+  const db2 = getGlobalDB();
+  let users2 = (await db2.allDocs({
     keys: userIds,
     include_docs: true
   })).rows.map((row) => row.doc);
@@ -10441,21 +10442,21 @@ var bulkGetGlobalUsersById = async (userIds, opts) => {
   return users2;
 };
 var getAllUserIds = async () => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const startKey = `${"us" /* USER */}${SEPARATOR}`;
-  const response = await db.allDocs({
+  const response = await db2.allDocs({
     startkey: startKey,
     endkey: `${startKey}${UNICODE_MAX}`
   });
   return response.rows.map((row) => row.id);
 };
 var bulkUpdateGlobalUsers = async (users2) => {
-  const db = getGlobalDB();
-  return await db.bulkDocs(users2);
+  const db2 = getGlobalDB();
+  return await db2.bulkDocs(users2);
 };
 async function getById(id, opts) {
-  const db = getGlobalDB();
-  let user = await db.get(id);
+  const db2 = getGlobalDB();
+  let user = await db2.get(id);
   if (opts == null ? void 0 : opts.cleanup) {
     user = removeUserPassword(user);
   }
@@ -10558,7 +10559,7 @@ var paginatedUsers = async ({
   email,
   appId
 } = {}) => {
-  const db = getGlobalDB();
+  const db2 = getGlobalDB();
   const opts = {
     include_docs: true,
     limit: PAGE_LIMIT + 1
@@ -10569,12 +10570,12 @@ var paginatedUsers = async ({
   let userList, property = "_id", getKey;
   if (appId) {
     userList = await searchGlobalUsersByApp(appId, opts);
-    getKey = (doc) => getGlobalUserByAppPage(appId, doc);
+    getKey = (doc2) => getGlobalUserByAppPage(appId, doc2);
   } else if (email) {
     userList = await searchGlobalUsersByEmail(email, opts);
     property = "email";
   } else {
-    const response = await db.allDocs(getGlobalUserParams(null, opts));
+    const response = await db2.allDocs(getGlobalUserParams(null, opts));
     userList = response.rows.map((row) => row.doc);
   }
   return pagination(userList, PAGE_LIMIT, {
@@ -10695,10 +10696,10 @@ var EXTERNAL_BUILTIN_ROLE_IDS = [
   BUILTIN_IDS.PUBLIC
 ];
 var Role2 = class {
-  constructor(id, name, permissionId) {
+  constructor(id, name2, permissionId) {
     this.permissions = {};
     this._id = id;
-    this.name = name;
+    this.name = name2;
     this.permissionId = permissionId;
   }
   addInheritance(inherits) {
@@ -10777,7 +10778,7 @@ function lowerBuiltinRoleID(roleId1, roleId2) {
   }
   return builtinRoleToNumber(roleId1) > builtinRoleToNumber(roleId2) ? roleId2 : roleId1;
 }
-async function getRole(roleId) {
+async function getRole(roleId, opts) {
   if (!roleId) {
     return void 0;
   }
@@ -10788,11 +10789,14 @@ async function getRole(roleId) {
     );
   }
   try {
-    const db = getAppDB();
-    const dbRole = await db.get(getDBRoleID(roleId));
+    const db2 = getAppDB();
+    const dbRole = await db2.get(getDBRoleID(roleId));
     role = Object.assign(role, dbRole);
     role._id = getExternalRoleID(role._id);
   } catch (err) {
+    if (!isBuiltin(roleId) && (opts == null ? void 0 : opts.defaultPublic)) {
+      return cloneDeep2(BUILTIN_ROLES.PUBLIC);
+    }
     if (Object.keys(role).length === 0) {
       throw err;
     }
@@ -10840,10 +10844,10 @@ async function getAllRoles(appId) {
     }
     return internal(appDB);
   }
-  async function internal(db) {
+  async function internal(db2) {
     let roles = [];
-    if (db) {
-      const body2 = await db.allDocs(
+    if (db2) {
+      const body2 = await db2.allDocs(
         getRoleParams(null, {
           include_docs: true
         })
@@ -11279,12 +11283,12 @@ async function syncUser(user, details) {
   if (details.profile) {
     const profile = details.profile;
     if (profile.name) {
-      const name = profile.name;
-      if (name.givenName) {
-        firstName = name.givenName;
+      const name2 = profile.name;
+      if (name2.givenName) {
+        firstName = name2.givenName;
       }
-      if (name.familyName) {
-        lastName = name.familyName;
+      if (name2.familyName) {
+        lastName = name2.familyName;
       }
     }
     pictureUrl = await getProfilePictureUrl(user, details);
@@ -11481,8 +11485,8 @@ async function preAuth(passport2, ctx, next) {
     callbackUrl,
     ssoSaveUserNoOp
   );
-  if (!ctx.query.appId || !ctx.query.datasourceId) {
-    ctx.throw(400, "appId and datasourceId query params not present.");
+  if (!ctx.query.appId) {
+    ctx.throw(400, "appId query param not present.");
   }
   return passport2.authenticate(strategy, {
     scope: ["profile", "email", "https://www.googleapis.com/auth/spreadsheets"],
@@ -11502,7 +11506,7 @@ async function postAuth(passport2, ctx, next) {
         clientSecret: config.clientSecret,
         callbackURL: callbackUrl
       },
-      (accessToken, refreshToken, profile, done) => {
+      (accessToken, refreshToken, _profile, done) => {
         clearCookie(ctx, "budibase:datasourceauth" /* DatasourceAuth */);
         done(null, { accessToken, refreshToken });
       }
@@ -11510,22 +11514,14 @@ async function postAuth(passport2, ctx, next) {
     { successRedirect: "/", failureRedirect: "/error" },
     async (err, tokens) => {
       const baseUrl = `/builder/app/${authStateCookie.appId}/data`;
-      await doWithDB(authStateCookie.appId, async (db) => {
-        let datasource2;
-        try {
-          datasource2 = await db.get(authStateCookie.datasourceId);
-        } catch (err2) {
-          if (err2.status === 404) {
-            ctx.redirect(baseUrl);
-          }
-        }
-        if (!datasource2.config) {
-          datasource2.config = {};
+      const id = newid();
+      await store(
+        `datasource:creation:${authStateCookie.appId}:google:${id}`,
+        {
+          tokens
         }
-        datasource2.config.auth = { type: "google", ...tokens };
-        await db.put(datasource2);
-        ctx.redirect(`${baseUrl}/datasource/${authStateCookie.datasourceId}`);
-      });
+      );
+      ctx.redirect(`${baseUrl}/new?continue_google_setup=${id}`);
     }
   )(ctx, next);
 }
@@ -11575,16 +11571,22 @@ var encryption_exports = {};
 __export(encryption_exports, {
   SecretOption: () => SecretOption,
   decrypt: () => decrypt,
+  decryptFile: () => decryptFile,
   encrypt: () => encrypt,
+  encryptFile: () => encryptFile,
   getSecret: () => getSecret
 });
 var import_crypto = __toESM(require("crypto"));
+var import_fs2 = __toESM(require("fs"));
+var import_zlib = __toESM(require("zlib"));
 init_environment2();
+var import_path2 = require("path");
 var ALGO = "aes-256-ctr";
 var SEPARATOR3 = "-";
 var ITERATIONS = 1e4;
-var RANDOM_BYTES = 16;
 var STRETCH_LENGTH = 32;
+var SALT_LENGTH = 16;
+var IV_LENGTH = 16;
 var SecretOption = /* @__PURE__ */ ((SecretOption2) => {
   SecretOption2["API"] = "api";
   SecretOption2["ENCRYPTION"] = "encryption";
@@ -11608,11 +11610,11 @@ function getSecret(secretOption) {
   }
   return secret;
 }
-function stretchString(string, salt) {
-  return import_crypto.default.pbkdf2Sync(string, salt, ITERATIONS, STRETCH_LENGTH, "sha512");
+function stretchString(secret, salt) {
+  return import_crypto.default.pbkdf2Sync(secret, salt, ITERATIONS, STRETCH_LENGTH, "sha512");
 }
 function encrypt(input, secretOption = "api" /* API */) {
-  const salt = import_crypto.default.randomBytes(RANDOM_BYTES);
+  const salt = import_crypto.default.randomBytes(SALT_LENGTH);
   const stretched = stretchString(getSecret(secretOption), salt);
   const cipher = import_crypto.default.createCipheriv(ALGO, stretched, salt);
   const base = cipher.update(input);
@@ -11629,6 +11631,87 @@ function decrypt(input, secretOption = "api" /* API */) {
   const final = decipher.final();
   return Buffer.concat([base, final]).toString();
 }
+async function encryptFile({ dir, filename }, secret) {
+  const outputFileName = `${filename}.enc`;
+  const filePath = (0, import_path2.join)(dir, filename);
+  const inputFile = import_fs2.default.createReadStream(filePath);
+  const outputFile = import_fs2.default.createWriteStream((0, import_path2.join)(dir, outputFileName));
+  const salt = import_crypto.default.randomBytes(SALT_LENGTH);
+  const iv = import_crypto.default.randomBytes(IV_LENGTH);
+  const stretched = stretchString(secret, salt);
+  const cipher = import_crypto.default.createCipheriv(ALGO, stretched, iv);
+  outputFile.write(salt);
+  outputFile.write(iv);
+  inputFile.pipe(import_zlib.default.createGzip()).pipe(cipher).pipe(outputFile);
+  return new Promise((r) => {
+    outputFile.on("finish", () => {
+      r({
+        filename: outputFileName,
+        dir
+      });
+    });
+  });
+}
+async function getSaltAndIV(path2) {
+  const fileStream = import_fs2.default.createReadStream(path2);
+  const salt = await readBytes(fileStream, SALT_LENGTH);
+  const iv = await readBytes(fileStream, IV_LENGTH);
+  fileStream.close();
+  return { salt, iv };
+}
+async function decryptFile(inputPath, outputPath, secret) {
+  const { salt, iv } = await getSaltAndIV(inputPath);
+  const inputFile = import_fs2.default.createReadStream(inputPath, {
+    start: SALT_LENGTH + IV_LENGTH
+  });
+  const outputFile = import_fs2.default.createWriteStream(outputPath);
+  const stretched = stretchString(secret, salt);
+  const decipher = import_crypto.default.createDecipheriv(ALGO, stretched, iv);
+  const unzip = import_zlib.default.createGunzip();
+  inputFile.pipe(decipher).pipe(unzip).pipe(outputFile);
+  return new Promise((res, rej) => {
+    outputFile.on("finish", () => {
+      outputFile.close();
+      res();
+    });
+    inputFile.on("error", (e) => {
+      outputFile.close();
+      rej(e);
+    });
+    decipher.on("error", (e) => {
+      outputFile.close();
+      rej(e);
+    });
+    unzip.on("error", (e) => {
+      outputFile.close();
+      rej(e);
+    });
+    outputFile.on("error", (e) => {
+      outputFile.close();
+      rej(e);
+    });
+  });
+}
+function readBytes(stream3, length) {
+  return new Promise((resolve3, reject) => {
+    let bytesRead = 0;
+    const data = [];
+    stream3.on("readable", () => {
+      let chunk;
+      while ((chunk = stream3.read(length - bytesRead)) !== null) {
+        data.push(chunk);
+        bytesRead += chunk.length;
+      }
+      resolve3(Buffer.concat(data));
+    });
+    stream3.on("end", () => {
+      reject(new Error("Insufficient data in the stream."));
+    });
+    stream3.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
 
 // ../backend-core/src/middleware/authenticated.ts
 init_identity();
@@ -11720,13 +11803,13 @@ async function checkApiKey(apiKey, populateUser) {
   return doInTenant(tenantId, async () => {
     let userId;
     try {
-      const db = getGlobalDB();
+      const db2 = getGlobalDB();
       userId = await queryGlobalView(
         "by_api_key" /* BY_API_KEY */,
         {
           key: apiKey
         },
-        db
+        db2
       );
     } catch (err) {
       userId = void 0;
@@ -11747,7 +11830,7 @@ function authenticated_default(noAuthPatterns = [], opts = {
   const noAuthOptions = noAuthPatterns ? buildMatcherRegex(noAuthPatterns) : [];
   return async (ctx, next) => {
     let publicEndpoint = false;
-    const version = ctx.request.headers["x-budibase-api-version" /* API_VER */];
+    const version2 = ctx.request.headers["x-budibase-api-version" /* API_VER */];
     const found = matches(ctx, noAuthOptions);
     if (found) {
       publicEndpoint = true;
@@ -11810,7 +11893,7 @@ function authenticated_default(noAuthPatterns = [], opts = {
       if (!authenticated) {
         authenticated = false;
       }
-      finalise(ctx, { authenticated, user, internal, version, publicEndpoint });
+      finalise(ctx, { authenticated, user, internal, version: version2, publicEndpoint });
       if (user && user.email) {
         return doInUserContext(user, ctx, next);
       } else {
@@ -11825,7 +11908,7 @@ function authenticated_default(noAuthPatterns = [], opts = {
         ctx.throw(403, err.message);
       }
       if (opts && opts.publicAllowed || publicEndpoint) {
-        finalise(ctx, { authenticated: false, version, publicEndpoint });
+        finalise(ctx, { authenticated: false, version: version2, publicEndpoint });
         return next();
       } else {
         ctx.throw(err.status || 403, err);
@@ -12182,8 +12265,8 @@ async function updateUserOAuth(userId, oAuthConfig) {
     refreshToken: oAuthConfig.refreshToken
   };
   try {
-    const db = getGlobalDB();
-    const dbUser = await db.get(userId);
+    const db2 = getGlobalDB();
+    const dbUser = await db2.get(userId);
     if (typeof details.refreshToken !== "string") {
       delete details.refreshToken;
     }
@@ -12191,7 +12274,7 @@ async function updateUserOAuth(userId, oAuthConfig) {
       ...dbUser.oauth2,
       ...details
     };
-    await db.put(dbUser);
+    await db2.put(dbUser);
     await invalidateUser(userId);
   } catch (e) {
     console.error("Could not update OAuth details for current user", e);
@@ -12386,16 +12469,16 @@ var import_aws_sdk = __toESM(require("aws-sdk"));
 var import_stream = __toESM(require("stream"));
 var import_node_fetch6 = __toESM(require("node-fetch"));
 var import_tar_fs = __toESM(require("tar-fs"));
-var import_zlib = __toESM(require("zlib"));
+var import_zlib2 = __toESM(require("zlib"));
 var import_util = require("util");
-var import_path3 = require("path");
-var import_fs3 = __toESM(require("fs"));
+var import_path4 = require("path");
+var import_fs4 = __toESM(require("fs"));
 init_environment2();
 
 // ../backend-core/src/objectStore/utils.ts
-var import_path2 = require("path");
+var import_path3 = require("path");
 var import_os = require("os");
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 init_environment2();
 var ObjectStoreBuckets = {
   BACKUPS: environment_default2.BACKUPS_BUCKET_NAME,
@@ -12404,9 +12487,9 @@ var ObjectStoreBuckets = {
   GLOBAL: environment_default2.GLOBAL_BUCKET_NAME,
   PLUGINS: environment_default2.PLUGIN_BUCKET_NAME
 };
-var bbTmp = (0, import_path2.join)((0, import_os.tmpdir)(), ".budibase");
-if (!import_fs2.default.existsSync(bbTmp)) {
-  import_fs2.default.mkdirSync(bbTmp);
+var bbTmp = (0, import_path3.join)((0, import_os.tmpdir)(), ".budibase");
+if (!import_fs3.default.existsSync(bbTmp)) {
+  import_fs3.default.mkdirSync(bbTmp);
 }
 function budibaseTempDir() {
   return bbTmp;
@@ -12491,10 +12574,10 @@ var upload = async ({
   filename,
   path: path2,
   type,
-  metadata
+  metadata: metadata2
 }) => {
   const extension = filename.split(".").pop();
-  const fileBytes = import_fs3.default.readFileSync(path2);
+  const fileBytes = import_fs4.default.readFileSync(path2);
   const objectStore = ObjectStore(bucketName);
   await makeSureBucketExists(objectStore, bucketName);
   let contentType = type;
@@ -12507,13 +12590,13 @@ var upload = async ({
     Body: fileBytes,
     ContentType: contentType
   };
-  if (metadata && typeof metadata === "object") {
-    for (let key of Object.keys(metadata)) {
-      if (!metadata[key] || typeof metadata[key] !== "string") {
-        delete metadata[key];
+  if (metadata2 && typeof metadata2 === "object") {
+    for (let key of Object.keys(metadata2)) {
+      if (!metadata2[key] || typeof metadata2[key] !== "string") {
+        delete metadata2[key];
       }
     }
-    config.Metadata = metadata;
+    config.Metadata = metadata2;
   }
   return objectStore.upload(config).promise();
 };
@@ -12596,13 +12679,13 @@ var retrieveToTmp = async (bucketName, filepath) => {
   bucketName = sanitizeBucket(bucketName);
   filepath = sanitizeKey(filepath);
   const data = await retrieve(bucketName, filepath);
-  const outputPath = (0, import_path3.join)(budibaseTempDir(), (0, import_uuid3.v4)());
-  import_fs3.default.writeFileSync(outputPath, data);
+  const outputPath = (0, import_path4.join)(budibaseTempDir(), (0, import_uuid3.v4)());
+  import_fs4.default.writeFileSync(outputPath, data);
   return outputPath;
 };
 var retrieveDirectory = async (bucketName, path2) => {
-  let writePath = (0, import_path3.join)(budibaseTempDir(), (0, import_uuid3.v4)());
-  import_fs3.default.mkdirSync(writePath);
+  let writePath = (0, import_path4.join)(budibaseTempDir(), (0, import_uuid3.v4)());
+  import_fs4.default.mkdirSync(writePath);
   const objects = await listAllObjects(bucketName, path2);
   let fullObjects = await Promise.all(
     objects.map((obj) => retrieve(bucketName, obj.Key))
@@ -12614,9 +12697,9 @@ var retrieveDirectory = async (bucketName, path2) => {
     const possiblePath = filename.split("/");
     if (possiblePath.length > 1) {
       const dirs = possiblePath.slice(0, possiblePath.length - 1);
-      import_fs3.default.mkdirSync((0, import_path3.join)(writePath, ...dirs), { recursive: true });
+      import_fs4.default.mkdirSync((0, import_path4.join)(writePath, ...dirs), { recursive: true });
     }
-    import_fs3.default.writeFileSync((0, import_path3.join)(writePath, ...possiblePath), data);
+    import_fs4.default.writeFileSync((0, import_path4.join)(writePath, ...possiblePath), data);
   }
   return writePath;
 };
@@ -12667,21 +12750,21 @@ var deleteFolder = async (bucketName, folder) => {
     return deleteFolder(bucketName, folder);
   }
 };
-var uploadDirectory = async (bucketName, localPath, bucketPath) => {
+var uploadDirectory = async (bucketName, localPath, bucketPath2) => {
   bucketName = sanitizeBucket(bucketName);
   let uploads = [];
-  const files = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
-  for (let file of files) {
-    const path2 = sanitizeKey((0, import_path3.join)(bucketPath, file.name));
-    const local = (0, import_path3.join)(localPath, file.name);
+  const files2 = import_fs4.default.readdirSync(localPath, { withFileTypes: true });
+  for (let file of files2) {
+    const path2 = sanitizeKey((0, import_path4.join)(bucketPath2, file.name));
+    const local = (0, import_path4.join)(localPath, file.name);
     if (file.isDirectory()) {
       uploads.push(uploadDirectory(bucketName, local, path2));
     } else {
-      uploads.push(streamUpload(bucketName, path2, import_fs3.default.createReadStream(local)));
+      uploads.push(streamUpload(bucketName, path2, import_fs4.default.createReadStream(local)));
     }
   }
   await Promise.all(uploads);
-  return files;
+  return files2;
 };
 var downloadTarballDirect = async (url, path2, headers = {}) => {
   path2 = sanitizeKey(path2);
@@ -12689,7 +12772,7 @@ var downloadTarballDirect = async (url, path2, headers = {}) => {
   if (!response.ok) {
     throw new Error(`unexpected response ${response.statusText}`);
   }
-  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path2));
+  await streamPipeline(response.body, import_zlib2.default.createUnzip(), import_tar_fs.default.extract(path2));
 };
 var downloadTarball = async (url, bucketName, path2) => {
   bucketName = sanitizeBucket(bucketName);
@@ -12698,8 +12781,8 @@ var downloadTarball = async (url, bucketName, path2) => {
   if (!response.ok) {
     throw new Error(`unexpected response ${response.statusText}`);
   }
-  const tmpPath = (0, import_path3.join)(budibaseTempDir(), path2);
-  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+  const tmpPath = (0, import_path4.join)(budibaseTempDir(), path2);
+  await streamPipeline(response.body, import_zlib2.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
   if (!environment_default2.isTest() && environment_default2.SELF_HOSTED) {
     await uploadDirectory(bucketName, tmpPath, path2);
   }
@@ -12746,12 +12829,12 @@ var getUrl = (s3Key) => {
 };
 
 // ../backend-core/src/objectStore/buckets/app.ts
-var clientLibraryUrl = (appId, version) => {
+var clientLibraryUrl = (appId, version2) => {
   if (environment_default2.isProd()) {
     let file = `${sanitizeKey(appId)}/budibase-client.js`;
     if (environment_default2.CLOUDFRONT_CDN) {
-      if (version) {
-        file += `?v=${version}`;
+      if (version2) {
+        file += `?v=${version2}`;
       }
       return getUrl(file);
     } else {
@@ -12772,8 +12855,8 @@ var getAppFileUrl = (s3Key) => {
 // ../backend-core/src/objectStore/buckets/global.ts
 init_environment2();
 init_context2();
-var getGlobalFileUrl = (type, name, etag) => {
-  let file = getGlobalFileS3Key(type, name);
+var getGlobalFileUrl = (type, name2, etag) => {
+  let file = getGlobalFileS3Key(type, name2);
   if (environment_default2.CLOUDFRONT_CDN) {
     if (etag) {
       file = `${file}?etag=${etag}`;
@@ -12783,8 +12866,8 @@ var getGlobalFileUrl = (type, name, etag) => {
     return getPresignedUrl(environment_default2.GLOBAL_BUCKET_NAME, file);
   }
 };
-var getGlobalFileS3Key = (type, name) => {
-  let file = `${type}/${name}`;
+var getGlobalFileS3Key = (type, name2) => {
+  let file = `${type}/${name2}`;
   if (environment_default2.MULTI_TENANCY) {
     const tenantId = getTenantId();
     file = `${tenantId}/${file}`;
@@ -12827,11 +12910,11 @@ var getPluginJSKey = (plugin) => {
   return getPluginS3Key(plugin, "plugin.min.js");
 };
 var getPluginIconKey = (plugin) => {
-  const iconFileName = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
-  if (!iconFileName) {
+  const iconFileName2 = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
+  if (!iconFileName2) {
     return;
   }
-  return getPluginS3Key(plugin, iconFileName);
+  return getPluginS3Key(plugin, iconFileName2);
 };
 var getPluginS3Key = (plugin, fileName) => {
   const s3Key = getPluginS3Dir(plugin.name);
@@ -13384,18 +13467,18 @@ function finaliseExternalTables(tables, entities) {
   let finalTables = {};
   const errors = {};
   const tableIds = Object.values(tables).map((table) => table._id);
-  for (let [name, table] of Object.entries(tables)) {
+  for (let [name2, table] of Object.entries(tables)) {
     const schemaFields = Object.keys(table.schema);
     if (table.primary == null || table.primary.length === 0) {
-      errors[name] = "no_key" /* NO_KEY */;
+      errors[name2] = "no_key" /* NO_KEY */;
       continue;
     } else if (schemaFields.find(
       (field) => invalidColumns.includes(field)
     )) {
-      errors[name] = "invalid_column" /* INVALID_COLUMN */;
+      errors[name2] = "invalid_column" /* INVALID_COLUMN */;
       continue;
     }
-    finalTables[name] = copyExistingPropsOver(name, table, entities, tableIds);
+    finalTables[name2] = copyExistingPropsOver(name2, table, entities, tableIds);
   }
   finalTables = Object.entries(finalTables).sort(([a], [b]) => a.localeCompare(b)).reduce((r, [k, v]) => ({ ...r, [k]: v }), {});
   return { tables: finalTables, errors };
@@ -14355,7 +14438,8 @@ var PostgresIntegration = class extends sql_default {
     try {
       await this.openConnection();
       const columnsResponse = await this.client.query(this.COLUMNS_SQL);
-      return columnsResponse.rows.map((row) => row.table_name);
+      const names = columnsResponse.rows.map((row) => row.table_name);
+      return [...new Set(names)];
     } finally {
       await this.closeConnection();
     }
@@ -14968,6 +15052,8 @@ var MongoIntegration = class {
       response.connected = true;
     } catch (e) {
       response.error = e.message;
+    } finally {
+      await this.client.close();
     }
     return response;
   }
@@ -15040,8 +15126,8 @@ var MongoIntegration = class {
   async create(query) {
     try {
       await this.connect();
-      const db = this.client.db(this.config.db);
-      const collection = db.collection(query.extra.collection);
+      const db2 = this.client.db(this.config.db);
+      const collection = db2.collection(query.extra.collection);
       let json = this.createObjectIds(query.json);
       switch (query.extra.actionType) {
         case "insertOne": {
@@ -15066,8 +15152,8 @@ var MongoIntegration = class {
   async read(query) {
     try {
       await this.connect();
-      const db = this.client.db(this.config.db);
-      const collection = db.collection(query.extra.collection);
+      const db2 = this.client.db(this.config.db);
+      const collection = db2.collection(query.extra.collection);
       let json = this.createObjectIds(query.json);
       switch (query.extra.actionType) {
         case "find": {
@@ -15109,8 +15195,8 @@ var MongoIntegration = class {
   async update(query) {
     try {
       await this.connect();
-      const db = this.client.db(this.config.db);
-      const collection = db.collection(query.extra.collection);
+      const db2 = this.client.db(this.config.db);
+      const collection = db2.collection(query.extra.collection);
       let queryJson = query.json;
       if (typeof queryJson === "string") {
         queryJson = this.parseQueryParams(queryJson, "update");
@@ -15147,8 +15233,8 @@ var MongoIntegration = class {
   async delete(query) {
     try {
       await this.connect();
-      const db = this.client.db(this.config.db);
-      const collection = db.collection(query.extra.collection);
+      const db2 = this.client.db(this.config.db);
+      const collection = db2.collection(query.extra.collection);
       let queryJson = query.json;
       if (typeof queryJson === "string") {
         queryJson = this.parseQueryParams(queryJson, "delete");
@@ -15184,25 +15270,25 @@ var MongoIntegration = class {
     var _a;
     try {
       await this.connect();
-      const db = this.client.db(this.config.db);
-      const collection = db.collection(query.extra.collection);
+      const db2 = this.client.db(this.config.db);
+      const collection = db2.collection(query.extra.collection);
       let response = [];
       if (((_a = query.extra) == null ? void 0 : _a.actionType) === "pipeline") {
-        for await (const doc of collection.aggregate(
+        for await (const doc2 of collection.aggregate(
           query.steps.map(({ key, value }) => {
             let temp = {};
             temp[key] = JSON.parse(value.value);
             return this.createObjectIds(temp);
           })
         )) {
-          response.push(doc);
+          response.push(doc2);
         }
       } else {
         const stages = query.json;
-        for await (const doc of collection.aggregate(
+        for await (const doc2 of collection.aggregate(
           stages ? this.createObjectIds(stages) : []
         )) {
-          response.push(doc);
+          response.push(doc2);
         }
       }
       return response;
@@ -15502,9 +15588,9 @@ var CouchDBIntegration = class {
     });
   }
   async delete(query) {
-    const doc = await this.query("get", "Cannot find doc to be deleted", query);
+    const doc2 = await this.query("get", "Cannot find doc to be deleted", query);
     return this.query("remove", "Error deleting couchDB document", {
-      json: doc
+      json: doc2
     });
   }
 };
@@ -15683,7 +15769,7 @@ var SqlServerIntegration = class extends sql_default {
       throw "Unable to get list of tables in database";
     }
     const schema = this.config.schema || DEFAULT_SCHEMA;
-    const tableNames = tableInfo.filter((record) => record.TABLE_SCHEMA === schema).map((record) => record.TABLE_NAME).filter((name) => this.MASTER_TABLES.indexOf(name) === -1);
+    const tableNames = tableInfo.filter((record) => record.TABLE_SCHEMA === schema).map((record) => record.TABLE_NAME).filter((name2) => this.MASTER_TABLES.indexOf(name2) === -1);
     const tables = {};
     for (let tableName of tableNames) {
       const definition = await this.runSQL(this.getDefinitionSQL(tableName));
@@ -15698,16 +15784,16 @@ var SqlServerIntegration = class extends sql_default {
       const requiredColumns = columns.filter((col) => col.IS_NULLABLE === "NO").map((col) => col.COLUMN_NAME);
       let schema2 = {};
       for (let def of definition) {
-        const name = def.COLUMN_NAME;
-        if (typeof name !== "string") {
+        const name2 = def.COLUMN_NAME;
+        if (typeof name2 !== "string") {
           continue;
         }
         const hasDefault = def.COLUMN_DEFAULT;
-        const isAuto = !!autoColumns.find((col) => col === name);
-        const required = !!requiredColumns.find((col) => col === name);
-        schema2[name] = {
+        const isAuto = !!autoColumns.find((col) => col === name2);
+        const required = !!requiredColumns.find((col) => col === name2);
+        schema2[name2] = {
           autocolumn: isAuto,
-          name,
+          name: name2,
           constraints: {
             presence: required && !isAuto && !hasDefault
           },
@@ -15729,7 +15815,7 @@ var SqlServerIntegration = class extends sql_default {
   async queryTableNames() {
     let tableInfo = await this.runSQL(this.TABLES_SQL);
     const schema = this.config.schema || DEFAULT_SCHEMA;
-    return tableInfo.filter((record) => record.TABLE_SCHEMA === schema).map((record) => record.TABLE_NAME).filter((name) => this.MASTER_TABLES.indexOf(name) === -1);
+    return tableInfo.filter((record) => record.TABLE_SCHEMA === schema).map((record) => record.TABLE_NAME).filter((name2) => this.MASTER_TABLES.indexOf(name2) === -1);
   }
   async getTableNames() {
     await this.connect();
@@ -17119,11 +17205,11 @@ var runLuceneQuery = (docs, query) => {
     return docs;
   }
   query = cleanupQuery(query);
-  const match = (type, failFn) => (doc) => {
+  const match = (type, failFn) => (doc2) => {
     const filters = Object.entries(query[type] || {});
     for (let i = 0; i < filters.length; i++) {
       const [key, testValue] = filters[i];
-      const docValue = deepGet(doc, removeKeyNumbering2(key));
+      const docValue = deepGet(doc2, removeKeyNumbering2(key));
       if (failFn(docValue, testValue)) {
         return false;
       }
@@ -17184,8 +17270,8 @@ var runLuceneQuery = (docs, query) => {
       return testValue == null ? void 0 : testValue.every((item) => docValue == null ? void 0 : docValue.includes(item));
     }
   );
-  const docMatch = (doc) => {
-    return stringMatch(doc) && fuzzyMatch(doc) && rangeMatch(doc) && equalMatch(doc) && notEqualMatch(doc) && emptyMatch(doc) && notEmptyMatch(doc) && oneOf(doc) && contains(doc) && containsAny(doc) && notContains(doc);
+  const docMatch = (doc2) => {
+    return stringMatch(doc2) && fuzzyMatch(doc2) && rangeMatch(doc2) && equalMatch(doc2) && notEqualMatch(doc2) && emptyMatch(doc2) && notEmptyMatch(doc2) && oneOf(doc2) && contains(doc2) && containsAny(doc2) && notContains(doc2);
   };
   return docs.filter(docMatch);
 };
@@ -17230,11 +17316,39 @@ var hasFilters = (query) => {
 // ../shared-core/src/utils.ts
 var utils_exports3 = {};
 __export(utils_exports3, {
+  parallelForeach: () => parallelForeach,
   unreachable: () => unreachable
 });
 function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
   throw new Error(message);
 }
+async function parallelForeach(items, task, maxConcurrency) {
+  const promises = [];
+  let index2 = 0;
+  const processItem = async (item) => {
+    try {
+      await task(item);
+    } finally {
+      processNext();
+    }
+  };
+  const processNext = () => {
+    if (index2 >= items.length) {
+      return;
+    }
+    const item = items[index2];
+    index2++;
+    const promise = processItem(item);
+    promises.push(promise);
+    if (promises.length >= maxConcurrency) {
+      Promise.race(promises).then(processNext);
+    } else {
+      processNext();
+    }
+  };
+  processNext();
+  await Promise.all(promises);
+}
 
 // src/integrations/googlesheets.ts
 var ALLOWED_TYPES = [
@@ -17263,7 +17377,7 @@ var SCHEMA12 = {
   },
   datasource: {
     spreadsheetId: {
-      display: "Google Sheet URL",
+      display: "Spreadsheet URL",
       type: "string" /* STRING */,
       required: true
     }
@@ -17384,6 +17498,7 @@ var GoogleSheetsIntegration = class {
   async connect() {
     var _a;
     try {
+      await setupCreationAuth(this.config);
       let googleConfig = await configs_exports.getGoogleDatasourceConfig();
       if (!googleConfig) {
         throw new HTTPError("Google config not found", 400);
@@ -17434,21 +17549,22 @@ var GoogleSheetsIntegration = class {
     return table;
   }
   async buildSchema(datasourceId, entities) {
-    if (!this.config.auth) {
-      return;
-    }
     await this.connect();
     const sheets = this.client.sheetsByIndex;
     const tables = {};
-    for (let sheet of sheets) {
-      await sheet.getRows();
-      const id = buildExternalTableId(datasourceId, sheet.title);
-      tables[sheet.title] = this.getTableSchema(
-        sheet.title,
-        sheet.headerValues,
-        id
-      );
-    }
+    await utils_exports3.parallelForeach(
+      sheets,
+      async (sheet) => {
+        await sheet.getRows({ limit: 0, offset: 0 });
+        const id = buildExternalTableId(datasourceId, sheet.title);
+        tables[sheet.title] = this.getTableSchema(
+          sheet.title,
+          sheet.headerValues,
+          id
+        );
+      },
+      10
+    );
     const final = finaliseExternalTables(tables, entities);
     this.tables = final.tables;
     this.schemaErrors = final.errors;
@@ -17496,13 +17612,13 @@ var GoogleSheetsIntegration = class {
     }
     return rowObject;
   }
-  async createTable(name) {
-    if (!name) {
+  async createTable(name2) {
+    if (!name2) {
       throw new Error("Must provide name for new sheet.");
     }
     try {
       await this.connect();
-      return await this.client.addSheet({ title: name, headerValues: [name] });
+      return await this.client.addSheet({ title: name2, headerValues: [name2] });
     } catch (err) {
       console.error("Error creating new table in google sheets", err);
       throw err;
@@ -17694,6 +17810,16 @@ var GoogleSheetsIntegration = class {
     }
   }
 };
+async function setupCreationAuth(datasouce) {
+  if (datasouce.continueSetupId) {
+    const appId = context_exports.getAppId();
+    const tokens = await cache_exports.get(
+      `datasource:creation:${appId}:google:${datasouce.continueSetupId}`
+    );
+    datasouce.auth = tokens.tokens;
+    delete datasouce.continueSetupId;
+  }
+}
 var googlesheets_default = {
   schema: SCHEMA12,
   integration: GoogleSheetsIntegration
@@ -17823,7 +17949,7 @@ var FirebaseIntegration = class {
         snapshot = await collectionRef.get();
       }
       const result = [];
-      snapshot.forEach((doc) => result.push(doc.data()));
+      snapshot.forEach((doc2) => result.push(doc2.data()));
       return result;
     } catch (err) {
       console.error("Error querying Firestore", err);
@@ -18472,24 +18598,24 @@ init_src();
 var budibaseTempDir2 = objectStore_exports2.budibaseTempDir;
 
 // src/utilities/fileSystem/app.ts
-var import_path5 = require("path");
+var import_path6 = require("path");
 
 // src/utilities/fileSystem/filesystem.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path4 = require("path");
+var import_fs5 = __toESM(require("fs"));
+var import_path5 = require("path");
 var import_tar = __toESM(require("tar"));
 var uuid2 = require("uuid/v4");
-var TOP_LEVEL_PATH = environment_default.TOP_LEVEL_PATH || (0, import_path4.resolve)((0, import_path4.join)(__dirname, "..", "..", ".."));
+var TOP_LEVEL_PATH = environment_default.TOP_LEVEL_PATH || (0, import_path5.resolve)((0, import_path5.join)(__dirname, "..", "..", ".."));
 var streamFile = (path2) => {
-  return import_fs4.default.createReadStream(path2);
+  return import_fs5.default.createReadStream(path2);
 };
 var createTempFolder = (item) => {
-  const path2 = (0, import_path4.join)(budibaseTempDir2(), item);
+  const path2 = (0, import_path5.join)(budibaseTempDir2(), item);
   try {
-    if (import_fs4.default.existsSync(path2)) {
-      import_fs4.default.rmSync(path2, { recursive: true, force: true });
+    if (import_fs5.default.existsSync(path2)) {
+      import_fs5.default.rmSync(path2, { recursive: true, force: true });
     }
-    import_fs4.default.mkdirSync(path2);
+    import_fs5.default.mkdirSync(path2);
   } catch (err) {
     throw new Error(`Path cannot be created: ${err.message}`);
   }
@@ -18503,21 +18629,21 @@ var extractTarball = async (fromFilePath, toPath) => {
 };
 
 // src/utilities/fileSystem/app.ts
-var NODE_MODULES_PATH = (0, import_path5.join)(TOP_LEVEL_PATH, "node_modules");
+var NODE_MODULES_PATH = (0, import_path6.join)(TOP_LEVEL_PATH, "node_modules");
 
 // src/utilities/fileSystem/plugin.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path6 = require("path");
-var DATASOURCE_PATH = (0, import_path6.join)(budibaseTempDir2(), "datasource");
-var AUTOMATION_PATH = (0, import_path6.join)(budibaseTempDir2(), "automation");
+var import_fs6 = __toESM(require("fs"));
+var import_path7 = require("path");
+var DATASOURCE_PATH = (0, import_path7.join)(budibaseTempDir2(), "datasource");
+var AUTOMATION_PATH = (0, import_path7.join)(budibaseTempDir2(), "automation");
 var getPluginMetadata = async (path2) => {
-  let metadata = {};
+  let metadata2 = {};
   try {
-    const pkg2 = import_fs5.default.readFileSync((0, import_path6.join)(path2, "package.json"), "utf8");
-    const schema = import_fs5.default.readFileSync((0, import_path6.join)(path2, "schema.json"), "utf8");
-    metadata.schema = JSON.parse(schema);
-    metadata.package = JSON.parse(pkg2);
-    if (!metadata.package.name || !metadata.package.version || !metadata.package.description) {
+    const pkg2 = import_fs6.default.readFileSync((0, import_path7.join)(path2, "package.json"), "utf8");
+    const schema = import_fs6.default.readFileSync((0, import_path7.join)(path2, "schema.json"), "utf8");
+    metadata2.schema = JSON.parse(schema);
+    metadata2.package = JSON.parse(pkg2);
+    if (!metadata2.package.name || !metadata2.package.version || !metadata2.package.description) {
       throw new Error(
         "package.json is missing one of 'name', 'version' or 'description'."
       );
@@ -18527,24 +18653,24 @@ var getPluginMetadata = async (path2) => {
       `Unable to process schema.json/package.json in plugin. ${err.message}`
     );
   }
-  return { metadata, directory: path2 };
+  return { metadata: metadata2, directory: path2 };
 };
 async function getPluginImpl(path2, plugin) {
   var _a;
-  const hash2 = (_a = plugin.schema) == null ? void 0 : _a.hash;
-  if (!import_fs5.default.existsSync(path2)) {
-    import_fs5.default.mkdirSync(path2);
+  const hash3 = (_a = plugin.schema) == null ? void 0 : _a.hash;
+  if (!import_fs6.default.existsSync(path2)) {
+    import_fs6.default.mkdirSync(path2);
   }
-  const filename = (0, import_path6.join)(path2, plugin.name);
+  const filename = (0, import_path7.join)(path2, plugin.name);
   const metadataName = `${filename}.bbmetadata`;
-  if (import_fs5.default.existsSync(filename)) {
-    const currentHash = import_fs5.default.readFileSync(metadataName, "utf8");
-    if (currentHash === hash2) {
+  if (import_fs6.default.existsSync(filename)) {
+    const currentHash = import_fs6.default.readFileSync(metadataName, "utf8");
+    if (currentHash === hash3) {
       return require(filename);
     } else {
       console.log(`Updating plugin: ${plugin.name}`);
       delete require.cache[require.resolve(filename)];
-      import_fs5.default.unlinkSync(filename);
+      import_fs6.default.unlinkSync(filename);
     }
   }
   const pluginKey = objectStore_exports2.getPluginJSKey(plugin);
@@ -18552,8 +18678,8 @@ async function getPluginImpl(path2, plugin) {
     objectStore_exports2.ObjectStoreBuckets.PLUGINS,
     pluginKey
   );
-  import_fs5.default.writeFileSync(filename, pluginJs);
-  import_fs5.default.writeFileSync(metadataName, hash2);
+  import_fs6.default.writeFileSync(filename, pluginJs);
+  import_fs6.default.writeFileSync(metadataName, hash3);
   return require(filename);
 }
 var getDatasourcePlugin = async (plugin) => {
@@ -18561,9 +18687,9 @@ var getDatasourcePlugin = async (plugin) => {
 };
 
 // src/utilities/fileSystem/template.ts
-var downloadTemplate = async (type, name) => {
+var downloadTemplate = async (type, name2) => {
   const DEFAULT_TEMPLATES_BUCKET = "prod-budi-templates.s3-eu-west-1.amazonaws.com";
-  const templateUrl = `https://${DEFAULT_TEMPLATES_BUCKET}/templates/${type}/${name}.tar.gz`;
+  const templateUrl = `https://${DEFAULT_TEMPLATES_BUCKET}/templates/${type}/${name2}.tar.gz`;
   return objectStore_exports2.downloadTarball(
     templateUrl,
     ObjectStoreBuckets2.TEMPLATES,
@@ -18588,22 +18714,23 @@ var GLOBAL_DB_EXPORT_FILE = "global.txt";
 var STATIC_APP_FILES = ["manifest.json", "budibase-client.js"];
 
 // src/sdk/app/backups/exports.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path7 = require("path");
+var import_fs7 = __toESM(require("fs"));
+var import_path8 = require("path");
+var import_tar2 = __toESM(require("tar"));
 var uuid3 = require("uuid/v4");
-var tar3 = require("tar");
 var MemoryStream = require("memorystream");
-function tarFilesToTmp(tmpDir, files) {
-  const exportFile = (0, import_path7.join)(budibaseTempDir2(), `${uuid3()}.tar.gz`);
-  tar3.create(
+function tarFilesToTmp(tmpDir, files2) {
+  const fileName = `${uuid3()}.tar.gz`;
+  const exportFile = (0, import_path8.join)(budibaseTempDir2(), fileName);
+  import_tar2.default.create(
     {
       sync: true,
       gzip: true,
       file: exportFile,
-      recursive: true,
+      noDirRecurse: false,
       cwd: tmpDir
     },
-    files
+    files2
   );
   return exportFile;
 }
@@ -18614,11 +18741,11 @@ async function exportDB(dbName, opts = {}) {
     batch_limit: 5,
     style: "main_only"
   };
-  return db_exports.doWithDB(dbName, async (db) => {
+  return db_exports.doWithDB(dbName, async (db2) => {
     if (opts == null ? void 0 : opts.exportPath) {
       const path2 = opts == null ? void 0 : opts.exportPath;
-      const writeStream = import_fs6.default.createWriteStream(path2);
-      await db.dump(writeStream, exportOpts);
+      const writeStream = import_fs7.default.createWriteStream(path2);
+      await db2.dump(writeStream, exportOpts);
       return path2;
     } else {
       const memStream = new MemoryStream();
@@ -18626,7 +18753,7 @@ async function exportDB(dbName, opts = {}) {
       memStream.on("data", (chunk) => {
         appString += chunk.toString();
       });
-      await db.dump(memStream, exportOpts);
+      await db2.dump(memStream, exportOpts);
       return appString;
     }
   });
@@ -18639,7 +18766,7 @@ function defineFilter(excludeRows, excludeLogs) {
   if (excludeLogs) {
     ids.push(AUTOMATION_LOG_PREFIX);
   }
-  return (doc) => !ids.map((key) => doc._id.includes(key)).reduce((prev, curr) => prev || curr);
+  return (doc2) => !ids.map((key) => doc2._id.includes(key)).reduce((prev, curr) => prev || curr);
 }
 async function exportApp(appId, config) {
   const prodAppId = db_exports.getProdAppID(appId);
@@ -18650,9 +18777,9 @@ async function exportApp(appId, config) {
       for (let path2 of STATIC_APP_FILES) {
         const contents = await objectStore_exports2.retrieve(
           ObjectStoreBuckets2.APPS,
-          (0, import_path7.join)(appPath, path2)
+          (0, import_path8.join)(appPath, path2)
         );
-        import_fs6.default.writeFileSync((0, import_path7.join)(tmpPath, path2), contents);
+        import_fs7.default.writeFileSync((0, import_path8.join)(tmpPath, path2), contents);
       }
     } else {
       tmpPath = await objectStore_exports2.retrieveDirectory(
@@ -18661,33 +18788,48 @@ async function exportApp(appId, config) {
       );
     }
   }
-  const downloadedPath = (0, import_path7.join)(tmpPath, appPath);
-  if (import_fs6.default.existsSync(downloadedPath)) {
-    const allFiles = import_fs6.default.readdirSync(downloadedPath);
+  const downloadedPath = (0, import_path8.join)(tmpPath, appPath);
+  if (import_fs7.default.existsSync(downloadedPath)) {
+    const allFiles = import_fs7.default.readdirSync(downloadedPath);
     for (let file of allFiles) {
-      const path2 = (0, import_path7.join)(downloadedPath, file);
-      import_fs6.default.renameSync(path2, (0, import_path7.join)(downloadedPath, "..", file));
+      const path2 = (0, import_path8.join)(downloadedPath, file);
+      import_fs7.default.renameSync(path2, (0, import_path8.join)(downloadedPath, "..", file));
     }
-    import_fs6.default.rmdirSync(downloadedPath);
+    import_fs7.default.rmdirSync(downloadedPath);
   }
-  const dbPath = (0, import_path7.join)(tmpPath, DB_EXPORT_FILE);
+  const dbPath = (0, import_path8.join)(tmpPath, DB_EXPORT_FILE);
   await exportDB(appId, {
     filter: defineFilter(config == null ? void 0 : config.excludeRows, config == null ? void 0 : config.excludeLogs),
     exportPath: dbPath
   });
+  if (config == null ? void 0 : config.encryptPassword) {
+    for (let file of import_fs7.default.readdirSync(tmpPath)) {
+      const path2 = (0, import_path8.join)(tmpPath, file);
+      await encryption_exports.encryptFile(
+        { dir: tmpPath, filename: file },
+        config.encryptPassword
+      );
+      import_fs7.default.rmSync(path2);
+    }
+  }
   if (config == null ? void 0 : config.tar) {
-    const tarPath = tarFilesToTmp(tmpPath, import_fs6.default.readdirSync(tmpPath));
-    import_fs6.default.rmSync(tmpPath, { recursive: true, force: true });
+    const tarPath = tarFilesToTmp(tmpPath, import_fs7.default.readdirSync(tmpPath));
+    import_fs7.default.rmSync(tmpPath, { recursive: true, force: true });
     return tarPath;
   } else {
     return tmpPath;
   }
 }
-async function streamExportApp(appId, excludeRows) {
+async function streamExportApp({
+  appId,
+  excludeRows,
+  encryptPassword
+}) {
   const tmpPath = await exportApp(appId, {
     excludeRows,
     excludeLogs: true,
-    tar: true
+    tar: true,
+    encryptPassword
   });
   return streamFile(tmpPath);
 }
@@ -18701,8 +18843,8 @@ __export(imports_exports, {
   untarFile: () => untarFile,
   updateAttachmentColumns: () => updateAttachmentColumns
 });
-var import_path8 = require("path");
-var import_fs7 = __toESM(require("fs"));
+var import_path9 = require("path");
+var import_fs8 = __toESM(require("fs"));
 init_src();
 var uuid4 = require("uuid/v4");
 var tar4 = require("tar");
@@ -18718,12 +18860,12 @@ function rewriteAttachmentUrl(appId, attachment) {
     // calculated on retrieval using key
   };
 }
-async function updateAttachmentColumns(prodAppId, db) {
-  const tables = await sdk_default.tables.getAllInternalTables(db);
+async function updateAttachmentColumns(prodAppId, db2) {
+  const tables = await sdk_default.tables.getAllInternalTables(db2);
   let updatedRows = [];
   for (let table of tables) {
     const { rows: rows2, columns } = await sdk_default.rows.getRowsWithAttachments(
-      db.name,
+      db2.name,
       table
     );
     updatedRows = updatedRows.concat(
@@ -18739,11 +18881,11 @@ async function updateAttachmentColumns(prodAppId, db) {
       })
     );
   }
-  await db.bulkDocs(updatedRows);
+  await db2.bulkDocs(updatedRows);
 }
-async function updateAutomations(prodAppId, db) {
+async function updateAutomations(prodAppId, db2) {
   var _a;
-  const automations2 = (await db.allDocs(
+  const automations2 = (await db2.allDocs(
     getAutomationParams(null, {
       include_docs: true
     })
@@ -18762,23 +18904,23 @@ async function updateAutomations(prodAppId, db) {
     automation.appId = devAppId;
     toSave.push(automation);
   }
-  await db.bulkDocs(toSave);
+  await db2.bulkDocs(toSave);
 }
 async function getTemplateStream(template) {
   if (template.file && template.file.type !== "text/plain") {
     throw new Error("Cannot import a non-text based file.");
   }
   if (template.file) {
-    return import_fs7.default.createReadStream(template.file.path);
+    return import_fs8.default.createReadStream(template.file.path);
   } else if (template.key) {
-    const [type, name] = template.key.split("/");
-    const tmpPath = await downloadTemplate(type, name);
-    return import_fs7.default.createReadStream((0, import_path8.join)(tmpPath, name, "db", "dump.txt"));
+    const [type, name2] = template.key.split("/");
+    const tmpPath = await downloadTemplate(type, name2);
+    return import_fs8.default.createReadStream((0, import_path9.join)(tmpPath, name2, "db", "dump.txt"));
   }
 }
 function untarFile(file) {
-  const tmpPath = (0, import_path8.join)(budibaseTempDir2(), uuid4());
-  import_fs7.default.mkdirSync(tmpPath);
+  const tmpPath = (0, import_path9.join)(budibaseTempDir2(), uuid4());
+  import_fs8.default.mkdirSync(tmpPath);
   tar4.extract({
     sync: true,
     cwd: tmpPath,
@@ -18786,31 +18928,49 @@ function untarFile(file) {
   });
   return tmpPath;
 }
+async function decryptFiles(path2, password) {
+  try {
+    for (let file of import_fs8.default.readdirSync(path2)) {
+      const inputPath = (0, import_path9.join)(path2, file);
+      const outputPath = inputPath.replace(/\.enc$/, "");
+      await encryption_exports.decryptFile(inputPath, outputPath, password);
+      import_fs8.default.rmSync(inputPath);
+    }
+  } catch (err) {
+    if (err.message === "incorrect header check") {
+      throw new Error("File cannot be imported");
+    }
+    throw err;
+  }
+}
 function getGlobalDBFile(tmpPath) {
-  return import_fs7.default.readFileSync((0, import_path8.join)(tmpPath, GLOBAL_DB_EXPORT_FILE), "utf8");
+  return import_fs8.default.readFileSync((0, import_path9.join)(tmpPath, GLOBAL_DB_EXPORT_FILE), "utf8");
 }
 function getListOfAppsInMulti(tmpPath) {
-  return import_fs7.default.readdirSync(tmpPath).filter((dir) => dir !== GLOBAL_DB_EXPORT_FILE);
+  return import_fs8.default.readdirSync(tmpPath).filter((dir) => dir !== GLOBAL_DB_EXPORT_FILE);
 }
-async function importApp(appId, db, template) {
+async function importApp(appId, db2, template) {
   var _a, _b;
   let prodAppId = db_exports.getProdAppID(appId);
   let dbStream;
   const isTar = template.file && ((_b = (_a = template == null ? void 0 : template.file) == null ? void 0 : _a.type) == null ? void 0 : _b.endsWith("gzip"));
-  const isDirectory = template.file && import_fs7.default.lstatSync(template.file.path).isDirectory();
+  const isDirectory = template.file && import_fs8.default.lstatSync(template.file.path).isDirectory();
   if (template.file && (isTar || isDirectory)) {
     const tmpPath = isTar ? untarFile(template.file) : template.file.path;
-    const contents = import_fs7.default.readdirSync(tmpPath);
+    if (isTar && template.file.password) {
+      await decryptFiles(tmpPath, template.file.password);
+    }
+    const contents = import_fs8.default.readdirSync(tmpPath);
     if (contents.length) {
       let promises = [];
       let excludedFiles = [GLOBAL_DB_EXPORT_FILE, DB_EXPORT_FILE];
       for (let filename of contents) {
-        const path2 = (0, import_path8.join)(tmpPath, filename);
+        const path2 = (0, import_path9.join)(tmpPath, filename);
         if (excludedFiles.includes(filename)) {
           continue;
         }
-        filename = (0, import_path8.join)(prodAppId, filename);
-        if (import_fs7.default.lstatSync(path2).isDirectory()) {
+        filename = (0, import_path9.join)(prodAppId, filename);
+        if (import_fs8.default.lstatSync(path2).isDirectory()) {
           promises.push(
             objectStore_exports2.uploadDirectory(ObjectStoreBuckets2.APPS, path2, filename)
           );
@@ -18826,16 +18986,16 @@ async function importApp(appId, db, template) {
       }
       await Promise.all(promises);
     }
-    dbStream = import_fs7.default.createReadStream((0, import_path8.join)(tmpPath, DB_EXPORT_FILE));
+    dbStream = import_fs8.default.createReadStream((0, import_path9.join)(tmpPath, DB_EXPORT_FILE));
   } else {
     dbStream = await getTemplateStream(template);
   }
-  const { ok } = await db.load(dbStream);
+  const { ok } = await db2.load(dbStream);
   if (!ok) {
     throw "Error loading database dump from template.";
   }
-  await updateAttachmentColumns(prodAppId, db);
-  await updateAutomations(prodAppId, db);
+  await updateAttachmentColumns(prodAppId, db2);
+  await updateAutomations(prodAppId, db2);
   return ok;
 }
 
@@ -18847,54 +19007,54 @@ __export(statistics_exports, {
   calculateDatasourceCount: () => calculateDatasourceCount,
   calculateScreenCount: () => calculateScreenCount
 });
-async function runInContext(appId, cb, db) {
-  if (db) {
-    return cb(db);
+async function runInContext(appId, cb, db2) {
+  if (db2) {
+    return cb(db2);
   } else {
     const devAppId = db_exports.getDevAppID(appId);
     return context_exports.doInAppContext(devAppId, () => {
-      const db2 = context_exports.getAppDB();
-      return cb(db2);
+      const db3 = context_exports.getAppDB();
+      return cb(db3);
     });
   }
 }
-async function calculateDatasourceCount(appId, db) {
+async function calculateDatasourceCount(appId, db2) {
   return runInContext(
     appId,
-    async (db2) => {
-      const datasourceList = await db2.allDocs(getDatasourceParams());
-      const tableList = await db2.allDocs(getTableParams());
+    async (db3) => {
+      const datasourceList = await db3.allDocs(getDatasourceParams());
+      const tableList = await db3.allDocs(getTableParams());
       return datasourceList.rows.length + tableList.rows.length;
     },
-    db
+    db2
   );
 }
-async function calculateAutomationCount(appId, db) {
+async function calculateAutomationCount(appId, db2) {
   return runInContext(
     appId,
-    async (db2) => {
-      const automationList = await db2.allDocs(getAutomationParams());
+    async (db3) => {
+      const automationList = await db3.allDocs(getAutomationParams());
       return automationList.rows.length;
     },
-    db
+    db2
   );
 }
-async function calculateScreenCount(appId, db) {
+async function calculateScreenCount(appId, db2) {
   return runInContext(
     appId,
-    async (db2) => {
-      const screenList = await db2.allDocs(getScreenParams());
+    async (db3) => {
+      const screenList = await db3.allDocs(getScreenParams());
       return screenList.rows.length;
     },
-    db
+    db2
   );
 }
 async function calculateBackupStats(appId) {
-  return runInContext(appId, async (db) => {
+  return runInContext(appId, async (db2) => {
     const promises = [];
-    promises.push(calculateDatasourceCount(appId, db));
-    promises.push(calculateAutomationCount(appId, db));
-    promises.push(calculateScreenCount(appId, db));
+    promises.push(calculateDatasourceCount(appId, db2));
+    promises.push(calculateAutomationCount(appId, db2));
+    promises.push(calculateScreenCount(appId, db2));
     const responses = await Promise.all(promises);
     return {
       datasources: responses[0],
@@ -19140,11 +19300,11 @@ var setCurrentMonth = (usage) => {
   }
   usage.monthly.current = usage.monthly[currentMonth];
 };
-var getBreakdownName = (name, id) => {
-  if (!id || !name) {
+var getBreakdownName = (name2, id) => {
+  if (!id || !name2) {
     return;
   }
-  switch (name) {
+  switch (name2) {
     case "automations" /* AUTOMATIONS */:
       return "automations" /* AUTOMATIONS */;
     case "queries" /* QUERIES */:
@@ -19158,11 +19318,11 @@ var getDB2 = () => {
   return new Writethrough2(tenancy.getGlobalDB());
 };
 var bustCache2 = async () => {
-  const db = getDB2();
+  const db2 = getDB2();
   try {
-    const usage = await db.get(db_exports.StaticDatabases.GLOBAL.docs.usageQuota);
+    const usage = await db2.get(db_exports.StaticDatabases.GLOBAL.docs.usageQuota);
     if (usage == null ? void 0 : usage._rev) {
-      await db.remove(
+      await db2.remove(
         db_exports.StaticDatabases.GLOBAL.docs.usageQuota,
         usage == null ? void 0 : usage._rev
       );
@@ -19174,16 +19334,16 @@ var bustCache2 = async () => {
   }
 };
 var getQuotaUsage = async () => {
-  const db = getDB2();
+  const db2 = getDB2();
   let usage;
   try {
-    usage = await db.get(db_exports.StaticDatabases.GLOBAL.docs.usageQuota);
+    usage = await db2.get(db_exports.StaticDatabases.GLOBAL.docs.usageQuota);
     setCurrentMonth(usage);
     setQuotaReset(usage);
   } catch (err) {
     if (err.status === 404) {
       usage = generateNewQuotaUsage();
-      const response = await db.put(usage);
+      const response = await db2.put(usage);
       usage._rev = response.rev;
     } else {
       throw err;
@@ -19198,17 +19358,17 @@ var getQuotaUsage = async () => {
   delete usage.usageQuota.developers;
   return usage;
 };
-var setUsage = async (value, name, type) => {
-  return setAllUsage(name, type, { total: value });
+var setUsage = async (value, name2, type) => {
+  return setAllUsage(name2, type, { total: value });
 };
-var setUsagePerApp = async (appValues, name, type) => {
-  const db = getDB2();
+var setUsagePerApp = async (appValues, name2, type) => {
+  const db2 = getDB2();
   let quotaUsage = await getQuotaUsage();
   const total = Object.values(appValues).reduce((sum, num) => sum + num, 0);
   for (let [appId, value] of Object.entries(appValues)) {
     quotaUsage = coreUsageUpdate(
       quotaUsage,
-      name,
+      name2,
       type,
       {
         total,
@@ -19219,12 +19379,12 @@ var setUsagePerApp = async (appValues, name, type) => {
       }
     );
   }
-  const response = await db.put(quotaUsage);
+  const response = await db2.put(quotaUsage);
   quotaUsage._rev = response.rev;
   return quotaUsage;
 };
-var setBreakdown = (monthUsage, name, id, values) => {
-  const breakdownName = getBreakdownName(name, id);
+var setBreakdown = (monthUsage, name2, id, values) => {
+  const breakdownName = getBreakdownName(name2, id);
   if (!breakdownName || !(values == null ? void 0 : values.breakdown)) {
     return monthUsage;
   }
@@ -19233,7 +19393,7 @@ var setBreakdown = (monthUsage, name, id, values) => {
   }
   if (!monthUsage.breakdown[breakdownName]) {
     monthUsage.breakdown[breakdownName] = {
-      parent: name,
+      parent: name2,
       values: {}
     };
   }
@@ -19241,14 +19401,14 @@ var setBreakdown = (monthUsage, name, id, values) => {
   breakdown.values[id] = values.breakdown;
   return monthUsage;
 };
-var setAppUsageValue = (quotaUsage, name, type, opts = {}, values) => {
+var setAppUsageValue = (quotaUsage, name2, type, opts = {}, values) => {
   var _a;
   let appId;
   try {
     appId = db_exports.getProdAppID((opts == null ? void 0 : opts.appId) || context_exports.getAppId());
   } catch (err) {
   }
-  if (!appId || !values.app || !APP_QUOTA_NAMES.includes(name)) {
+  if (!appId || !values.app || !APP_QUOTA_NAMES.includes(name2)) {
     return quotaUsage;
   }
   if (!((_a = quotaUsage.apps) == null ? void 0 : _a[appId])) {
@@ -19260,11 +19420,11 @@ var setAppUsageValue = (quotaUsage, name, type, opts = {}, values) => {
   const appUsage = quotaUsage.apps[appId];
   switch (type) {
     case "static" /* STATIC */:
-      appUsage.usageQuota[name] = values.app;
+      appUsage.usageQuota[name2] = values.app;
       break;
     case "monthly" /* MONTHLY */:
       const currentMonth = getCurrentMonthString();
-      const monthlyName = name;
+      const monthlyName = name2;
       let monthUsage = appUsage.monthly[currentMonth];
       if (!monthUsage) {
         appUsage.monthly[currentMonth] = generateNewMonthlyQuotas();
@@ -19278,9 +19438,9 @@ var setAppUsageValue = (quotaUsage, name, type, opts = {}, values) => {
   }
   return quotaUsage;
 };
-var getAppUsageValue = (quotaUsage, type, name, id) => {
+var getAppUsageValue = (quotaUsage, type, name2, id) => {
   var _a, _b, _c, _d, _e;
-  if (!APP_QUOTA_NAMES.includes(name)) {
+  if (!APP_QUOTA_NAMES.includes(name2)) {
     return {};
   }
   let appId;
@@ -19294,13 +19454,13 @@ var getAppUsageValue = (quotaUsage, type, name, id) => {
   const appUsage = quotaUsage.apps[appId];
   switch (type) {
     case "static" /* STATIC */:
-      if ((_a = appUsage.usageQuota) == null ? void 0 : _a[name]) {
-        return { app: appUsage.usageQuota[name] };
+      if ((_a = appUsage.usageQuota) == null ? void 0 : _a[name2]) {
+        return { app: appUsage.usageQuota[name2] };
       }
       break;
     case "monthly" /* MONTHLY */:
       const currentMonth = getCurrentMonthString();
-      const monthlyName = name;
+      const monthlyName = name2;
       if (!((_c = (_b = appUsage.monthly) == null ? void 0 : _b[currentMonth]) == null ? void 0 : _c[monthlyName])) {
         break;
       }
@@ -19315,68 +19475,68 @@ var getAppUsageValue = (quotaUsage, type, name, id) => {
   }
   return { app: 0 };
 };
-var setStaticTriggers = (name, quotaUsage, triggers) => {
+var setStaticTriggers = (name2, quotaUsage, triggers) => {
   if (!quotaUsage.usageQuota.triggers) {
     quotaUsage.usageQuota.triggers = {};
   }
   if (triggers) {
-    quotaUsage.usageQuota.triggers[name] = triggers;
+    quotaUsage.usageQuota.triggers[name2] = triggers;
   }
 };
-var setMonthlyTriggers = (name, currentMonth, quotaUsage, triggers) => {
+var setMonthlyTriggers = (name2, currentMonth, quotaUsage, triggers) => {
   if (!quotaUsage.monthly[currentMonth].triggers) {
     quotaUsage.monthly[currentMonth].triggers = {};
   }
   if (triggers) {
-    quotaUsage.monthly[currentMonth].triggers[name] = triggers;
+    quotaUsage.monthly[currentMonth].triggers[name2] = triggers;
   }
 };
-var coreUsageUpdate = (quotaUsage, name, type, values, opts = {}) => {
+var coreUsageUpdate = (quotaUsage, name2, type, values, opts = {}) => {
   if (type === "static" /* STATIC */) {
-    name = name;
-    quotaUsage.usageQuota[name] = values.total;
-    setStaticTriggers(name, quotaUsage, values.triggers);
+    name2 = name2;
+    quotaUsage.usageQuota[name2] = values.total;
+    setStaticTriggers(name2, quotaUsage, values.triggers);
   } else if (type === "monthly" /* MONTHLY */) {
-    name = name;
+    name2 = name2;
     const currentMonth = getCurrentMonthString();
-    quotaUsage.monthly[currentMonth][name] = values.total;
-    setMonthlyTriggers(name, currentMonth, quotaUsage, values.triggers);
+    quotaUsage.monthly[currentMonth][name2] = values.total;
+    setMonthlyTriggers(name2, currentMonth, quotaUsage, values.triggers);
   } else {
     throw new Error(`Invalid usage type: ${type}`);
   }
-  return setAppUsageValue(quotaUsage, name, type, opts, values);
+  return setAppUsageValue(quotaUsage, name2, type, opts, values);
 };
-var setAllUsage = async (name, type, values, opts = {}) => {
-  const db = getDB2();
+var setAllUsage = async (name2, type, values, opts = {}) => {
+  const db2 = getDB2();
   let quotaUsage = await getQuotaUsage();
-  quotaUsage = coreUsageUpdate(quotaUsage, name, type, values, opts);
-  const response = await db.put(quotaUsage);
+  quotaUsage = coreUsageUpdate(quotaUsage, name2, type, values, opts);
+  const response = await db2.put(quotaUsage);
   quotaUsage._rev = response.rev;
   return quotaUsage;
 };
-var getCurrentUsageValues = async (type, name, id) => {
+var getCurrentUsageValues = async (type, name2, id) => {
   const quotaUsage = await getQuotaUsage();
   let total = 0, appValues = {};
   switch (type) {
     case "static" /* STATIC */:
-      if (quotaUsage.usageQuota[name]) {
-        const staticName = name;
+      if (quotaUsage.usageQuota[name2]) {
+        const staticName = name2;
         total = quotaUsage.usageQuota[staticName];
-        appValues = getAppUsageValue(quotaUsage, type, name, id);
+        appValues = getAppUsageValue(quotaUsage, type, name2, id);
       }
       break;
     case "monthly" /* MONTHLY */:
       const currentMonth = getCurrentMonthString();
-      const monthlyName = name;
+      const monthlyName = name2;
       if (quotaUsage.monthly[currentMonth][monthlyName]) {
         total = quotaUsage.monthly[currentMonth][monthlyName];
-        appValues = getAppUsageValue(quotaUsage, type, name, id);
+        appValues = getAppUsageValue(quotaUsage, type, name2, id);
       }
       break;
     default:
       throw new Error(`Invalid usage type: ${type}`);
   }
-  if (APP_QUOTA_NAMES.includes(name) && !(appValues.app || appValues.breakdown)) {
+  if (APP_QUOTA_NAMES.includes(name2) && !(appValues.app || appValues.breakdown)) {
     appValues.app = appValues.app || 0;
     appValues.breakdown = appValues.breakdown || 0;
   }
@@ -19397,8 +19557,8 @@ var newLicenseInfo = (licenseKey) => {
   };
 };
 var save2 = async (licenseInfo) => {
-  const db = tenancy.getGlobalDB();
-  const response = await db.put(licenseInfo);
+  const db2 = tenancy.getGlobalDB();
+  const response = await db2.put(licenseInfo);
   licenseInfo._rev = response.rev;
   return licenseInfo;
 };
@@ -19407,9 +19567,9 @@ var create = async (licenseKey) => {
   return save2(licenseInfo);
 };
 var get4 = async () => {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    return await db.get(StaticDatabases.GLOBAL.docs.licenseInfo);
+    return await db2.get(StaticDatabases.GLOBAL.docs.licenseInfo);
   } catch (err) {
     if (err.status === 404) {
       return void 0;
@@ -19422,8 +19582,8 @@ var destroy2 = async () => {
   if (!info) {
     return;
   }
-  const db = tenancy.getGlobalDB();
-  return db.remove(StaticDatabases.GLOBAL.docs.licenseInfo, info._rev);
+  const db2 = tenancy.getGlobalDB();
+  return db2.remove(StaticDatabases.GLOBAL.docs.licenseInfo, info._rev);
 };
 
 // ../pro/packages/pro/src/db/groups.ts
@@ -19445,10 +19605,10 @@ __export(groups_exports, {
 // ../pro/packages/pro/src/db/views/staticViews.ts
 init_src();
 async function createAuditLogSearchIndex() {
-  const db = context_exports.getAuditLogsDB();
+  const db2 = context_exports.getAuditLogsDB();
   let designDoc;
   try {
-    designDoc = await db.get("_design/database");
+    designDoc = await db2.get("_design/database");
   } catch (err) {
     if (err.status === 404) {
       designDoc = { _id: "_design/database" };
@@ -19491,14 +19651,14 @@ async function createAuditLogSearchIndex() {
       }
     }
   };
-  await db.put(designDoc);
+  await db2.put(designDoc);
 }
 
 // ../pro/packages/pro/src/db/views/groups.ts
 var { ViewName: ViewName4, SEPARATOR: SEPARATOR5, DocumentType: DocumentType3, createView: createView2 } = db_exports;
 var USER_PREFIX = DocumentType3.USER + SEPARATOR5;
 async function createGroupUserLookupView() {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   const viewJs = `function(doc) {
       if (doc._id.startsWith("${USER_PREFIX}") && Array.isArray(doc.userGroups)) {
         for (let groupId of doc.userGroups) {
@@ -19507,7 +19667,7 @@ async function createGroupUserLookupView() {
         }
       }
     }`;
-  await createView2(db, viewJs, ViewName4.USER_BY_GROUP);
+  await createView2(db2, viewJs, ViewName4.USER_BY_GROUP);
 }
 
 // ../pro/packages/pro/src/db/groups.ts
@@ -19547,17 +19707,17 @@ function generateUserGroupID() {
   return `${GROUP_PREFIX}${utils_exports2.newid()}`;
 }
 async function getGroupUsers(groupId, params2) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   const userDocs = await db_exports.queryView(
     db_exports.ViewName.USER_BY_GROUP,
     getGroupUsersParams(groupId, params2),
-    db,
+    db2,
     createGroupUserLookupView,
     { arrayResponse: true }
   );
-  const users2 = userDocs.map((doc) => ({
-    _id: doc.userId,
-    email: doc.email
+  const users2 = userDocs.map((doc2) => ({
+    _id: doc2.userId,
+    email: doc2.email
   })) || [];
   return users2;
 }
@@ -19586,9 +19746,9 @@ async function cleanupUsers(group) {
   }
 }
 async function fetch11() {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const groups = (await db.allDocs(
+    const groups = (await db2.allDocs(
       getUserGroupsParams(null, {
         include_docs: true
       })
@@ -19603,18 +19763,18 @@ async function fetch11() {
   }
 }
 async function get5(groupId) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const group = await db.get(groupId);
+    const group = await db2.get(groupId);
     return await enrichGroup(group);
   } catch (err) {
     throw err;
   }
 }
 async function getBulk(groupIds, opts = { enriched: true }) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const groups = (await db.allDocs({
+    const groups = (await db2.allDocs({
       keys: groupIds,
       include_docs: true
     })).rows.map((row) => row.doc);
@@ -19632,26 +19792,26 @@ async function getBulk(groupIds, opts = { enriched: true }) {
   }
 }
 async function save3(group) {
-  const db = tenancy.getGlobalDB();
-  return await db.put(group);
+  const db2 = tenancy.getGlobalDB();
+  return await db2.put(group);
 }
 async function bulkSave(groups) {
-  const db = tenancy.getGlobalDB();
-  return await db.bulkDocs(groups);
+  const db2 = tenancy.getGlobalDB();
+  return await db2.bulkDocs(groups);
 }
 async function destroy3(groupId, revision) {
-  const db = tenancy.getGlobalDB();
-  const group = await db.get(groupId);
-  let resp = await db.remove(groupId, revision);
+  const db2 = tenancy.getGlobalDB();
+  const group = await db2.get(groupId);
+  let resp = await db2.remove(groupId, revision);
   await cleanupUsers(group);
   return resp;
 }
-async function getByName(name) {
+async function getByName(name2) {
   try {
     const groups = await db_exports.directCouchFind(tenancy.getGlobalDBName(), {
       selector: {
         name: {
-          $regex: `^(?i)${name}$`
+          $regex: `^(?i)${name2}$`
         }
       },
       limit: 1
@@ -19701,7 +19861,7 @@ var { ViewName: ViewName5, AutomationViewMode: AutomationViewMode2, SEPARATOR: S
 var LOG_PREFIX = DocumentType4.AUTOMATION_LOG + SEPARATOR6;
 var APP_BACKUP_PREFIX = DocumentType4.APP_BACKUP + SEPARATOR6;
 async function createLogByAutomationView() {
-  const db = context_exports.getProdAppDB();
+  const db2 = context_exports.getProdAppDB();
   const viewJs = `function(doc) {
     if (doc._id.startsWith("${LOG_PREFIX}")) {
       let autoId = doc.automationId + "${SEPARATOR6}"
@@ -19714,10 +19874,10 @@ async function createLogByAutomationView() {
       emit(allKey)
     }
   }`;
-  await createView3(db, viewJs, ViewName5.AUTOMATION_LOGS);
+  await createView3(db2, viewJs, ViewName5.AUTOMATION_LOGS);
 }
 async function createAppBackupTriggerView() {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   const viewJs = `function(doc) {
     if (doc._id.startsWith("${APP_BACKUP_PREFIX}") && doc.type && doc.trigger) {
       let full = doc.appId + "${SEPARATOR6}"
@@ -19726,7 +19886,7 @@ async function createAppBackupTriggerView() {
       emit("${APP_BACKUP_PREFIX}" + full + doc.timestamp) 
     }
   }`;
-  await createView3(db, viewJs, ViewName5.APP_BACKUP_BY_TRIGGER);
+  await createView3(db2, viewJs, ViewName5.APP_BACKUP_BY_TRIGGER);
 }
 
 // ../pro/packages/pro/src/db/utils/retention.ts
@@ -19945,17 +20105,17 @@ __export(version_exports, {
   getLicenseVersion: () => getLicenseVersion,
   getProVersion: () => getProVersion
 });
-var import_fs8 = __toESM(require("fs"));
-var import_path9 = __toESM(require("path"));
+var import_fs9 = __toESM(require("fs"));
+var import_path10 = __toESM(require("path"));
 var getLicenseVersion = () => {
   if (environment_default2.isDev()) {
     const DEV_VER_FILENAME = "dev-version.txt";
-    const verFile = import_path9.default.join(objectStore_exports2.budibaseTempDir(), DEV_VER_FILENAME);
-    if (import_fs8.default.existsSync(verFile)) {
-      return import_fs8.default.readFileSync(verFile, "utf8");
+    const verFile = import_path10.default.join(objectStore_exports2.budibaseTempDir(), DEV_VER_FILENAME);
+    if (import_fs9.default.existsSync(verFile)) {
+      return import_fs9.default.readFileSync(verFile, "utf8");
     } else {
       const devVer = utils_exports2.newid();
-      import_fs8.default.writeFileSync(verFile, devVer);
+      import_fs9.default.writeFileSync(verFile, devVer);
       return devVer;
     }
   } else {
@@ -19963,11 +20123,11 @@ var getLicenseVersion = () => {
   }
 };
 var getProVersion = () => {
-  const version = environment_default2.VERSION;
-  if (!version) {
+  const version2 = environment_default2.VERSION;
+  if (!version2) {
     throw new Error("No budibase pro version was specified");
   }
-  return version;
+  return version2;
 };
 
 // ../pro/packages/pro/src/constants/misc.ts
@@ -20020,17 +20180,17 @@ async function getAppBackupParams(appId, filters, otherProps = {}) {
     endkey: `${APP_BACKUP_PREFIX2}${endKey}`
   };
 }
-async function getAppBackupsByTrigger(db, params2) {
+async function getAppBackupsByTrigger(db2, params2) {
   let backups = [];
   try {
     const queryIndex = db_exports.getQueryIndex(
       db_exports.ViewName.APP_BACKUP_BY_TRIGGER
     );
-    backups = await db.query(queryIndex, params2);
+    backups = await db2.query(queryIndex, params2);
   } catch (err) {
     if (err != null && err.error === "not_found") {
       await createAppBackupTriggerView();
-      return getAppBackupsByTrigger(db, params2);
+      return getAppBackupsByTrigger(db2, params2);
     } else {
       throw err;
     }
@@ -20041,7 +20201,7 @@ function generateAppBackupID(appId, timestamp) {
   return `${APP_BACKUP_PREFIX2}${appId}${db_exports.SEPARATOR}${timestamp}`;
 }
 async function fetchAppBackups(appId, opts = {}) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   let backups;
   const pageSize = opts.limit || GENERIC_PAGE_SIZE;
   const params2 = await getAppBackupParams(appId, opts, {
@@ -20052,9 +20212,9 @@ async function fetchAppBackups(appId, opts = {}) {
     params2.startkey = opts.page;
   }
   if (!opts.trigger || !opts.type) {
-    backups = await db.allDocs(params2);
+    backups = await db2.allDocs(params2);
   } else {
-    backups = await getAppBackupsByTrigger(db, params2);
+    backups = await getAppBackupsByTrigger(db2, params2);
   }
   const pageData = pagination2(backups, {
     paginate: opts.paginate,
@@ -20077,15 +20237,15 @@ async function fetchAppBackups(appId, opts = {}) {
   }
   return pageData;
 }
-async function storeAppBackupMetadata(metadata, opts = {}) {
-  const db = tenancy.getGlobalDB();
-  const prodAppId = db_exports.getProdAppID(metadata.appId);
-  let _id = generateAppBackupID(prodAppId, metadata.timestamp);
+async function storeAppBackupMetadata(metadata2, opts = {}) {
+  const db2 = tenancy.getGlobalDB();
+  const prodAppId = db_exports.getProdAppID(metadata2.appId);
+  let _id = generateAppBackupID(prodAppId, metadata2.timestamp);
   const appBackupDoc = {
-    ...metadata,
+    ...metadata2,
     _id,
     appId: prodAppId,
-    name: metadata.name
+    name: metadata2.name
   };
   if (opts.filename) {
     appBackupDoc.filename = opts.filename;
@@ -20094,27 +20254,27 @@ async function storeAppBackupMetadata(metadata, opts = {}) {
     appBackupDoc._id = opts.docId;
     appBackupDoc._rev = opts.docRev;
   }
-  if (metadata.createdBy) {
+  if (metadata2.createdBy) {
     appBackupDoc.createdBy = db_exports.getGlobalIDFromUserMetadataID(
-      metadata.createdBy
+      metadata2.createdBy
     );
   }
-  return await db.put(appBackupDoc);
+  return await db2.put(appBackupDoc);
 }
-async function updateAppBackupMetadata(backupId, name) {
-  const db = tenancy.getGlobalDB();
-  const metadata = await db.get(backupId);
-  metadata.name = name;
-  return await db.put(metadata);
+async function updateAppBackupMetadata(backupId, name2) {
+  const db2 = tenancy.getGlobalDB();
+  const metadata2 = await db2.get(backupId);
+  metadata2.name = name2;
+  return await db2.put(metadata2);
 }
 async function deleteAppBackupMetadata(backupId) {
-  const db = tenancy.getGlobalDB();
-  const backupDoc = await db.get(backupId);
-  await db.remove(backupDoc._id, backupDoc._rev);
+  const db2 = tenancy.getGlobalDB();
+  const backupDoc = await db2.get(backupId);
+  await db2.remove(backupDoc._id, backupDoc._rev);
 }
 async function getAppBackupMetadata(backupId) {
-  const db = tenancy.getGlobalDB();
-  return await db.get(backupId);
+  const db2 = tenancy.getGlobalDB();
+  return await db2.get(backupId);
 }
 
 // ../pro/packages/pro/src/db/environmentVariables.ts
@@ -20133,16 +20293,16 @@ var cache = new import_lru_cache.default({
 function getEnvVarID() {
   return StaticDatabases.GLOBAL.docs.environmentVariables;
 }
-function getCacheEnvVarID(rev) {
+function getCacheEnvVarID(rev2) {
   const tenantId = tenancy.getTenantId();
-  return `${tenantId}/${getEnvVarID()}/${rev || ""}`;
+  return `${tenantId}/${getEnvVarID()}/${rev2 || ""}`;
 }
 async function get6() {
   const id = getEnvVarID();
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   let encrypted, notFound = false;
   try {
-    encrypted = await db.get(id);
+    encrypted = await db2.get(id);
   } catch (err) {
     if (err.status == 404) {
       notFound = true;
@@ -20175,14 +20335,14 @@ async function get6() {
   cache.set(cacheKey, finalDoc);
   return finalDoc;
 }
-async function update(doc) {
+async function update(doc2) {
   const id = getEnvVarID();
-  const db = tenancy.getGlobalDB();
-  return await db.put({
-    _id: doc._id || id,
-    _rev: doc._rev || void 0,
+  const db2 = tenancy.getGlobalDB();
+  return await db2.put({
+    _id: doc2._id || id,
+    _rev: doc2._rev || void 0,
     variables: encryption_exports.encrypt(
-      JSON.stringify(doc.variables),
+      JSON.stringify(doc2.variables),
       encryption_exports.SecretOption.ENCRYPTION
     )
   });
@@ -20314,16 +20474,16 @@ __export(offline_exports, {
   getOfflineLicense: () => getOfflineLicense,
   writeOfflineLicenseToDisk: () => writeOfflineLicenseToDisk
 });
-var import_fs9 = __toESM(require("fs"));
-var import_path10 = require("path");
+var import_fs10 = __toESM(require("fs"));
+var import_path11 = require("path");
 var import_os2 = require("os");
 var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
 var SUB_DIRECTORY = environment_default2.isTest() ? ".budibase-test" : ".budibase";
-var DIRECTORY = (0, import_path10.join)((0, import_os2.tmpdir)(), SUB_DIRECTORY);
+var DIRECTORY = (0, import_path11.join)((0, import_os2.tmpdir)(), SUB_DIRECTORY);
 var OFFLINE_LICENSE_FILE = "offline_license.txt";
-var LICENSE_FILE_PATH = (0, import_path10.join)(DIRECTORY, OFFLINE_LICENSE_FILE);
-if (!import_fs9.default.existsSync(DIRECTORY)) {
-  import_fs9.default.mkdirSync(DIRECTORY);
+var LICENSE_FILE_PATH = (0, import_path11.join)(DIRECTORY, OFFLINE_LICENSE_FILE);
+if (!import_fs10.default.existsSync(DIRECTORY)) {
+  import_fs10.default.mkdirSync(DIRECTORY);
 }
 var PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvz3jePLCFBXZ19c8Dpkv\nXtSgOhKFOcvQdo/LV0KJRUzQWDPWuO4ILtBtnqhjtIzZH4CH0qCYBet5L6Qr4CM1\nl2HXiAD1Q2rlHNW9wDaYyKb1F5f+v4RyqCAyzlkwRdksmkLeECTboojNnmRCrE3C\n8suunQP5bEScqEY2kclqzSf8e6xqMzPUg3mL/pNa1iEv7TuLbU9nJfgR36l0WmZY\n94fWnSaT8OSXSqcxsaByf06gfS3HAoTJNc7eqz1Hf9fUORQGPUAnFK8cT3SfdA36\nd/o3ZWE1TTj1zYwlCLN5qRKr3hU8nC3xEYNEbkB9SfTRaOq9Q7P8WmfLkoCPm3pR\nmwIDAQAB\n-----END PUBLIC KEY-----\n";
 function getOfflineLicense() {
@@ -20334,16 +20494,16 @@ function getOfflineLicense() {
   }
 }
 function getOfflineLicenseFromDisk() {
-  if (import_fs9.default.existsSync(LICENSE_FILE_PATH)) {
-    const token = import_fs9.default.readFileSync(LICENSE_FILE_PATH, { encoding: "utf-8" });
+  if (import_fs10.default.existsSync(LICENSE_FILE_PATH)) {
+    const token = import_fs10.default.readFileSync(LICENSE_FILE_PATH, { encoding: "utf-8" });
     return import_jsonwebtoken.default.verify(token, PUBLIC_KEY, { algorithms: ["RS256"] });
   }
 }
 function writeOfflineLicenseToDisk(signedLicense) {
-  import_fs9.default.writeFileSync(LICENSE_FILE_PATH, signedLicense, { encoding: "utf-8" });
+  import_fs10.default.writeFileSync(LICENSE_FILE_PATH, signedLicense, { encoding: "utf-8" });
 }
 function deleteOfflineLicense() {
-  import_fs9.default.rmSync(LICENSE_FILE_PATH, { force: true });
+  import_fs10.default.rmSync(LICENSE_FILE_PATH, { force: true });
 }
 
 // ../pro/packages/pro/src/sdk/licensing/licenses/licenses.ts
@@ -20546,14 +20706,14 @@ __export(quotas_exports4, {
 
 // ../pro/packages/pro/src/sdk/quotas/quotas.ts
 init_src();
-var increment = (name, type, opts) => {
-  return tryIncrement(1, name, type, opts);
+var increment = (name2, type, opts) => {
+  return tryIncrement(1, name2, type, opts);
 };
-var incrementMany = (change, name, type, opts) => {
-  return tryIncrement(change, name, type, opts);
+var incrementMany = (change, name2, type, opts) => {
+  return tryIncrement(change, name2, type, opts);
 };
-var tryIncrement = async (change, name, type, opts = {}) => {
-  await updateUsage(change, name, type, {
+var tryIncrement = async (change, name2, type, opts = {}) => {
+  await updateUsage(change, name2, type, {
     dryRun: true,
     suppressErrorLog: opts.suppressErrorLog,
     id: opts.id
@@ -20562,7 +20722,7 @@ var tryIncrement = async (change, name, type, opts = {}) => {
   if (opts.fn) {
     result = await opts.fn();
   }
-  await updateUsage(change, name, type, {
+  await updateUsage(change, name2, type, {
     dryRun: false,
     valueFn: opts.valueFn,
     suppressErrorLog: opts.suppressErrorLog,
@@ -20570,32 +20730,32 @@ var tryIncrement = async (change, name, type, opts = {}) => {
   });
   return result;
 };
-var decrement = (name, type, opts = {}) => {
-  return updateUsage(-1, name, type, opts);
+var decrement = (name2, type, opts = {}) => {
+  return updateUsage(-1, name2, type, opts);
 };
-var decrementMany = (change, name, type, opts = {}) => {
-  return updateUsage(-change, name, type, opts);
+var decrementMany = (change, name2, type, opts = {}) => {
+  return updateUsage(-change, name2, type, opts);
 };
-var set2 = async (name, type, value) => {
-  return quotas_exports.setUsage(value, name, type);
+var set2 = async (name2, type, value) => {
+  return quotas_exports.setUsage(value, name2, type);
 };
-var getExistingTriggers = (type, name, quotaUsage) => {
+var getExistingTriggers = (type, name2, quotaUsage) => {
   if (type == "static" /* STATIC */) {
     const triggers = quotaUsage.usageQuota.triggers;
-    return triggers ? triggers[name] || {} : {};
+    return triggers ? triggers[name2] || {} : {};
   } else {
     const currentMonthString = quotas_exports.utils.getCurrentMonthString();
     const triggers = quotaUsage.monthly[currentMonthString].triggers;
-    return triggers ? triggers[name] || {} : {};
+    return triggers ? triggers[name2] || {} : {};
   }
 };
-var triggerQuota2 = async (name, quota, percentage, resetDate) => {
+var triggerQuota2 = async (name2, quota, percentage, resetDate) => {
   try {
     await redlockImpl_exports.doWithLock(
       {
         type: "try_once" /* TRY_ONCE */,
         name: "trigger_quota" /* TRIGGER_QUOTA */,
-        resource: name,
+        resource: name2,
         // use the quota name for extra uniqueness on the lock
         ttl: 1e4
         // auto expire after 10 seconds
@@ -20615,10 +20775,10 @@ var triggerQuota2 = async (name, quota, percentage, resetDate) => {
     logging_exports.logAlert("Error triggering quota", e);
   }
 };
-var checkTriggers = async (type, name, totalValue, quota) => {
+var checkTriggers = async (type, name2, totalValue, quota) => {
   const usage = await getQuotaUsage();
   const resetDate = type === "monthly" /* MONTHLY */ ? usage.quotaReset : void 0;
-  const triggers = await getExistingTriggers(type, name, usage);
+  const triggers = await getExistingTriggers(type, name2, usage);
   const quotaTriggers = quota.triggers;
   let percentage = totalValue / quota.value * 100;
   if (percentage > 100) {
@@ -20634,7 +20794,7 @@ var checkTriggers = async (type, name, totalValue, quota) => {
         const isAtTrigger = percentage === triggerPercentage;
         const sendNotification = !nextIsTriggered || isAtTrigger;
         if (sendNotification) {
-          await triggerQuota2(name, quota, percentage, resetDate);
+          await triggerQuota2(name2, quota, percentage, resetDate);
         }
       }
     } else {
@@ -20643,23 +20803,23 @@ var checkTriggers = async (type, name, totalValue, quota) => {
   }
   return triggers;
 };
-var updateUsage = async (usageChange, name, type, opts = {}) => {
+var updateUsage = async (usageChange, name2, type, opts = {}) => {
   let appId = null;
   try {
     appId = context_exports.getAppId();
   } catch (err) {
   }
-  const isAppQuota = APP_QUOTA_NAMES.includes(name);
+  const isAppQuota = APP_QUOTA_NAMES.includes(name2);
   if (isAppQuota && !appId) {
     throw new Error("App context required for quota update");
   }
   try {
-    const licensedQuota = await getLicensedQuota("usage" /* USAGE */, name, type);
+    const licensedQuota = await getLicensedQuota("usage" /* USAGE */, name2, type);
     let {
       total: totalValue,
       app: appValue,
       breakdown: breakdownValue
-    } = await quotas_exports.getCurrentUsageValues(type, name, opts.id);
+    } = await quotas_exports.getCurrentUsageValues(type, name2, opts.id);
     totalValue += usageChange;
     if (appValue != null) {
       appValue += usageChange;
@@ -20669,7 +20829,7 @@ var updateUsage = async (usageChange, name, type, opts = {}) => {
     }
     let triggers = {};
     if (!opts.dryRun) {
-      triggers = await checkTriggers(type, name, totalValue, licensedQuota);
+      triggers = await checkTriggers(type, name2, totalValue, licensedQuota);
     }
     if (licensedQuota.value !== quotas_exports2.UNLIMITED && totalValue > licensedQuota.value && usageChange > 0) {
       throw new UsageLimitError(
@@ -20692,7 +20852,7 @@ var updateUsage = async (usageChange, name, type, opts = {}) => {
       appValue = totalValue;
     }
     await quotas_exports.setAllUsage(
-      name,
+      name2,
       type,
       {
         total: totalValue,
@@ -20704,30 +20864,30 @@ var updateUsage = async (usageChange, name, type, opts = {}) => {
     );
   } catch (err) {
     if (!opts.suppressErrorLog) {
-      console.error(`Error updating usage quotas for ${name}`, err);
+      console.error(`Error updating usage quotas for ${name2}`, err);
     }
     throw err;
   }
 };
-var getLicensedQuota = async (quotaType, name, usageType) => {
+var getLicensedQuota = async (quotaType, name2, usageType) => {
   const license = await cache_exports2.getCachedLicense();
   if (!license) {
     const tenantId = tenancy.getTenantId();
     throw new Error("License not found for tenant id " + tenantId);
   }
-  if (usageType && isStaticQuota(quotaType, usageType, name)) {
-    return license.quotas[quotaType][usageType][name];
-  } else if (usageType && isMonthlyQuota(quotaType, usageType, name)) {
-    return license.quotas[quotaType][usageType][name];
-  } else if (isConstantQuota(quotaType, name)) {
-    return license.quotas[quotaType][name];
+  if (usageType && isStaticQuota(quotaType, usageType, name2)) {
+    return license.quotas[quotaType][usageType][name2];
+  } else if (usageType && isMonthlyQuota(quotaType, usageType, name2)) {
+    return license.quotas[quotaType][usageType][name2];
+  } else if (isConstantQuota(quotaType, name2)) {
+    return license.quotas[quotaType][name2];
   } else {
     throw new Error("Invalid quota type");
   }
 };
-var usageLimitIsExceeded = async (name, type) => {
+var usageLimitIsExceeded = async (name2, type) => {
   try {
-    await updateUsage(1, name, type, { dryRun: true });
+    await updateUsage(1, name2, type, { dryRun: true });
     return false;
   } catch (e) {
     if (e.code === "usage_limit_exceeded" /* USAGE_LIMIT_EXCEEDED */) {
@@ -20841,19 +21001,19 @@ async function recordDayPassOnQuotas() {
   });
 }
 async function recordDayPassTimeOnUser(user) {
-  const db = tenancy.getGlobalDB();
-  let dbUser = await db.get(user._id);
+  const db2 = tenancy.getGlobalDB();
+  let dbUser = await db2.get(user._id);
   const now = /* @__PURE__ */ new Date();
   const nowString = (/* @__PURE__ */ new Date()).toISOString();
   user.dayPassRecordedAt = nowString;
   dbUser.dayPassRecordedAt = nowString;
   try {
     console.log(`Recording day pass for user=${user._id}`);
-    await db.put(dbUser);
+    await db2.put(dbUser);
   } catch (e) {
     if (e.status === 409) {
       console.warn(`Conflict recording day pass for user=${user._id}`);
-      dbUser = await db.get(user._id);
+      dbUser = await db2.get(user._id);
       if (!dbUser.dayPassRecordedAt || new Date(dbUser.dayPassRecordedAt).getDay() !== now.getDay()) {
         console.error(`Day pass not recorded for user=${user._id}`);
         throw e;
@@ -21102,9 +21262,9 @@ function generateAutomationLogID(isoDate, status2, automationId) {
   return `${DocumentType5.AUTOMATION_LOG}${SEPARATOR7}${isoDate}${SEPARATOR7}${automationId}${SEPARATOR7}${status2}`;
 }
 async function getAllLogs(startDate, endDate, opts = { docs: true }) {
-  let db = context_exports.getProdAppDB();
-  if (!await db.exists()) {
-    db = context_exports.getDevAppDB();
+  let db2 = context_exports.getProdAppDB();
+  if (!await db2.exists()) {
+    db2 = context_exports.getDevAppDB();
   }
   let optional = { status: opts.status };
   let limit = (opts == null ? void 0 : opts.limit) ? opts.limit : (opts == null ? void 0 : opts.paginate) ? GENERIC_PAGE_SIZE + 1 : void 0;
@@ -21115,16 +21275,16 @@ async function getAllLogs(startDate, endDate, opts = { docs: true }) {
   if (opts == null ? void 0 : opts.page) {
     params2.startkey = opts.page;
   }
-  let response = await db.allDocs(params2);
+  let response = await db2.allDocs(params2);
   return pagination2(response, {
     paginate: opts == null ? void 0 : opts.paginate,
     pageSize: GENERIC_PAGE_SIZE
   });
 }
 async function getLogsByView(startDate, endDate, viewParams = {}) {
-  let db = context_exports.getProdAppDB();
-  if (!await db.exists()) {
-    db = context_exports.getDevAppDB();
+  let db2 = context_exports.getProdAppDB();
+  if (!await db2.exists()) {
+    db2 = context_exports.getDevAppDB();
   }
   let response;
   try {
@@ -21139,7 +21299,7 @@ async function getLogsByView(startDate, endDate, viewParams = {}) {
     if (viewParams == null ? void 0 : viewParams.page) {
       params2.startkey = viewParams.page;
     }
-    response = await db.query(getQueryIndex3(ViewName6.AUTOMATION_LOGS), params2);
+    response = await db2.query(getQueryIndex3(ViewName6.AUTOMATION_LOGS), params2);
   } catch (err) {
     if (err != null && (err.name === "not_found" || err.error === "not_found")) {
       await createLogByAutomationView();
@@ -21151,9 +21311,9 @@ async function getLogsByView(startDate, endDate, viewParams = {}) {
   return pagination2(response);
 }
 async function writeLog(automation, results) {
-  const db = context_exports.getProdAppDB();
+  const db2 = context_exports.getProdAppDB();
   const automationId = automation._id;
-  const name = automation.name;
+  const name2 = automation.name;
   const status2 = getStatus(results);
   const isoDate = (/* @__PURE__ */ new Date()).toISOString();
   const id = generateAutomationLogID(isoDate, status2, automationId);
@@ -21162,23 +21322,23 @@ async function writeLog(automation, results) {
     ...results,
     automationId,
     status: status2,
-    automationName: name,
+    automationName: name2,
     createdAt: isoDate,
     _id: id
   };
-  await db.put(log);
+  await db2.put(log);
   return id;
 }
 async function updateAppMetadataWithErrors(logIds, { clearing } = { clearing: false }) {
-  const db = context_exports.getProdAppDB();
+  const db2 = context_exports.getProdAppDB();
   await backOff(async () => {
-    const metadata = await db.get(db_exports.DocumentType.APP_METADATA);
+    const metadata2 = await db2.get(db_exports.DocumentType.APP_METADATA);
     for (let logId of logIds) {
       const parts = logId.split(db_exports.SEPARATOR);
       const autoId = `${parts[parts.length - 3]}${db_exports.SEPARATOR}${parts[parts.length - 2]}`;
       let errors = {};
-      if (metadata.automationErrors) {
-        errors = metadata.automationErrors;
+      if (metadata2.automationErrors) {
+        errors = metadata2.automationErrors;
       }
       if (!Array.isArray(errors[autoId])) {
         errors[autoId] = [];
@@ -21192,10 +21352,10 @@ async function updateAppMetadataWithErrors(logIds, { clearing } = { clearing: fa
       if (errors[autoId].length === 0) {
         delete errors[autoId];
       }
-      metadata.automationErrors = errors;
+      metadata2.automationErrors = errors;
     }
-    await db.put(metadata);
-    await cache_exports.app.invalidateAppMetadata(metadata.appId, metadata);
+    await db2.put(metadata2);
+    await cache_exports.app.invalidateAppMetadata(metadata2.appId, metadata2);
   }, "Failed to update app metadata with automation log error");
 }
 async function getExpiredLogs() {
@@ -21211,29 +21371,29 @@ async function getExpiredLogs() {
   }
 }
 async function clearOldHistory() {
-  const db = context_exports.getProdAppDB();
+  const db2 = context_exports.getProdAppDB();
   try {
     const expired = await getExpiredLogs();
     if (!expired.data || expired.data.length === 0) {
       return;
     }
-    const toDelete = expired.data.map((doc) => ({
-      _id: doc.id,
-      _rev: doc.value.rev,
+    const toDelete = expired.data.map((doc2) => ({
+      _id: doc2.id,
+      _rev: doc2.value.rev,
       _deleted: true
     }));
-    const errorLogIds = expired.data.filter((doc) => {
-      const parts = doc.id.split(db_exports.SEPARATOR);
+    const errorLogIds = expired.data.filter((doc2) => {
+      const parts = doc2.id.split(db_exports.SEPARATOR);
       const status2 = parts[parts.length - 1];
       return status2 === "error" /* ERROR */;
-    }).map((doc) => doc.id);
-    await db.bulkDocs(toDelete);
+    }).map((doc2) => doc2.id);
+    await db2.bulkDocs(toDelete);
     if (errorLogIds.length) {
       await updateAppMetadataWithErrors(errorLogIds, { clearing: true });
     }
   } catch (err) {
     logging_exports.logAlert(
-      `Failed to cleanup automation log history - Database "${db.name}"`,
+      `Failed to cleanup automation log history - Database "${db2.name}"`,
       err
     );
   }
@@ -21406,10 +21566,10 @@ async function get7(id) {
 async function getBulk2(ids, opts = { enriched: true }) {
   return await groups_exports.getBulk(ids, opts);
 }
-async function guardNameAvailility(name) {
-  const existingGroup = await groups_exports.getByName(name);
+async function guardNameAvailility(name2) {
+  const existingGroup = await groups_exports.getByName(name2);
   if (existingGroup) {
-    throw new GroupNameUnavailableError(name);
+    throw new GroupNameUnavailableError(name2);
   }
 }
 async function save4(group) {
@@ -21548,16 +21708,16 @@ __export(plugins_exports, {
 init_src();
 
 // ../pro/packages/pro/src/utilities/fileSystem.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path11 = require("path");
-function loadJSFile(directory, name) {
-  return import_fs10.default.readFileSync((0, import_path11.join)(directory, name), "utf8");
+var import_fs11 = __toESM(require("fs"));
+var import_path12 = require("path");
+function loadJSFile(directory2, name2) {
+  return import_fs11.default.readFileSync((0, import_path12.join)(directory2, name2), "utf8");
 }
 
 // ../pro/packages/pro/src/sdk/plugins/index.ts
 async function storePlugin(metadata, directory, source) {
   const db = tenancy.getGlobalDB();
-  const version = metadata.package.version, name = metadata.package.name, description = metadata.package.description, hash2 = metadata.schema.hash;
+  const version = metadata.package.version, name = metadata.package.name, description = metadata.package.description, hash = metadata.schema.hash;
   const bucketPath = objectStore_exports2.getPluginS3Dir(name);
   const files = await objectStore_exports2.uploadDirectory(
     objectStore_exports2.ObjectStoreBuckets.PLUGINS,
@@ -21572,8 +21732,7 @@ async function storePlugin(metadata, directory, source) {
   if (metadata.schema.type === "datasource" /* DATASOURCE */) {
     const js = loadJSFile(directory, jsFile.name);
     try {
-      ;
-      (0, eval)(js);
+      eval(js);
     } catch (err) {
       const message = (err == null ? void 0 : err.message) ? err.message : JSON.stringify(err);
       throw new Error(`JS invalid: ${message}`);
@@ -21594,7 +21753,7 @@ async function storePlugin(metadata, directory, source) {
     ...metadata,
     name,
     version,
-    hash: hash2,
+    hash,
     description
   };
   if (iconFileName) {
@@ -21606,7 +21765,7 @@ async function storePlugin(metadata, directory, source) {
       source
     };
   }
-  const write2 = async () => {
+  const write = async () => {
     const response = await db.put(doc);
     await events_exports.plugin.imported(doc);
     return {
@@ -21615,21 +21774,21 @@ async function storePlugin(metadata, directory, source) {
     };
   };
   if (!rev) {
-    return await addPlugin(write2);
+    return await addPlugin(write);
   } else {
-    return await write2();
+    return await write();
   }
 }
-async function deletePlugin(pluginId) {
-  const db = tenancy.getGlobalDB();
+async function deletePlugin(pluginId2) {
+  const db2 = tenancy.getGlobalDB();
   try {
-    const plugin = await db.get(pluginId);
-    const bucketPath = objectStore_exports2.getPluginS3Dir(plugin.name);
+    const plugin = await db2.get(pluginId2);
+    const bucketPath2 = objectStore_exports2.getPluginS3Dir(plugin.name);
     await objectStore_exports2.deleteFolder(
       objectStore_exports2.ObjectStoreBuckets.PLUGINS,
-      bucketPath
+      bucketPath2
     );
-    await db.remove(pluginId, plugin._rev);
+    await db2.remove(pluginId2, plugin._rev);
     await events_exports.plugin.deleted(plugin);
     await removePlugin();
   } catch (err) {
@@ -21638,9 +21797,9 @@ async function deletePlugin(pluginId) {
   }
 }
 async function checkPluginQuotas() {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const allPlugins = await db.allDocs(db_exports.getPluginParams());
+    const allPlugins = await db2.allDocs(db_exports.getPluginParams());
     const pluginCount = allPlugins.rows.length;
     console.log(`Syncing plugin count: ${pluginCount}`);
     await updatePluginCount(pluginCount);
@@ -21666,12 +21825,12 @@ function isEncryptionKeyAvailable() {
   return !!environment_default2.ENCRYPTION_KEY;
 }
 async function fetch13() {
-  const doc = await environmentVariables_exports.get();
-  return Object.keys(doc.variables);
+  const doc2 = await environmentVariables_exports.get();
+  return Object.keys(doc2.variables);
 }
 async function fetchValues(environment3) {
-  const doc = await environmentVariables_exports.get();
-  const decrypted = doc.variables;
+  const doc2 = await environmentVariables_exports.get();
+  const decrypted = doc2.variables;
   const output = {};
   for (let [key, value] of Object.entries(decrypted)) {
     switch (environment3) {
@@ -21693,9 +21852,9 @@ async function changeValues(cb) {
       "User does not have access to environment variables feature."
     );
   }
-  const doc = await environmentVariables_exports.get();
-  doc.variables = cb(doc.variables);
-  await environmentVariables_exports.update(doc);
+  const doc2 = await environmentVariables_exports.get();
+  doc2.variables = cb(doc2.variables);
+  await environmentVariables_exports.update(doc2);
 }
 async function update2(varName, value) {
   const checkName = isValid(varName);
@@ -21724,7 +21883,7 @@ __export(auditLogs_exports2, {
   definitions: () => definitions,
   download: () => download,
   fetch: () => fetch14,
-  write: () => write
+  write: () => write2
 });
 
 // ../pro/packages/pro/src/sdk/auditLogs/auditLogs.ts
@@ -21736,15 +21895,15 @@ var MemoryStream2 = require("memorystream");
 function generateAuditLogID(timestamp) {
   return `${"al" /* AUDIT_LOG */}${SEPARATOR}${timestamp}${SEPARATOR}${utils_exports2.newid()}`;
 }
-async function save5(doc) {
-  if (!doc._id) {
-    doc._id = generateAuditLogID(doc.timestamp);
+async function save5(doc2) {
+  if (!doc2._id) {
+    doc2._id = generateAuditLogID(doc2.timestamp);
   }
   try {
-    const db = context_exports.getAuditLogsDB();
-    const response = await db.put(doc);
+    const db2 = context_exports.getAuditLogsDB();
+    const response = await db2.put(doc2);
     return {
-      ...doc,
+      ...doc2,
       _rev: response.rev
     };
   } catch (err) {
@@ -21769,12 +21928,12 @@ async function search(search3, bookmark) {
   );
 }
 function dump(params2) {
-  const db = context_exports.getAuditLogsDB();
+  const db2 = context_exports.getAuditLogsDB();
   const stream3 = new MemoryStream2();
-  const promise = db.dump(stream3, {
-    filter: (doc) => {
+  const promise = db2.dump(stream3, {
+    filter: (doc2) => {
       var _a;
-      const auditLog = doc;
+      const auditLog = doc2;
       if (!((_a = auditLog._id) == null ? void 0 : _a.startsWith("al" /* AUDIT_LOG */))) {
         return false;
       }
@@ -21792,7 +21951,7 @@ function dump(params2) {
         allMatched = allMatched && auditLog.timestamp >= params2.startDate && auditLog.timestamp <= params2.endDate;
       }
       if (params2.fullSearch) {
-        const json = JSON.stringify(doc);
+        const json = JSON.stringify(doc2);
         allMatched = allMatched && json.includes(params2.fullSearch);
       }
       return allMatched;
@@ -21803,8 +21962,8 @@ function dump(params2) {
     const json = JSON.parse(Buffer.from(data).toString());
     if (Array.isArray(json.docs)) {
       let str = "";
-      for (let doc of json.docs) {
-        str += JSON.stringify(doc) + "\n";
+      for (let doc2 of json.docs) {
+        str += JSON.stringify(doc2) + "\n";
       }
       returnStream.write(str);
     }
@@ -21910,12 +22069,12 @@ async function auditLogsEnabled() {
   const license = await licensing_exports.cache.getCachedLicense();
   return license.features.includes("auditLogs" /* AUDIT_LOGS */);
 }
-function getEventFriendlyName(event, metadata) {
+function getEventFriendlyName(event, metadata2) {
   const friendly = AuditedEventFriendlyName[event];
   if (!friendly) {
     throw new Error("No friendly name found.");
   }
-  let processed = processStringSync(friendly, metadata);
+  let processed = processStringSync(friendly, metadata2);
   if (processed.includes(`""`)) {
     processed = removeTemplateStrings(friendly);
   }
@@ -21923,29 +22082,29 @@ function getEventFriendlyName(event, metadata) {
 }
 
 // ../pro/packages/pro/src/sdk/auditLogs/auditLogs.ts
-async function write(event, metadata, opts) {
+async function write2(event, metadata2, opts) {
   if (!await auditLogsEnabled() || !utils_exports2.isAudited(event)) {
     return;
   }
-  const friendly = getEventFriendlyName(event, metadata);
+  const friendly = getEventFriendlyName(event, metadata2);
   let date = /* @__PURE__ */ new Date();
   if (opts == null ? void 0 : opts.timestamp) {
     date = new Date(opts.timestamp);
   }
-  const doc = {
+  const doc2 = {
     timestamp: date.toISOString(),
     event,
     name: friendly,
     userId: (opts == null ? void 0 : opts.userId) || AuditLogSystemUser,
     metadata: {
-      ...metadata,
+      ...metadata2,
       ...opts == null ? void 0 : opts.hostInfo
     }
   };
   const fallback = {};
   try {
     if (opts == null ? void 0 : opts.appId) {
-      doc.appId = db_exports.getProdAppID(opts.appId);
+      doc2.appId = db_exports.getProdAppID(opts.appId);
       const appMetadata = await cache_exports.app.getAppMetadata(opts.appId);
       fallback.appName = appMetadata.name;
     }
@@ -21959,8 +22118,8 @@ async function write(event, metadata, opts) {
       err
     );
   }
-  doc.fallback = fallback;
-  return await save5(doc);
+  doc2.fallback = fallback;
+  return await save5(doc2);
 }
 async function enrich(logs) {
   const allUserIds = logs.map((log) => log.userId);
@@ -22031,8 +22190,8 @@ function getBackupQueue() {
 }
 
 // ../pro/packages/pro/src/sdk/backups/backup.ts
-async function storeAppBackupMetadata2(metadata, opts = {}) {
-  return backups_exports.storeAppBackupMetadata(metadata, opts);
+async function storeAppBackupMetadata2(metadata2, opts = {}) {
+  return backups_exports.storeAppBackupMetadata(metadata2, opts);
 }
 function getTimestamps(status2) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -22046,7 +22205,7 @@ function getTimestamps(status2) {
       return { timestamp, createdAt: timestamp };
   }
 }
-async function updateBackupStatus(id, rev, status2, contents, filename) {
+async function updateBackupStatus(id, rev2, status2, contents, filename) {
   const backup = await getAppBackup(id);
   return await backups_exports.storeAppBackupMetadata(
     {
@@ -22056,10 +22215,10 @@ async function updateBackupStatus(id, rev, status2, contents, filename) {
       status: status2,
       type: "backup" /* BACKUP */
     },
-    { filename, docId: id, docRev: rev }
+    { filename, docId: id, docRev: rev2 }
   );
 }
-async function updateRestoreStatus(id, rev, status2) {
+async function updateRestoreStatus(id, rev2, status2) {
   const restore = await getAppBackup(id);
   return await backups_exports.storeAppBackupMetadata(
     {
@@ -22069,7 +22228,7 @@ async function updateRestoreStatus(id, rev, status2) {
       type: "restore" /* RESTORE */,
       trigger: "manual" /* MANUAL */
     },
-    { docId: id, docRev: rev }
+    { docId: id, docRev: rev2 }
   );
 }
 async function getAppBackup(backupId) {
@@ -22079,11 +22238,11 @@ async function updateAppBackup(backupId, backupName) {
   return backups_exports.updateAppBackupMetadata(backupId, backupName);
 }
 async function deleteAppBackup(backupId) {
-  const metadata = await backups_exports.getAppBackupMetadata(backupId);
-  if (metadata.filename) {
+  const metadata2 = await backups_exports.getAppBackupMetadata(backupId);
+  if (metadata2.filename) {
     await objectStore_exports2.deleteFile(
       objectStore_exports2.ObjectStoreBuckets.BACKUPS,
-      metadata.filename
+      metadata2.filename
     );
   }
   return backups_exports.deleteAppBackupMetadata(backupId);
@@ -22092,15 +22251,15 @@ async function fetchAppBackups2(appId, opts) {
   return backups_exports.fetchAppBackups(appId, opts);
 }
 async function downloadAppBackup(backupId) {
-  const metadata = await backups_exports.getAppBackupMetadata(backupId);
-  if (!metadata.filename) {
+  const metadata2 = await backups_exports.getAppBackupMetadata(backupId);
+  if (!metadata2.filename) {
     throw new Error("Backup incomplete - cannot download.");
   }
   const path2 = await objectStore_exports2.retrieveToTmp(
     objectStore_exports2.ObjectStoreBuckets.BACKUPS,
-    metadata.filename
+    metadata2.filename
   );
-  return { metadata, path: path2 };
+  return { metadata: metadata2, path: path2 };
 }
 async function triggerAppBackup(appId, trigger, opts = {}) {
   let backup;
@@ -22139,7 +22298,7 @@ async function triggerAppBackup(appId, trigger, opts = {}) {
   return backup.id;
 }
 async function triggerAppRestore(appId, backupId, nameForBackup, createdBy) {
-  const metadata = await getAppBackup(backupId);
+  const metadata2 = await getAppBackup(backupId);
   let restore;
   try {
     restore = await storeAppBackupMetadata2({
@@ -22166,7 +22325,7 @@ async function triggerAppRestore(appId, backupId, nameForBackup, createdBy) {
       createdBy
     }
   });
-  return { restoreId: restore.id, metadata };
+  return { restoreId: restore.id, metadata: metadata2 };
 }
 var pkg = {
   isEnabled: isBackupsEnabled,
@@ -22189,7 +22348,7 @@ __export(processing_exports, {
   init: () => init12
 });
 init_src();
-var import_fs11 = __toESM(require("fs"));
+var import_fs12 = __toESM(require("fs"));
 async function init12(opts) {
   await getBackupQueue().process(async (job) => {
     const data = job.data;
@@ -22257,8 +22416,8 @@ async function runBackup(trigger, tenantId, appId, opts) {
       }
     });
     await updateMetadata("complete" /* COMPLETE */, { filename, contents });
-    if (import_fs11.default.existsSync(tarPath)) {
-      import_fs11.default.rmSync(tarPath);
+    if (import_fs12.default.existsSync(tarPath)) {
+      import_fs12.default.rmSync(tarPath);
     }
   } catch (err) {
     logging_exports.logAlert("App backup error", err);
@@ -22271,7 +22430,7 @@ async function importProcessor(job, opts) {
   const tenantId = tenancy.getTenantIDFromAppID(appId);
   return tenancy.doInTenant(tenantId, async () => {
     const devAppId = db_exports.getDevAppID(appId);
-    const { rev } = await backup_default2.updateRestoreStatus(
+    const { rev: rev2 } = await backup_default2.updateRestoreStatus(
       data.docId,
       data.docRev,
       "started" /* STARTED */
@@ -22296,23 +22455,23 @@ async function importProcessor(job, opts) {
       logging_exports.logAlert("App restore error", err);
       status2 = "failed" /* FAILED */;
     }
-    await backup_default2.updateRestoreStatus(data.docId, rev, status2);
+    await backup_default2.updateRestoreStatus(data.docId, rev2, status2);
   });
 }
 async function exportProcessor(job, opts) {
   const data = job.data;
-  const appId = data.appId, trigger = data.export.trigger, name = data.export.name;
+  const appId = data.appId, trigger = data.export.trigger, name2 = data.export.name;
   const tenantId = tenancy.getTenantIDFromAppID(appId);
   await tenancy.doInTenant(tenantId, async () => {
-    const { rev } = await backup_default2.updateBackupStatus(
+    const { rev: rev2 } = await backup_default2.updateBackupStatus(
       data.docId,
       data.docRev,
       "started" /* STARTED */
     );
     return runBackup(trigger, tenantId, appId, {
       processing: opts,
-      doc: { id: data.docId, rev },
-      name
+      doc: { id: data.docId, rev: rev2 },
+      name: name2
     });
   });
 }
@@ -22359,8 +22518,8 @@ var ScimUserService = class {
   constructor(config) {
     this.get = async (params2) => {
       var _a;
-      const db = tenancy.getGlobalDB();
-      const builder2 = new db_exports.QueryBuilder(db.name, "user" /* USER */);
+      const db2 = tenancy.getGlobalDB();
+      const builder2 = new db_exports.QueryBuilder(db2.name, "user" /* USER */);
       builder2.setIndexBuilder(db_exports.searchIndexes.createUserIndex);
       builder2.setLimit(params2.pageSize);
       builder2.addEqual("scimInfo.isSync", true);
@@ -22496,9 +22655,9 @@ var fetch15 = async (ctx) => {
   ctx.body = { data: await fetch12() };
 };
 var destroy4 = async (ctx) => {
-  const { id, rev } = ctx.params;
+  const { id, rev: rev2 } = ctx.params;
   try {
-    await remove2(id, rev);
+    await remove2(id, rev2);
     ctx.body = { message: "Group deleted successfully" };
   } catch (err) {
     ctx.throw(err.status, err);
@@ -22543,13 +22702,13 @@ async function fetch16(ctx) {
   };
 }
 async function create3(ctx) {
-  const { name, production, development } = ctx.request.body;
-  await environmentVariables_exports2.update(name, { production, development });
+  const { name: name2, production, development } = ctx.request.body;
+  await environmentVariables_exports2.update(name2, { production, development });
   const environments = ["production" /* PRODUCTION */];
   if (production !== development) {
     environments.push("development" /* DEVELOPMENT */);
   }
-  await events_exports.environmentVariable.created(name, environments);
+  await events_exports.environmentVariable.created(name2, environments);
   ctx.status = 200;
 }
 async function update4(ctx) {
@@ -22711,7 +22870,7 @@ router3.post(
 
 // ../pro/packages/pro/src/api/controllers/apps/backups.ts
 init_src();
-var import_fs12 = __toESM(require("fs"));
+var import_fs13 = __toESM(require("fs"));
 async function checkAppID(ctx, appId) {
   if (!await utils_exports5.appExists(appId)) {
     ctx.throw(400, `Provided app ID: ${appId} - is invalid.`);
@@ -22795,9 +22954,9 @@ async function downloadBackup(ctx) {
   const appId = ctx.params.appId;
   await checkAppID(ctx, appId);
   const backupId = ctx.params.backupId;
-  const { metadata, path: path2 } = await backups_default2.downloadAppBackup(backupId);
-  ctx.attachment(`backup-${metadata.timestamp}.tar.gz`);
-  ctx.body = import_fs12.default.createReadStream(path2);
+  const { metadata: metadata2, path: path2 } = await backups_default2.downloadAppBackup(backupId);
+  ctx.attachment(`backup-${metadata2.timestamp}.tar.gz`);
+  ctx.body = import_fs13.default.createReadStream(path2);
 }
 
 // ../pro/packages/pro/src/api/routes/apps/backups.ts
@@ -22912,8 +23071,8 @@ var import_router6 = __toESM(require("@koa/router"));
 
 // ../pro/packages/pro/src/api/controllers/global/scim/users.ts
 var import_scim_patch = require("scim-patch");
-function tryGetQueryAsNumber(ctx, name) {
-  const value = ctx.request.query[name];
+function tryGetQueryAsNumber(ctx, name2) {
+  const value = ctx.request.query[name2];
   if (value === void 0) {
     return void 0;
   }
@@ -23459,11 +23618,11 @@ var datasources_default = {
 };
 
 // src/sdk/app/tables/index.ts
-async function getAllInternalTables(db) {
-  if (!db) {
-    db = context_exports.getAppDB();
+async function getAllInternalTables(db2) {
+  if (!db2) {
+    db2 = context_exports.getAppDB();
   }
-  const internalTables = await db.allDocs(
+  const internalTables = await db2.allDocs(
     getTableParams(null, {
       include_docs: true
     })
@@ -23475,7 +23634,7 @@ async function getAllInternalTables(db) {
   }));
 }
 async function getAllExternalTables(datasourceId) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const datasource2 = await datasources_default.get(datasourceId, { enriched: true });
   if (!datasource2 || !datasource2.entities) {
     throw "Datasource is not configured fully.";
@@ -23487,14 +23646,14 @@ async function getExternalTable(datasourceId, tableName) {
   return entities[tableName];
 }
 async function getTable(tableId) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   if (isExternalTable(tableId)) {
     let { datasourceId, tableName } = breakExternalTableId(tableId);
     const datasource2 = await datasources_default.get(datasourceId);
     const table = await getExternalTable(datasourceId, tableName);
     return { ...table, sql: isSQL(datasource2) };
   } else {
-    return db.get(tableId);
+    return db2.get(tableId);
   }
 }
 var tables_default = {
@@ -23514,10 +23673,10 @@ __export(webhook_exports, {
 function isWebhookID(id) {
   return id.startsWith(db_exports.DocumentType.WEBHOOK);
 }
-function newDoc(name, type, target) {
+function newDoc(name2, type, target) {
   return {
     live: true,
-    name,
+    name: name2,
     action: {
       type,
       target
@@ -23525,22 +23684,22 @@ function newDoc(name, type, target) {
   };
 }
 async function save7(webhook) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   if (webhook._id && isWebhookID(webhook._id)) {
-    await db.get(webhook._id);
+    await db2.get(webhook._id);
   } else {
     webhook._id = generateWebhookID();
   }
-  const response = await db.put(webhook);
+  const response = await db2.put(webhook);
   webhook._rev = response.rev;
   return webhook;
 }
-async function destroy6(id, rev) {
-  const db = context_exports.getAppDB();
+async function destroy6(id, rev2) {
+  const db2 = context_exports.getAppDB();
   if (!id || !isWebhookID(id)) {
     throw new Error("Provided webhook ID is not valid.");
   }
-  return await db.remove(id, rev);
+  return await db2.remove(id, rev2);
 }
 
 // src/sdk/app/automations/utils.ts
@@ -23620,14 +23779,14 @@ async function processUser(user, opts = {}) {
 }
 async function getGlobalUsers(userIds, opts) {
   const appId = context_exports.getAppId();
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   let globalUsers;
   if (userIds) {
-    globalUsers = (await db.allDocs(getMultiIDParams(userIds))).rows.map(
+    globalUsers = (await db2.allDocs(getMultiIDParams(userIds))).rows.map(
       (row) => row.doc
     );
   } else {
-    globalUsers = (await db.allDocs(
+    globalUsers = (await db2.allDocs(
       db_exports.getGlobalUserParams(null, {
         include_docs: true
       })
@@ -23654,7 +23813,7 @@ async function syncUsersToApp(appId, users2, groups) {
     return;
   }
   await context_exports.doInAppContext(appId, async () => {
-    const db = context_exports.getAppDB();
+    const db2 = context_exports.getAppDB();
     for (let user of users2) {
       let ctxUser = user;
       let deletedUser = false;
@@ -23669,9 +23828,9 @@ async function syncUsersToApp(appId, users2, groups) {
       if (roleId === roles_exports.BUILTIN_ROLE_IDS.PUBLIC) {
         roleId = void 0;
       }
-      let metadata;
+      let metadata2;
       try {
-        metadata = await db.get(metadataId);
+        metadata2 = await db2.get(metadataId);
       } catch (err) {
         if (err.status !== 404) {
           throw err;
@@ -23679,21 +23838,21 @@ async function syncUsersToApp(appId, users2, groups) {
         if (!roleId) {
           continue;
         } else if (!deletedUser) {
-          metadata = {
+          metadata2 = {
             tableId: InternalTables.USER_METADATA
           };
         }
       }
       if (deletedUser || !roleId) {
-        await db.remove(metadata);
+        await db2.remove(metadata2);
         continue;
       }
       if (roleId) {
-        metadata.roleId = roleId;
+        metadata2.roleId = roleId;
       }
-      let combined = sdk_default.users.combineMetadataAndUser(ctxUser, metadata);
+      let combined = sdk_default.users.combineMetadataAndUser(ctxUser, metadata2);
       if (combined) {
-        await db.put(combined);
+        await db2.put(combined);
       }
     }
   });
@@ -23748,7 +23907,7 @@ async function syncApp(appId, opts) {
     try {
       const replOpts = replication.appReplicateOpts();
       if (opts == null ? void 0 : opts.automationOnly) {
-        replOpts.filter = (doc) => doc._id.startsWith(db_exports.DocumentType.AUTOMATION);
+        replOpts.filter = (doc2) => doc2._id.startsWith(db_exports.DocumentType.AUTOMATION);
       }
       await replication.replicate(replOpts);
     } catch (err) {
@@ -23861,7 +24020,7 @@ function generateAttachmentFindParams(tableId, attachmentCols, bookmark) {
   return params2;
 }
 async function getRowsWithAttachments(appId, table) {
-  const db = db_exports.getDB(appId);
+  const db2 = db_exports.getDB(appId);
   const attachmentCols = [];
   for (let [key, column] of Object.entries(table.schema)) {
     if (column.type === "attachment" /* ATTACHMENT */) {
@@ -23878,7 +24037,7 @@ async function getRowsWithAttachments(appId, table) {
       attachmentCols,
       bookmark
     );
-    const resp = await db_exports.directCouchFind(db.name, params2);
+    const resp = await db_exports.directCouchFind(db2.name, params2);
     bookmark = resp.bookmark;
     rowsLength = resp.rows.length;
     const rows2 = resp.rows;
@@ -23893,13 +24052,13 @@ __export(rows_exports, {
   getAllInternalRows: () => getAllInternalRows
 });
 async function getAllInternalRows(appId) {
-  let db;
+  let db2;
   if (appId) {
-    db = db_exports.getDB(appId);
+    db2 = db_exports.getDB(appId);
   } else {
-    db = context_exports.getAppDB();
+    db2 = context_exports.getAppDB();
   }
-  const response = await db.allDocs(
+  const response = await db2.allDocs(
     getRowParams2(null, null, {
       include_docs: true
     })
@@ -23921,9 +24080,9 @@ __export(utils_exports8, {
   syncGlobalUsers: () => syncGlobalUsers
 });
 var import_lodash5 = require("lodash");
-function combineMetadataAndUser(user, metadata) {
+function combineMetadataAndUser(user, metadata2) {
   const metadataId = generateUserMetadataID2(user._id);
-  const found = Array.isArray(metadata) ? metadata.find((doc) => doc._id === metadataId) : metadata;
+  const found = Array.isArray(metadata2) ? metadata2.find((doc2) => doc2._id === metadataId) : metadata2;
   if (user.roleId == null || user.roleId === roles_exports.BUILTIN_ROLE_IDS.PUBLIC) {
     if (found == null ? void 0 : found._id) {
       return { ...found, _deleted: true };
@@ -23950,11 +24109,11 @@ function combineMetadataAndUser(user, metadata) {
   }
   return null;
 }
-async function rawUserMetadata(db) {
-  if (!db) {
-    db = context_exports.getAppDB();
+async function rawUserMetadata(db2) {
+  if (!db2) {
+    db2 = context_exports.getAppDB();
   }
-  return (await db.allDocs(
+  return (await db2.allDocs(
     getUserMetadataParams2(null, {
       include_docs: true
     })
@@ -23962,22 +24121,22 @@ async function rawUserMetadata(db) {
 }
 async function syncGlobalUsers() {
   const dbs = [context_exports.getDevAppDB(), context_exports.getProdAppDB()];
-  for (let db of dbs) {
-    if (!await db.exists()) {
+  for (let db2 of dbs) {
+    if (!await db2.exists()) {
       continue;
     }
-    const resp = await Promise.all([getGlobalUsers(), rawUserMetadata(db)]);
+    const resp = await Promise.all([getGlobalUsers(), rawUserMetadata(db2)]);
     const users2 = resp[0];
-    const metadata = resp[1];
+    const metadata2 = resp[1];
     const toWrite = [];
     for (let user of users2) {
-      const combined = combineMetadataAndUser(user, metadata);
+      const combined = combineMetadataAndUser(user, metadata2);
       if (combined) {
         toWrite.push(combined);
       }
     }
     let foundEmails = [];
-    for (let data of metadata) {
+    for (let data of metadata2) {
       if (!data._id) {
         continue;
       }
@@ -23990,7 +24149,7 @@ async function syncGlobalUsers() {
         foundEmails.push(data.email);
       }
     }
-    await db.bulkDocs(toWrite);
+    await db2.bulkDocs(toWrite);
   }
 }
 
@@ -24051,8 +24210,8 @@ var clientAppSocket;
 
 // src/sdk/plugins/plugins.ts
 async function fetch17(type) {
-  const db = tenancy.getGlobalDB();
-  const response = await db.allDocs(
+  const db2 = tenancy.getGlobalDB();
+  const response = await db2.allDocs(
     db_exports.getPluginParams(null, {
       include_docs: true
     })
@@ -24068,16 +24227,16 @@ async function fetch17(type) {
     return plugins2;
   }
 }
-async function processUploaded(plugin, source) {
+async function processUploaded(plugin, source2) {
   var _a, _b;
-  const { metadata, directory } = await fileUpload(plugin);
-  plugin_exports.validate(metadata == null ? void 0 : metadata.schema);
-  if (!environment_default.SELF_HOSTED && ((_a = metadata == null ? void 0 : metadata.schema) == null ? void 0 : _a.type) !== "component" /* COMPONENT */) {
+  const { metadata: metadata2, directory: directory2 } = await fileUpload(plugin);
+  plugin_exports.validate(metadata2 == null ? void 0 : metadata2.schema);
+  if (!environment_default.SELF_HOSTED && ((_a = metadata2 == null ? void 0 : metadata2.schema) == null ? void 0 : _a.type) !== "component" /* COMPONENT */) {
     throw new Error("Only component plugins are supported outside of self-host");
   }
-  const doc = await sdk_exports.plugins.storePlugin(metadata, directory, source);
-  (_b = clientAppSocket) == null ? void 0 : _b.emit("plugin-update", { name: doc.name, hash: doc.hash });
-  return doc;
+  const doc2 = await sdk_exports.plugins.storePlugin(metadata2, directory2, source2);
+  (_b = clientAppSocket) == null ? void 0 : _b.emit("plugin-update", { name: doc2.name, hash: doc2.hash });
+  return doc2;
 }
 
 // src/sdk/plugins/index.ts
@@ -24141,13 +24300,13 @@ if (process.arch && !process.arch.startsWith("arm") && oracle_default.integratio
   DEFINITIONS2["ORACLE" /* ORACLE */] = oracle_default.schema;
   INTEGRATIONS["ORACLE" /* ORACLE */] = oracle_default.integration;
 }
-async function getDefinition(source) {
-  const definition = DEFINITIONS2[source];
+async function getDefinition(source2) {
+  const definition = DEFINITIONS2[source2];
   if (definition) {
     return definition;
   }
   const allDefinitions = await getDefinitions();
-  return allDefinitions[source];
+  return allDefinitions[source2];
 }
 async function getDefinitions() {
   const pluginSchemas = {};
@@ -24350,8 +24509,8 @@ var QueryRunner = class {
     return { rows: rows2, keys: keys2, info, extra, pagination: pagination3 };
   }
   async runAnotherQuery(queryId, parameters) {
-    const db = context_exports.getAppDB();
-    const query = await db.get(queryId);
+    const db2 = context_exports.getAppDB();
+    const query = await db2.get(queryId);
     const datasource2 = await sdk_default.datasources.get(query.datasourceId, {
       enriched: true
     });
@@ -24393,14 +24552,14 @@ var QueryRunner = class {
   }
   async getDynamicVariable(variable) {
     let { parameters } = this;
-    const queryId = variable.queryId, name = variable.name;
-    let value = await utils_default.checkCacheForDynamicVariable(queryId, name);
+    const queryId = variable.queryId, name2 = variable.name;
+    let value = await utils_default.checkCacheForDynamicVariable(queryId, name2);
     if (!value) {
       value = this.queryResponse[queryId] ? this.queryResponse[queryId] : await this.runAnotherQuery(queryId, parameters);
       this.queryResponse[queryId] = value;
-      await utils_default.storeDynamicVariable(queryId, name, value);
+      await utils_default.storeDynamicVariable(queryId, name2, value);
     } else {
-      this.cachedVariables.push({ queryId, name });
+      this.cachedVariables.push({ queryId, name: name2 });
     }
     return value;
   }