@budibase/server 2.6.19-alpha.14 → 2.6.19-alpha.16

package/dist/automation.js

@@ -4,8 +4,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn2, res) => function __init() {
+  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
 };
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
@@ -2027,9 +2027,9 @@ async function directCouchUrlCall({
   return await (0, import_node_fetch.default)(checkSlashesInUrl(encodeURI(url)), params2);
 }
 async function directCouchQuery(path2, method = "GET", body2) {
-  const response = await directCouchCall(path2, method, body2);
-  if (response.status < 300) {
-    return await response.json();
+  const response2 = await directCouchCall(path2, method, body2);
+  if (response2.status < 300) {
+    return await response2.json();
   } else {
     throw "Cannot connect to CouchDB instance";
   }
@@ -2050,27 +2050,27 @@ function init(opts) {
 }
 function getPouchDB(dbName, opts) {
   checkInitialised();
-  const db = new Pouch(dbName, opts);
-  const dbPut = db.put;
-  db.put = async (doc, options2 = {}) => {
+  const db2 = new Pouch(dbName, opts);
+  const dbPut = db2.put;
+  db2.put = async (doc, options2 = {}) => {
     if (!doc.createdAt) {
       doc.createdAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     doc.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     return dbPut(doc, 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) {
   }
 }
@@ -2182,12 +2182,12 @@ var init_DatabaseImpl = __esm({
         DatabaseImpl.nano = buildNano(couchInfo);
       }
       async exists() {
-        const response = await directCouchUrlCall({
+        const response2 = await directCouchUrlCall({
           url: `${this.couchInfo.url}/${this.name}`,
           method: "HEAD",
           cookie: this.couchInfo.cookie
         });
-        return response.status === 200;
+        return response2.status === 200;
       }
       nano() {
         return this.instanceNano || DatabaseImpl.nano;
@@ -2221,14 +2221,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();
+        const db2 = await this.checkSetup();
         let _id;
         let _rev;
         if (isDocument(idOrDoc)) {
@@ -2241,7 +2241,7 @@ var init_DatabaseImpl = __esm({
         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) {
@@ -2253,7 +2253,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();
         }
@@ -2270,20 +2270,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 [database, view] = viewName.split("/");
-        return this.updateOutput(() => db.view(database, view, params2));
+        const db2 = await this.checkSetup();
+        const [database, view2] = viewName.split("/");
+        return this.updateOutput(() => db2.view(database, view2, params2));
       }
       async destroy() {
         try {
@@ -2297,8 +2297,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
@@ -2341,8 +2341,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()) {
@@ -2690,11 +2690,11 @@ function getRedisOptions() {
   }
   return { opts, host, 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);
@@ -2905,8 +2905,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() {
@@ -2923,8 +2923,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");
@@ -2935,32 +2935,32 @@ 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 get(key) {
-        const db = this._db;
-        let response = await this.getClient().get(addDbPrefix(db, key));
-        if (response != null && response.key) {
-          response.key = key;
+        const db2 = this._db;
+        let response2 = await this.getClient().get(addDbPrefix(db2, key));
+        if (response2 != null && response2.key) {
+          response2.key = key;
         }
         try {
-          return JSON.parse(response);
+          return JSON.parse(response2);
         } catch (err) {
-          return response;
+          return response2;
         }
       }
       async bulkGet(keys2) {
-        const db = this._db;
+        const db2 = this._db;
         if (keys2.length === 0) {
           return {};
         }
-        const prefixedKeys = keys2.map((key) => addDbPrefix(db, key));
-        let response = await this.getClient().mget(prefixedKeys);
-        if (Array.isArray(response)) {
+        const prefixedKeys = keys2.map((key) => addDbPrefix(db2, key));
+        let response2 = await this.getClient().mget(prefixedKeys);
+        if (Array.isArray(response2)) {
           let final = {};
           let count = 0;
-          for (let result of response) {
+          for (let result of response2) {
             if (result) {
               let parsed;
               try {
@@ -2974,33 +2974,33 @@ var init_redis = __esm({
           }
           return final;
         } else {
-          throw new Error(`Invalid response: ${response}`);
+          throw new Error(`Invalid response: ${response2}`);
         }
       }
       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();
@@ -3376,8 +3376,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 {
@@ -3393,14 +3393,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;
     }
@@ -3413,9 +3413,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
   });
@@ -3425,7 +3425,7 @@ async function removeUser(user) {
       _deleted: true
     };
   });
-  await db.bulkDocs(toDelete);
+  await db2.bulkDocs(toDelete);
 }
 var init_users3 = __esm({
   "../backend-core/src/platform/users.ts"() {
@@ -3648,7 +3648,7 @@ var init_logger = __esm({
           ...contextObject
         };
         if (objects.length) {
-          const data = {};
+          const data2 = {};
           let dataIndex = 0;
           for (let i = 0; i < objects.length; i++) {
             const object = objects[i];
@@ -3657,12 +3657,12 @@ var init_logger = __esm({
               delete object._logKey;
               mergingObject[logKey] = object;
             } else {
-              data[dataIndex] = object;
+              data2[dataIndex] = object;
               dataIndex++;
             }
           }
-          if (Object.keys(data).length) {
-            mergingObject.data = data;
+          if (Object.keys(data2).length) {
+            mergingObject.data = data2;
           }
         }
         return [mergingObject, message];
@@ -3762,8 +3762,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) {
@@ -3863,16 +3863,16 @@ var init_accounts3 = __esm({
       const payload = {
         email
       };
-      const response = await api.post(`/api/accounts/search`, {
+      const response2 = await api.post(`/api/accounts/search`, {
         body: payload,
         headers: {
           ["x-budibase-api-key" /* API_KEY */]: environment_default2.ACCOUNT_PORTAL_API_KEY
         }
       });
-      if (response.status !== 200) {
+      if (response2.status !== 200) {
         throw new Error(`Error getting account by email ${email}`);
       }
-      const json2 = await response.json();
+      const json2 = await response2.json();
       return json2[0];
     };
   }
@@ -3892,8 +3892,8 @@ __export(user_exports, {
   invalidateUser: () => invalidateUser
 });
 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);
@@ -4155,8 +4155,8 @@ async function getAllApps({
   if (appPromises.length === 0) {
     return [];
   } else {
-    const response = await Promise.allSettled(appPromises);
-    const apps2 = response.filter(
+    const response2 = await Promise.allSettled(appPromises);
+    const apps2 = response2.filter(
       (result) => result.status === "fulfilled" && result.value != null
     ).map(({ value }) => value);
     if (!all) {
@@ -4197,13 +4197,13 @@ 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 }
   );
 }
-function pagination(data, pageSize, {
+function pagination(data2, pageSize, {
   paginate,
   property,
   getKey
@@ -4212,18 +4212,18 @@ function pagination(data, pageSize, {
   property: "_id"
 }) {
   if (!paginate) {
-    return { data, hasNextPage: false };
+    return { data: data2, hasNextPage: false };
   }
-  const hasNextPage = data.length > pageSize;
+  const hasNextPage = data2.length > pageSize;
   let nextPage = void 0;
   if (!getKey) {
     getKey = (doc) => property ? doc == null ? void 0 : doc[property] : doc == null ? void 0 : doc._id;
   }
   if (hasNextPage) {
-    nextPage = getKey(data[pageSize]);
+    nextPage = getKey(data2[pageSize]);
   }
   return {
-    data: data.slice(0, pageSize),
+    data: data2.slice(0, pageSize),
     hasNextPage,
     nextPage
   };
@@ -4250,56 +4250,56 @@ 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();
   }
-  const view = {
+  const view2 = {
     map: viewJs
   };
   designDoc.views = {
     ...designDoc.views,
-    [viewName]: view
+    [viewName]: view2
   };
   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;
     }
   }
 }
-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);
-    return response;
+    const response2 = await db2.query(`database/${viewName}`, params2);
+    return response2;
   } 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;
     }
@@ -4307,8 +4307,8 @@ async function queryViewRaw(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()) {
@@ -4318,9 +4318,9 @@ async function createPlatformView(viewJs, viewName) {
   }
 }
 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);
 }
 var DESIGN_DB, createNewUserEmailView, createUserAppView, createApiKeyView, createUserBuildersView, queryView, createPlatformAccountEmailView, createPlatformUserView, queryPlatformView, CreateFuncByName, queryGlobalView;
 var init_views = __esm({
@@ -4331,16 +4331,16 @@ var init_views = __esm({
     init_environment3();
     DESIGN_DB = "_design/database";
     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 */);
     };
     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)) {
@@ -4349,29 +4349,29 @@ var init_views = __esm({
       }
     }
   }`;
-      await createView(db, viewJs, "by_app" /* USER_BY_APP */);
+      await createView(db2, viewJs, "by_app" /* USER_BY_APP */);
     };
     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 */);
     };
     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 */);
     };
-    queryView = async (viewName, params2, db, createFunc, opts) => {
-      const response = await queryViewRaw(viewName, params2, db, createFunc, opts);
-      const rows2 = response.rows;
+    queryView = async (viewName, params2, db2, createFunc, opts) => {
+      const response2 = await queryViewRaw(viewName, params2, db2, createFunc, opts);
+      const rows2 = response2.rows;
       const docs = rows2.map(
         (row) => params2.include_docs ? row.doc : row.value
       );
@@ -4402,9 +4402,9 @@ var init_views = __esm({
         ["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);
       });
     };
     CreateFuncByName = {
@@ -4413,12 +4413,12 @@ var init_views = __esm({
       ["by_builders" /* USER_BY_BUILDERS */]: createUserBuildersView,
       ["by_app" /* USER_BY_APP */]: createUserAppView
     };
-    queryGlobalView = async (viewName, params2, db, opts) => {
-      if (!db) {
-        db = getGlobalDB();
+    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);
     };
   }
 });
@@ -4503,17 +4503,17 @@ function removeKeyNumbering(key) {
   }
 }
 async function runQuery(url, body2, cookie) {
-  const response = await (0, import_node_fetch3.default)(url, {
+  const response2 = await (0, import_node_fetch3.default)(url, {
     body: JSON.stringify(body2),
     method: "POST",
     headers: {
       Authorization: cookie
     }
   });
-  if (response.status === 404) {
-    throw response;
+  if (response2.status === 404) {
+    throw response2;
   }
-  const json2 = await response.json();
+  const json2 = await response2.json();
   let output = {
     rows: [],
     totalRows: 0
@@ -5046,16 +5046,16 @@ var init_lucene = __esm({
 
 // ../backend-core/src/db/searchIndexes/searchIndexes.ts
 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" };
     }
   }
-  const fn = function(user) {
+  const fn2 = function(user) {
     if (user._id && !user._id.startsWith("us_")) {
       return;
     }
@@ -5088,14 +5088,14 @@ async function createUserIndex() {
   };
   designDoc.indexes = {
     ["user" /* USER */]: {
-      index: fn.toString(),
+      index: fn2.toString(),
       analyzer: {
         default: "keyword",
         name: "perfield"
       }
     }
   };
-  await db.put(designDoc);
+  await db2.put(designDoc);
 }
 var init_searchIndexes = __esm({
   "../backend-core/src/db/searchIndexes/searchIndexes.ts"() {
@@ -5230,8 +5230,8 @@ __export(appMetadata_exports, {
 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 }
   );
@@ -5301,18 +5301,18 @@ 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() };
 }
-async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
+async function put(db2, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
   const cache2 = await getCache();
   const key = doc._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;
@@ -5326,11 +5326,11 @@ async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
       },
       async () => {
         const writeDb = async (toWrite) => {
-          const response = await db.put(toWrite, { force: true });
+          const response2 = await db2.put(toWrite, { force: true });
           output = {
             ...doc,
-            _id: response.id,
-            _rev: response.rev
+            _id: response2.id,
+            _rev: response2.rev
           };
         };
         try {
@@ -5350,22 +5350,22 @@ 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);
+    const doc = await db2.get(id);
     cacheItem = makeCacheItem(doc);
     await cache2.store(cacheKey, cacheItem);
   }
   return cacheItem.doc;
 }
-async function remove(db, docOrId, rev) {
+async function remove(db2, docOrId, rev) {
   const cache2 = await getCache();
   if (!docOrId) {
     throw new Error("No ID/Rev provided.");
@@ -5373,9 +5373,9 @@ async function remove(db, docOrId, rev) {
   const id = typeof docOrId === "string" ? docOrId : docOrId._id;
   rev = typeof docOrId === "string" ? rev : 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, rev);
   }
 }
 var DEFAULT_WRITE_RATE_MS, CACHE, Writethrough;
@@ -5389,8 +5389,8 @@ var init_writethrough = __esm({
     DEFAULT_WRITE_RATE_MS = 1e4;
     CACHE = null;
     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) {
@@ -5437,9 +5437,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;
@@ -5448,8 +5448,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 */);
@@ -5790,12 +5790,12 @@ var init_PosthogProcessor = __esm({
         }
         this.posthog.identify(payload);
       }
-      async identifyGroup(group, timestamp) {
+      async identifyGroup(group2, timestamp) {
         const payload = {
-          distinctId: group.id,
-          groupType: group.type,
-          groupKey: group.id,
-          properties: group
+          distinctId: group2.id,
+          groupType: group2.type,
+          groupKey: group2.id,
+          properties: group2
         };
         if (timestamp) {
           payload.timestamp = new Date(timestamp);
@@ -5853,9 +5853,9 @@ var init_AnalyticsProcessor = __esm({
           await this.posthog.identify(identity, timestamp);
         }
       }
-      async identifyGroup(group, timestamp) {
+      async identifyGroup(group2, timestamp) {
         if (this.posthog) {
-          await this.posthog.identifyGroup(group, timestamp);
+          await this.posthog.identifyGroup(group2, timestamp);
         }
       }
       shutdown() {
@@ -5886,11 +5886,11 @@ var init_LoggingProcessor = __esm({
         }
         console.log(`[audit] identified`, identity);
       }
-      async identifyGroup(group, timestamp) {
+      async identifyGroup(group2, timestamp) {
         if (skipLogging) {
           return;
         }
-        console.log(`[audit] group identified`, group);
+        console.log(`[audit] group identified`, group2);
       }
       shutdown() {
       }
@@ -5899,12 +5899,12 @@ var init_LoggingProcessor = __esm({
 });
 
 // ../backend-core/src/utils/hashing.ts
-async function hash(data) {
+async function hash(data2) {
   const salt = await bcrypt.genSalt(SALT_ROUNDS);
-  return bcrypt.hash(data, salt);
+  return bcrypt.hash(data2, salt);
 }
-async function compare(data, encrypted) {
-  return bcrypt.compare(data, encrypted);
+async function compare(data2, encrypted) {
+  return bcrypt.compare(data2, encrypted);
 }
 var bcrypt, SALT_ROUNDS;
 var init_hashing = __esm({
@@ -6436,9 +6436,9 @@ var init_AuditLogsProcessor = __esm({
     init_environment3();
     _AuditLogsProcessor = class {
       // can't use constructor as need to return promise
-      static init(fn) {
+      static init(fn2) {
         _AuditLogsProcessor.auditLogsEnabled = true;
-        const writeAuditLogs = fn;
+        const writeAuditLogs = fn2;
         _AuditLogsProcessor.auditLogQueue = createQueue(
           "auditLogQueue" /* AUDIT_LOG */
         );
@@ -6483,7 +6483,7 @@ var init_AuditLogsProcessor = __esm({
       }
       async identify(identity, timestamp) {
       }
-      async identifyGroup(group, timestamp) {
+      async identifyGroup(group2, timestamp) {
       }
       shutdown() {
         var _a;
@@ -6748,15 +6748,15 @@ var init_identification2 = __esm({
       const hosting = getHostingFromEnv();
       const version = environment_default2.VERSION;
       const environment3 = getDeploymentEnvironment();
-      const group = {
+      const group2 = {
         id,
         type,
         hosting,
         version,
         environment: environment3
       };
-      await identifyGroup(group, timestamp);
-      await identify({ ...group, id: `$${type}_${id}` }, timestamp);
+      await identifyGroup(group2, timestamp);
+      await identify({ ...group2, id: `$${type}_${id}` }, timestamp);
     };
     identifyTenantGroup = async (tenantId, account, timestamp) => {
       const id = await getEventTenantId(tenantId);
@@ -6773,7 +6773,7 @@ var init_identification2 = __esm({
       } else {
         hosting = getHostingFromEnv();
       }
-      const group = {
+      const group2 = {
         id,
         type,
         hosting,
@@ -6782,8 +6782,8 @@ var init_identification2 = __esm({
         profession,
         companySize
       };
-      await identifyGroup(group, timestamp);
-      await identify({ ...group, id: `$${type}_${id}` }, timestamp);
+      await identifyGroup(group2, timestamp);
+      await identify({ ...group2, id: `$${type}_${id}` }, timestamp);
     };
     identifyUser = async (user, account, timestamp) => {
       var _a, _b;
@@ -6847,8 +6847,8 @@ var init_identification2 = __esm({
     identify = async (identity, timestamp) => {
       await processors.identify(identity, timestamp);
     };
-    identifyGroup = async (group, timestamp) => {
-      await processors.identifyGroup(group, timestamp);
+    identifyGroup = async (group2, timestamp) => {
+      await processors.identifyGroup(group2, timestamp);
     };
     getDeploymentEnvironment = () => {
       if (environment_default2.isDev()) {
@@ -6877,7 +6877,7 @@ var init_identification2 = __esm({
     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) {
@@ -6885,7 +6885,7 @@ var init_identification2 = __esm({
           } else {
             uniqueTenantId = `${newid()}_${tenantId}`;
             config.config.uniqueTenantId = uniqueTenantId;
-            await db.put(config);
+            await db2.put(config);
             return uniqueTenantId;
           }
         });
@@ -8077,21 +8077,21 @@ var init_user9 = __esm({
 });
 
 // ../backend-core/src/events/publishers/view.ts
-async function created12(view, timestamp) {
+async function created12(view2, timestamp) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:created" /* VIEW_CREATED */, properties, timestamp);
 }
-async function updated7(view) {
+async function updated7(view2) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:updated" /* VIEW_UPDATED */, properties);
 }
-async function deleted11(view) {
+async function deleted11(view2) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:deleted" /* VIEW_DELETED */, properties);
 }
@@ -8102,35 +8102,35 @@ async function exported3(table, format) {
   };
   await publishEvent("view:exported" /* VIEW_EXPORTED */, properties);
 }
-async function filterCreated(view, timestamp) {
+async function filterCreated(view2, timestamp) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:filter:created" /* VIEW_FILTER_CREATED */, properties, timestamp);
 }
-async function filterUpdated(view) {
+async function filterUpdated(view2) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:filter:updated" /* VIEW_FILTER_UPDATED */, properties);
 }
-async function filterDeleted(view) {
+async function filterDeleted(view2) {
   const properties = {
-    tableId: view.tableId
+    tableId: view2.tableId
   };
   await publishEvent("view:filter:deleted" /* VIEW_FILTER_DELETED */, properties);
 }
-async function calculationCreated(view, timestamp) {
+async function calculationCreated(view2, timestamp) {
   const properties = {
-    tableId: view.tableId,
-    calculation: view.calculation
+    tableId: view2.tableId,
+    calculation: view2.calculation
   };
   await publishEvent("view:calculation:created" /* VIEW_CALCULATION_CREATED */, properties, timestamp);
 }
-async function calculationUpdated(view) {
+async function calculationUpdated(view2) {
   const properties = {
-    tableId: view.tableId,
-    calculation: view.calculation
+    tableId: view2.tableId,
+    calculation: view2.calculation
   };
   await publishEvent("view:calculation:updated" /* VIEW_CALCULATION_UPDATED */, properties);
 }
@@ -8266,54 +8266,54 @@ var init_backfill3 = __esm({
 });
 
 // ../backend-core/src/events/publishers/group.ts
-async function created13(group, timestamp) {
+async function created13(group2, timestamp) {
   const properties = {
-    groupId: group._id,
+    groupId: group2._id,
     viaScim: isScim(),
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:created" /* USER_GROUP_CREATED */, properties, timestamp);
 }
-async function updated8(group) {
+async function updated8(group2) {
   const properties = {
-    groupId: group._id,
+    groupId: group2._id,
     viaScim: isScim(),
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:updated" /* USER_GROUP_UPDATED */, properties);
 }
-async function deleted12(group) {
+async function deleted12(group2) {
   const properties = {
-    groupId: group._id,
+    groupId: group2._id,
     viaScim: isScim(),
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:deleted" /* USER_GROUP_DELETED */, properties);
 }
-async function usersAdded(count, group) {
+async function usersAdded(count, group2) {
   const properties = {
     count,
-    groupId: group._id,
+    groupId: group2._id,
     viaScim: isScim(),
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:user_added" /* USER_GROUP_USERS_ADDED */, properties);
 }
-async function usersDeleted(count, group) {
+async function usersDeleted(count, group2) {
   const properties = {
     count,
-    groupId: group._id,
+    groupId: group2._id,
     viaScim: isScim(),
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:users_deleted" /* USER_GROUP_USERS_REMOVED */, properties);
@@ -8325,12 +8325,12 @@ async function createdOnboarding(groupId) {
   };
   await publishEvent("user_group:onboarding_added" /* USER_GROUP_ONBOARDING */, properties);
 }
-async function permissionsEdited(group) {
+async function permissionsEdited(group2) {
   const properties = {
-    permissions: group.roles,
-    groupId: group._id,
+    permissions: group2.roles,
+    groupId: group2._id,
     audited: {
-      name: group.name
+      name: group2.name
     }
   };
   await publishEvent("user_group:permissions_edited" /* USER_GROUP_PERMISSIONS_EDITED */, properties);
@@ -8665,20 +8665,20 @@ function removeUserPassword(users2) {
   return 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);
   }
   return user;
 }
 async function getUserCount() {
-  const response = await queryGlobalViewRaw("by_email2" /* USER_BY_EMAIL */, {
+  const response2 = await queryGlobalViewRaw("by_email2" /* USER_BY_EMAIL */, {
     limit: 0,
     // to be as fast as possible - we just want the total rows count
     include_docs: false
   });
-  return response.total_rows;
+  return response2.total_rows;
 }
 var bulkGetGlobalUsersById, getAllUserIds, bulkUpdateGlobalUsers, getGlobalUserByEmail, searchGlobalUsersByApp, searchGlobalUsersByAppAccess, getGlobalUserByAppPage, searchGlobalUsersByEmail, PAGE_LIMIT, paginatedUsers;
 var init_users4 = __esm({
@@ -8687,8 +8687,8 @@ var init_users4 = __esm({
     init_context2();
     init_context2();
     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);
@@ -8698,30 +8698,30 @@ var init_users4 = __esm({
       return users2;
     };
     getAllUserIds = async () => {
-      const db = getGlobalDB();
+      const db2 = getGlobalDB();
       const startKey = `${"us" /* USER */}${SEPARATOR}`;
-      const response = await db.allDocs({
+      const response2 = await db2.allDocs({
         startkey: startKey,
         endkey: `${startKey}${UNICODE_MAX}`
       });
-      return response.rows.map((row) => row.id);
+      return response2.rows.map((row) => row.id);
     };
     bulkUpdateGlobalUsers = async (users2) => {
-      const db = getGlobalDB();
-      return await db.bulkDocs(users2);
+      const db2 = getGlobalDB();
+      return await db2.bulkDocs(users2);
     };
     getGlobalUserByEmail = async (email, opts) => {
       if (email == null) {
         throw "Must supply an email address to view";
       }
-      const response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
+      const response2 = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
         key: email.toLowerCase(),
         include_docs: true
       });
-      if (Array.isArray(response)) {
+      if (Array.isArray(response2)) {
         throw new Error(`Multiple users found with email address: ${email}`);
       }
-      let user = response;
+      let user = response2;
       if (opts == null ? void 0 : opts.cleanup) {
         user = removeUserPassword(user);
       }
@@ -8735,11 +8735,11 @@ var init_users4 = __esm({
         include_docs: true
       });
       params2.startkey = opts && opts.startkey ? opts.startkey : params2.startkey;
-      let response = await queryGlobalView("by_app" /* USER_BY_APP */, params2);
-      if (!response) {
-        response = [];
+      let response2 = await queryGlobalView("by_app" /* USER_BY_APP */, params2);
+      if (!response2) {
+        response2 = [];
       }
-      let users2 = Array.isArray(response) ? response : [response];
+      let users2 = Array.isArray(response2) ? response2 : [response2];
       if (getOpts == null ? void 0 : getOpts.cleanup) {
         users2 = removeUserPassword(users2);
       }
@@ -8787,15 +8787,15 @@ var init_users4 = __esm({
       }
       const lcEmail = email.toLowerCase();
       const startkey = opts && opts.startkey ? opts.startkey : lcEmail;
-      let response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
+      let response2 = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
         ...opts,
         startkey,
         endkey: `${lcEmail}${UNICODE_MAX}`
       });
-      if (!response) {
-        response = [];
+      if (!response2) {
+        response2 = [];
       }
-      let users2 = Array.isArray(response) ? response : [response];
+      let users2 = Array.isArray(response2) ? response2 : [response2];
       if (getOpts == null ? void 0 : getOpts.cleanup) {
         users2 = removeUserPassword(users2);
       }
@@ -8807,7 +8807,7 @@ var init_users4 = __esm({
       email,
       appId
     } = {}) => {
-      const db = getGlobalDB();
+      const db2 = getGlobalDB();
       const opts = {
         include_docs: true,
         limit: PAGE_LIMIT + 1
@@ -8823,8 +8823,8 @@ var init_users4 = __esm({
         userList = await searchGlobalUsersByEmail(email, opts);
         property = "email";
       } else {
-        const response = await db.allDocs(getGlobalUserParams(null, opts));
-        userList = response.rows.map((row) => row.doc);
+        const response2 = await db2.allDocs(getGlobalUserParams(null, opts));
+        userList = response2.rows.map((row) => row.doc);
       }
       return pagination(userList, PAGE_LIMIT, {
         paginate: true,
@@ -8979,8 +8979,8 @@ 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) {
@@ -9031,10 +9031,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
         })
@@ -9474,9 +9474,9 @@ async function getProfilePictureUrl(user, details) {
   var _a;
   const pictureUrl = (_a = details.profile) == null ? void 0 : _a._json.picture;
   if (pictureUrl) {
-    const response = await (0, import_node_fetch4.default)(pictureUrl);
-    if (response.status === 200) {
-      const type = response.headers.get("content-type");
+    const response2 = await (0, import_node_fetch4.default)(pictureUrl);
+    if (response2.status === 200) {
+      const type = response2.headers.get("content-type");
       if (type.startsWith("image/")) {
         return pictureUrl;
       }
@@ -9664,13 +9664,13 @@ async function fetchStrategyConfig(oidcConfig, callbackUrl) {
         "Configuration invalid. Must contain clientID, clientSecret, callbackUrl and configUrl"
       );
     }
-    const response = await (0, import_node_fetch5.default)(configUrl);
-    if (!response.ok) {
+    const response2 = await (0, import_node_fetch5.default)(configUrl);
+    if (!response2.ok) {
       throw new Error(
-        `Unexpected response when fetching openid-configuration: ${response.statusText}`
+        `Unexpected response when fetching openid-configuration: ${response2.statusText}`
       );
     }
-    const body2 = await response.json();
+    const body2 = await response2.json();
     return {
       issuer: body2.issuer,
       authorizationURL: body2.authorization_endpoint,
@@ -9753,10 +9753,10 @@ 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) => {
+      await doWithDB(authStateCookie.appId, async (db2) => {
         let datasource2;
         try {
-          datasource2 = await db.get(authStateCookie.datasourceId);
+          datasource2 = await db2.get(authStateCookie.datasourceId);
         } catch (err2) {
           if (err2.status === 404) {
             ctx.redirect(baseUrl);
@@ -9766,7 +9766,7 @@ async function postAuth(passport2, ctx, next) {
           datasource2.config = {};
         }
         datasource2.config.auth = { type: "google", ...tokens };
-        await db.put(datasource2);
+        await db2.put(datasource2);
         ctx.redirect(`${baseUrl}/datasource/${authStateCookie.datasourceId}`);
       });
     }
@@ -9986,13 +9986,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;
@@ -10563,8 +10563,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;
     }
@@ -10572,7 +10572,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);
@@ -10959,11 +10959,11 @@ var init_objectStore = __esm({
         Bucket: sanitizeBucket(bucketName),
         Key: sanitizeKey(filepath)
       };
-      const response = await objectStore.getObject(params2).promise();
-      if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
-        return response.Body.toString("utf8");
+      const response2 = await objectStore.getObject(params2).promise();
+      if (STRING_CONTENT_TYPES.includes(response2.ContentType)) {
+        return response2.Body.toString("utf8");
       } else {
-        return response.Body;
+        return response2.Body;
       }
     };
     listAllObjects = async (bucketName, path2) => {
@@ -10981,11 +10981,11 @@ var init_objectStore = __esm({
         if (token) {
           params2.ContinuationToken = token;
         }
-        const response = await list(params2);
-        if (response.Contents) {
-          objects = objects.concat(response.Contents);
+        const response2 = await list(params2);
+        if (response2.Contents) {
+          objects = objects.concat(response2.Contents);
         }
-        isTruncated = !!response.IsTruncated;
+        isTruncated = !!response2.IsTruncated;
       } while (isTruncated);
       return objects;
     };
@@ -11009,9 +11009,9 @@ var init_objectStore = __esm({
     retrieveToTmp = async (bucketName, filepath) => {
       bucketName = sanitizeBucket(bucketName);
       filepath = sanitizeKey(filepath);
-      const data = await retrieve(bucketName, filepath);
+      const data2 = await retrieve(bucketName, filepath);
       const outputPath = (0, import_path3.join)(budibaseTempDir(), (0, import_uuid3.v4)());
-      import_fs3.default.writeFileSync(outputPath, data);
+      import_fs3.default.writeFileSync(outputPath, data2);
       return outputPath;
     };
     retrieveDirectory = async (bucketName, path2) => {
@@ -11024,13 +11024,13 @@ var init_objectStore = __esm({
       let count = 0;
       for (let obj of objects) {
         const filename = obj.Key;
-        const data = fullObjects[count++];
+        const data2 = fullObjects[count++];
         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_fs3.default.writeFileSync((0, import_path3.join)(writePath, ...possiblePath), data);
+        import_fs3.default.writeFileSync((0, import_path3.join)(writePath, ...possiblePath), data2);
       }
       return writePath;
     };
@@ -11099,21 +11099,21 @@ var init_objectStore = __esm({
     };
     downloadTarballDirect = async (url, path2, headers = {}) => {
       path2 = sanitizeKey(path2);
-      const response = await (0, import_node_fetch6.default)(url, { headers });
-      if (!response.ok) {
-        throw new Error(`unexpected response ${response.statusText}`);
+      const response2 = await (0, import_node_fetch6.default)(url, { headers });
+      if (!response2.ok) {
+        throw new Error(`unexpected response ${response2.statusText}`);
       }
-      await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path2));
+      await streamPipeline(response2.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path2));
     };
     downloadTarball = async (url, bucketName, path2) => {
       bucketName = sanitizeBucket(bucketName);
       path2 = sanitizeKey(path2);
-      const response = await (0, import_node_fetch6.default)(url);
-      if (!response.ok) {
-        throw new Error(`unexpected response ${response.statusText}`);
+      const response2 = await (0, import_node_fetch6.default)(url);
+      if (!response2.ok) {
+        throw new Error(`unexpected response ${response2.statusText}`);
       }
       const tmpPath = (0, import_path3.join)(budibaseTempDir(), path2);
-      await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+      await streamPipeline(response2.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
       if (!environment_default2.isTest() && environment_default2.SELF_HOSTED) {
         await uploadDirectory(bucketName, tmpPath, path2);
       }
@@ -11724,11 +11724,11 @@ var init_quotas2 = __esm({
       return new Writethrough2(tenancy.getGlobalDB());
     };
     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
           );
@@ -11740,17 +11740,17 @@ var init_quotas2 = __esm({
       }
     };
     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);
-          usage._rev = response.rev;
+          const response2 = await db2.put(usage);
+          usage._rev = response2.rev;
         } else {
           throw err;
         }
@@ -11768,7 +11768,7 @@ var init_quotas2 = __esm({
       return setAllUsage(name, type, { total: value });
     };
     setUsagePerApp = async (appValues, name, type) => {
-      const db = getDB2();
+      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)) {
@@ -11785,8 +11785,8 @@ var init_quotas2 = __esm({
           }
         );
       }
-      const response = await db.put(quotaUsage);
-      quotaUsage._rev = response.rev;
+      const response2 = await db2.put(quotaUsage);
+      quotaUsage._rev = response2.rev;
       return quotaUsage;
     };
     setBreakdown = (monthUsage, name, id, values) => {
@@ -11913,11 +11913,11 @@ var init_quotas2 = __esm({
       return setAppUsageValue(quotaUsage, name, type, opts, values);
     };
     setAllUsage = async (name, type, values, opts = {}) => {
-      const db = getDB2();
+      const db2 = getDB2();
       let quotaUsage = await getQuotaUsage();
       quotaUsage = coreUsageUpdate(quotaUsage, name, type, values, opts);
-      const response = await db.put(quotaUsage);
-      quotaUsage._rev = response.rev;
+      const response2 = await db2.put(quotaUsage);
+      quotaUsage._rev = response2.rev;
       return quotaUsage;
     };
     getCurrentUsageValues = async (type, name, id) => {
@@ -11988,9 +11988,9 @@ var init_licenseInfo = __esm({
       };
     };
     save2 = async (licenseInfo) => {
-      const db = tenancy.getGlobalDB();
-      const response = await db.put(licenseInfo);
-      licenseInfo._rev = response.rev;
+      const db2 = tenancy.getGlobalDB();
+      const response2 = await db2.put(licenseInfo);
+      licenseInfo._rev = response2.rev;
       return licenseInfo;
     };
     create = async (licenseKey) => {
@@ -11998,9 +11998,9 @@ var init_licenseInfo = __esm({
       return save2(licenseInfo);
     };
     get3 = 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;
@@ -12013,24 +12013,24 @@ var init_licenseInfo = __esm({
       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/views/staticViews.ts
 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" };
     }
   }
-  const fn = function(auditLog) {
+  const fn2 = function(auditLog) {
     if (auditLog._id && !auditLog._id.startsWith("al_")) {
       return;
     }
@@ -12057,7 +12057,7 @@ async function createAuditLogSearchIndex() {
   };
   designDoc.indexes = {
     ["audit" /* AUDIT */]: {
-      index: fn.toString(),
+      index: fn2.toString(),
       analyzer: {
         default: "whitespace",
         fields: {
@@ -12067,7 +12067,7 @@ async function createAuditLogSearchIndex() {
       }
     }
   };
-  await db.put(designDoc);
+  await db2.put(designDoc);
 }
 var init_staticViews = __esm({
   "../pro/packages/pro/src/db/views/staticViews.ts"() {
@@ -12078,7 +12078,7 @@ var init_staticViews = __esm({
 
 // ../pro/packages/pro/src/db/views/groups.ts
 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) {
@@ -12087,7 +12087,7 @@ async function createGroupUserLookupView() {
         }
       }
     }`;
-  await createView2(db, viewJs, ViewName3.USER_BY_GROUP);
+  await createView2(db2, viewJs, ViewName3.USER_BY_GROUP);
 }
 var ViewName3, SEPARATOR4, DocumentType2, createView2, USER_PREFIX;
 var init_groups2 = __esm({
@@ -12156,11 +12156,11 @@ 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 }
   );
@@ -12170,13 +12170,13 @@ async function getGroupUsers(groupId, params2) {
   })) || [];
   return users2;
 }
-async function enrichGroup(group) {
-  group.users = await getGroupUsers(group._id);
-  return group;
+async function enrichGroup(group2) {
+  group2.users = await getGroupUsers(group2._id);
+  return group2;
 }
-async function cleanupUsers(group) {
+async function cleanupUsers(group2) {
   var _a;
-  const enriched = await enrichGroup(group);
+  const enriched = await enrichGroup(group2);
   const userIds = (_a = enriched.users) == null ? void 0 : _a.map((user) => user._id);
   const users2 = await users_exports2.bulkGetGlobalUsersById(userIds);
   const toUpdate = [];
@@ -12185,7 +12185,7 @@ async function cleanupUsers(group) {
       continue;
     }
     const lengthBefore = user.userGroups.length;
-    user.userGroups = user.userGroups.filter((groupId) => groupId !== group._id);
+    user.userGroups = user.userGroups.filter((groupId) => groupId !== group2._id);
     if (user.userGroups.length !== lengthBefore) {
       toUpdate.push(user);
     }
@@ -12195,16 +12195,16 @@ async function cleanupUsers(group) {
   }
 }
 async function fetch8() {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const groups = (await db.allDocs(
+    const groups = (await db2.allDocs(
       getUserGroupsParams(null, {
         include_docs: true
       })
     )).rows.map((row) => row.doc);
     const enrichedGroups = [];
-    for (let group of groups) {
-      enrichedGroups.push(enrichGroup(group));
+    for (let group2 of groups) {
+      enrichedGroups.push(enrichGroup(group2));
     }
     return await Promise.all(enrichedGroups);
   } catch (err) {
@@ -12212,25 +12212,25 @@ async function fetch8() {
   }
 }
 async function get4(groupId) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const group = await db.get(groupId);
-    return await enrichGroup(group);
+    const group2 = await db2.get(groupId);
+    return await enrichGroup(group2);
   } 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);
     if (opts == null ? void 0 : opts.enriched) {
       const enrichedGroups = [];
-      for (let group of groups) {
-        enrichedGroups.push(enrichGroup(group));
+      for (let group2 of groups) {
+        enrichedGroups.push(enrichGroup(group2));
       }
       return await Promise.all(enrichedGroups);
     } else {
@@ -12240,19 +12240,19 @@ async function getBulk(groupIds, opts = { enriched: true }) {
     throw err;
   }
 }
-async function save3(group) {
-  const db = tenancy.getGlobalDB();
-  return await db.put(group);
+async function save3(group2) {
+  const db2 = tenancy.getGlobalDB();
+  return await db2.put(group2);
 }
 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);
-  await cleanupUsers(group);
+  const db2 = tenancy.getGlobalDB();
+  const group2 = await db2.get(groupId);
+  let resp = await db2.remove(groupId, revision);
+  await cleanupUsers(group2);
   return resp;
 }
 async function getByName(name) {
@@ -12265,11 +12265,11 @@ async function getByName(name) {
       },
       limit: 1
     });
-    const [group] = groups.rows;
-    if (!group) {
+    const [group2] = groups.rows;
+    if (!group2) {
       return;
     }
-    return await enrichGroup(group);
+    return await enrichGroup(group2);
   } catch (err) {
     throw err;
   }
@@ -12284,19 +12284,19 @@ var init_groups3 = __esm({
 });
 
 // ../pro/packages/pro/src/db/utils/pagination.ts
-function pagination2(response, opts) {
+function pagination2(response2, opts) {
   var _a;
-  const data = response.rows.map((row) => {
+  const data2 = response2.rows.map((row) => {
     return row.doc ? row.doc : row;
   });
   if (!(opts == null ? void 0 : opts.paginate)) {
-    return { data, hasNextPage: false };
+    return { data: data2, hasNextPage: false };
   }
-  const hasNextPage = data.length > (opts == null ? void 0 : opts.pageSize);
+  const hasNextPage = data2.length > (opts == null ? void 0 : opts.pageSize);
   return {
-    data: data.slice(0, opts == null ? void 0 : opts.pageSize),
+    data: data2.slice(0, opts == null ? void 0 : opts.pageSize),
     hasNextPage,
-    nextPage: hasNextPage ? (_a = data[opts == null ? void 0 : opts.pageSize]) == null ? void 0 : _a._id : void 0
+    nextPage: hasNextPage ? (_a = data2[opts == null ? void 0 : opts.pageSize]) == null ? void 0 : _a._id : void 0
   };
 }
 var init_pagination2 = __esm({
@@ -12306,7 +12306,7 @@ var init_pagination2 = __esm({
 
 // ../pro/packages/pro/src/db/utils/views.ts
 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 + "${SEPARATOR5}"
@@ -12319,10 +12319,10 @@ async function createLogByAutomationView() {
       emit(allKey)
     }
   }`;
-  await createView3(db, viewJs, ViewName4.AUTOMATION_LOGS);
+  await createView3(db2, viewJs, ViewName4.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 + "${SEPARATOR5}"
@@ -12331,7 +12331,7 @@ async function createAppBackupTriggerView() {
       emit("${APP_BACKUP_PREFIX}" + full + doc.timestamp) 
     }
   }`;
-  await createView3(db, viewJs, ViewName4.APP_BACKUP_BY_TRIGGER);
+  await createView3(db2, viewJs, ViewName4.APP_BACKUP_BY_TRIGGER);
 }
 var ViewName4, AutomationViewMode2, SEPARATOR5, DocumentType3, createView3, LOG_PREFIX, APP_BACKUP_PREFIX;
 var init_views3 = __esm({
@@ -12678,17 +12678,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;
     }
@@ -12699,7 +12699,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, {
@@ -12710,9 +12710,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,
@@ -12727,16 +12727,16 @@ async function fetchAppBackups(appId, opts = {}) {
     cleanup: true
   });
   for (let user of users2) {
-    for (let data of pageData.data) {
-      if ((user == null ? void 0 : user._id) === data.createdBy) {
-        data.createdBy = user;
+    for (let data2 of pageData.data) {
+      if ((user == null ? void 0 : user._id) === data2.createdBy) {
+        data2.createdBy = user;
       }
     }
   }
   return pageData;
 }
 async function storeAppBackupMetadata(metadata, opts = {}) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   const prodAppId = db_exports.getProdAppID(metadata.appId);
   let _id = generateAppBackupID(prodAppId, metadata.timestamp);
   const appBackupDoc = {
@@ -12757,22 +12757,22 @@ async function storeAppBackupMetadata(metadata, opts = {}) {
       metadata.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);
+  const db2 = tenancy.getGlobalDB();
+  const metadata = await db2.get(backupId);
   metadata.name = name;
-  return await db.put(metadata);
+  return await db2.put(metadata);
 }
 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);
 }
 var APP_BACKUP_PREFIX2;
 var init_backups = __esm({
@@ -12804,10 +12804,10 @@ function getCacheEnvVarID(rev) {
 }
 async function get5() {
   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;
@@ -12842,8 +12842,8 @@ async function get5() {
 }
 async function update(doc) {
   const id = getEnvVarID();
-  const db = tenancy.getGlobalDB();
-  return await db.put({
+  const db2 = tenancy.getGlobalDB();
+  return await db2.put({
     _id: doc._id || id,
     _rev: doc._rev || void 0,
     variables: encryption_exports.encrypt(
@@ -12891,23 +12891,23 @@ var init_client = __esm({
     init_db6();
     init_constants4();
     api2 = new api_default(environment_default2.ACCOUNT_PORTAL_URL);
-    getResponseErrorMessage = async (response) => {
+    getResponseErrorMessage = async (response2) => {
       try {
-        const json2 = await response.json();
+        const json2 = await response2.json();
         if (json2.message) {
           return json2.message;
         }
       } catch (e) {
       }
       try {
-        const text = await response.text();
+        const text = await response2.text();
         if (text) {
           return text;
         }
       } catch (e) {
       }
     };
-    authAware = async (fn) => {
+    authAware = async (fn2) => {
       let licenseInfo;
       let authHeader;
       if (environment_default2.SELF_HOSTED) {
@@ -12925,7 +12925,7 @@ var init_client = __esm({
           [constants_exports.Header.TENANT_ID]: tenantId
         };
       }
-      return fn(authHeader);
+      return fn2(authHeader);
     };
     _getLicense = async () => {
       return authAware(async (authHeader) => {
@@ -12954,18 +12954,18 @@ var init_client = __esm({
             version: installVersion
           }
         };
-        const response = await api2.post(`/api/license`, {
+        const response2 = await api2.post(`/api/license`, {
           headers: { ...authHeader },
           body: body2
         });
-        if (response.status === 404 || response.status === 403) {
+        if (response2.status === 404 || response2.status === 403) {
           return;
         }
-        if (response.status !== 200) {
-          const message = await getResponseErrorMessage(response);
-          throw new HTTPError(`Error getting license: ${message}`, response.status);
+        if (response2.status !== 200) {
+          const message = await getResponseErrorMessage(response2);
+          throw new HTTPError(`Error getting license: ${message}`, response2.status);
         }
-        return response.json();
+        return response2.json();
       });
     };
     if (environment_default2.isJest()) {
@@ -12974,12 +12974,12 @@ var init_client = __esm({
     getLicense = _getLicense;
     triggerQuota = (body2) => {
       return authAware(async (authHeader) => {
-        const response = await api2.post(`/api/license/usage/triggered`, {
+        const response2 = await api2.post(`/api/license/usage/triggered`, {
           headers: { ...authHeader },
           body: body2
         });
-        if (response.status !== 200) {
-          const message = await getResponseErrorMessage(response);
+        if (response2.status !== 200) {
+          const message = await getResponseErrorMessage(response2);
           logging_exports.logAlert(`Error triggering quota usage: ${message}`);
         }
       });
@@ -12989,23 +12989,23 @@ var init_client = __esm({
       const body2 = {
         installVersion
       };
-      const response = await api2.post(`/api/license/activate`, {
+      const response2 = await api2.post(`/api/license/activate`, {
         headers: {
           [constants_exports.Header.LICENSE_KEY]: licenseKey
         },
         body: body2
       });
-      if (response.status === 403) {
+      if (response2.status === 403) {
         throw new HTTPError("Invalid license key", 400);
       }
-      if (response.status !== 200) {
-        const message = await getResponseErrorMessage(response);
+      if (response2.status !== 200) {
+        const message = await getResponseErrorMessage(response2);
         throw new HTTPError(
           `Error activating license key: ${message}`,
-          response.status
+          response2.status
         );
       }
-      return response.json();
+      return response2.json();
     };
   }
 });
@@ -13646,19 +13646,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;
@@ -13830,23 +13830,23 @@ var init_api5 = __esm({
     init_db6();
     init_src2();
     api3 = new api_default(environment_default2.ACCOUNT_PORTAL_URL);
-    createActivity = async (userId, data) => {
-      const response = await send(
+    createActivity = async (userId, data2) => {
+      const response2 = await send(
         (options2) => api3.post(`/api/users/${userId}/activity`, options2),
         {
-          body: data
+          body: data2
         }
       );
-      if (!response) {
+      if (!response2) {
         return;
       }
-      if (response.status !== 201) {
-        const text = await response.text();
+      if (response2.status !== 201) {
+        const text = await response2.text();
         const message = `Error creating account user activity: ${text}`;
         logging_exports.logAlert(message);
         throw new Error(message);
       }
-      return response.json();
+      return response2.json();
     };
     send = async (requestFn, baseOptions) => {
       const isLicensingEnabled = await featureFlags_exports.isEnabled(
@@ -13899,10 +13899,10 @@ var init_users6 = __esm({
   "../pro/packages/pro/src/sdk/users/users.ts"() {
     init_api6();
     createActivity2 = async (userId) => {
-      const data = {
+      const data2 = {
         timestamp: Date.now()
       };
-      return createActivity(userId, data);
+      return createActivity(userId, data2);
     };
   }
 });
@@ -13919,14 +13919,14 @@ var init_users7 = __esm({
 });
 
 // ../pro/packages/pro/src/utilities/delay.ts
-async function backOff(fn, errMsg) {
-  let attempts = 5, success = false, response, first = true;
+async function backOff(fn2, errMsg) {
+  let attempts = 5, success = false, response2, first = true;
   for (; attempts > 0; attempts--) {
     try {
       if (first) {
-        response = await fn();
+        response2 = await fn2();
       } else {
-        response = await exports.randomDelay(fn);
+        response2 = await exports.randomDelay(fn2);
       }
       success = true;
       break;
@@ -13936,7 +13936,7 @@ async function backOff(fn, errMsg) {
   if (!success) {
     logging_exports.logAlert(`Failed to backoff`, errMsg);
   }
-  return response;
+  return response2;
 }
 var init_delay = __esm({
   "../pro/packages/pro/src/utilities/delay.ts"() {
@@ -13993,9 +13993,9 @@ function generateAutomationLogID(isoDate, status2, automationId) {
   return `${DocumentType4.AUTOMATION_LOG}${SEPARATOR6}${isoDate}${SEPARATOR6}${automationId}${SEPARATOR6}${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;
@@ -14006,18 +14006,18 @@ 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);
-  return pagination2(response, {
+  let response2 = await db2.allDocs(params2);
+  return pagination2(response2, {
     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;
+  let response2;
   try {
     let optional = {
       automationId: viewParams == null ? void 0 : viewParams.automationId,
@@ -14030,7 +14030,7 @@ async function getLogsByView(startDate, endDate, viewParams = {}) {
     if (viewParams == null ? void 0 : viewParams.page) {
       params2.startkey = viewParams.page;
     }
-    response = await db.query(getQueryIndex2(ViewName5.AUTOMATION_LOGS), params2);
+    response2 = await db2.query(getQueryIndex2(ViewName5.AUTOMATION_LOGS), params2);
   } catch (err) {
     if (err != null && (err.name === "not_found" || err.error === "not_found")) {
       await createLogByAutomationView();
@@ -14039,10 +14039,10 @@ async function getLogsByView(startDate, endDate, viewParams = {}) {
       throw err;
     }
   }
-  return pagination2(response);
+  return pagination2(response2);
 }
 async function writeLog(automation, results) {
-  const db = context_exports.getProdAppDB();
+  const db2 = context_exports.getProdAppDB();
   const automationId = automation._id;
   const name = automation.name;
   const status2 = getStatus(results);
@@ -14057,13 +14057,13 @@ async function writeLog(automation, results) {
     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 metadata = 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]}`;
@@ -14085,7 +14085,7 @@ async function updateAppMetadataWithErrors(logIds, { clearing } = { clearing: fa
       }
       metadata.automationErrors = errors;
     }
-    await db.put(metadata);
+    await db2.put(metadata);
     await cache_exports.app.invalidateAppMetadata(metadata.appId, metadata);
   }, "Failed to update app metadata with automation log error");
 }
@@ -14102,7 +14102,7 @@ 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) {
@@ -14118,13 +14118,13 @@ async function clearOldHistory() {
       const status2 = parts[parts.length - 1];
       return status2 === "error" /* ERROR */;
     }).map((doc) => doc.id);
-    await db.bulkDocs(toDelete);
+    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
     );
   }
@@ -14163,27 +14163,27 @@ __export(logging_exports2, {
   storeLog: () => storeLog
 });
 async function getLogs(startDate, status2, automationId, page) {
-  let response;
+  let response2;
   let endDate = (/* @__PURE__ */ new Date()).toISOString();
   const maxStartDate = await oldestLogDate2();
   if (!startDate || startDate < maxStartDate) {
     startDate = maxStartDate;
   }
   if (automationId || status2) {
-    response = await getLogsByView(startDate, endDate, {
+    response2 = await getLogsByView(startDate, endDate, {
       automationId,
       status: status2,
       page
     });
   } else {
-    response = await getAllLogs(startDate, endDate, {
+    response2 = await getAllLogs(startDate, endDate, {
       status: status2,
       page,
       docs: true,
       paginate: true
     });
   }
-  return response;
+  return response2;
 }
 async function logSearch(options2) {
   await clearOldHistory();
@@ -14243,9 +14243,9 @@ var init_errors4 = __esm({
 async function findHighestRole(groups, appId) {
   try {
     let potentialRoles = [];
-    for (let group of groups) {
-      if (group.roles) {
-        potentialRoles.push(group.roles[db_exports.getProdAppID(appId)]);
+    for (let group2 of groups) {
+      if (group2.roles) {
+        potentialRoles.push(group2.roles[db_exports.getProdAppID(appId)]);
       }
     }
     const allRoleNumbersArr = await Promise.all(
@@ -14285,7 +14285,7 @@ async function getGroupRoleId(user, appId, opts) {
   let groupsToAdd;
   if (opts == null ? void 0 : opts.groups) {
     groupsToAdd = opts.groups.filter(
-      (group) => user.userGroups.includes(group._id)
+      (group2) => user.userGroups.includes(group2._id)
     );
   } else {
     groupsToAdd = await groups_exports.getBulk(user.userGroups, {
@@ -14296,11 +14296,11 @@ async function getGroupRoleId(user, appId, opts) {
   if ((_a = user.roles) == null ? void 0 : _a[prodAppId]) {
     return user.roles[prodAppId];
   }
-  groupsToAdd = groupsToAdd.filter((group) => {
-    if (!(group == null ? void 0 : group.roles)) {
+  groupsToAdd = groupsToAdd.filter((group2) => {
+    if (!(group2 == null ? void 0 : group2.roles)) {
       return false;
     }
-    const appIds = Object.keys(group.roles);
+    const appIds = Object.keys(group2.roles);
     return appIds.includes(prodAppId);
   });
   return await findHighestRole(groupsToAdd, appId);
@@ -14311,9 +14311,9 @@ async function enrichUserRolesFromGroups(user) {
   }
   const retrievedGroups = await getBulk2(user.userGroups, { enriched: false });
   let allGroupAppIds = [];
-  for (let group of retrievedGroups) {
-    if (group == null ? void 0 : group.roles) {
-      allGroupAppIds = allGroupAppIds.concat(Object.keys(group.roles));
+  for (let group2 of retrievedGroups) {
+    if (group2 == null ? void 0 : group2.roles) {
+      allGroupAppIds = allGroupAppIds.concat(Object.keys(group2.roles));
     }
   }
   allGroupAppIds = [...new Set(allGroupAppIds)];
@@ -14343,29 +14343,29 @@ async function guardNameAvailility(name) {
     throw new GroupNameUnavailableError(name);
   }
 }
-async function save4(group) {
+async function save4(group2) {
   let eventPromises = [];
-  let isCreate = !group._id;
-  delete group.users;
+  let isCreate = !group2._id;
+  delete group2.users;
   groups_exports.getUserGroupsParams;
-  if (!group._id) {
-    group._id = groups_exports.generateUserGroupID();
-    await guardNameAvailility(group.name);
-    eventPromises.push(events_exports.group.created(group));
+  if (!group2._id) {
+    group2._id = groups_exports.generateUserGroupID();
+    await guardNameAvailility(group2.name);
+    eventPromises.push(events_exports.group.created(group2));
   } else {
-    const oldGroup = await groups_exports.get(group._id);
-    if (oldGroup.name !== group.name) {
-      await guardNameAvailility(group.name);
+    const oldGroup = await groups_exports.get(group2._id);
+    if (oldGroup.name !== group2.name) {
+      await guardNameAvailility(group2.name);
     }
-    eventPromises.push(events_exports.group.updated(group));
-    if (JSON.stringify(oldGroup.roles) !== JSON.stringify(group.roles)) {
-      eventPromises.push(events_exports.group.permissionsEdited(group));
+    eventPromises.push(events_exports.group.updated(group2));
+    if (JSON.stringify(oldGroup.roles) !== JSON.stringify(group2.roles)) {
+      eventPromises.push(events_exports.group.permissionsEdited(group2));
     }
   }
   try {
     await Promise.all(eventPromises);
     const saveGroup = () => {
-      return groups_exports.save(group);
+      return groups_exports.save(group2);
     };
     if (isCreate) {
       return await addGroup(saveGroup);
@@ -14377,15 +14377,15 @@ async function save4(group) {
   }
 }
 async function remove2(groupId, revision) {
-  let group;
+  let group2;
   try {
-    group = await groups_exports.get(groupId);
+    group2 = await groups_exports.get(groupId);
   } catch (err) {
     throw new Error("Group not found");
   }
   try {
     let resp = await groups_exports.destroy(groupId, revision);
-    await events_exports.group.deleted(group);
+    await events_exports.group.deleted(group2);
     await removeGroup();
     return resp;
   } catch (err) {
@@ -14393,7 +14393,7 @@ async function remove2(groupId, revision) {
   }
 }
 async function addUsers2(groupId, userIds) {
-  const group = await groups_exports.get(groupId);
+  const group2 = await groups_exports.get(groupId);
   const users2 = await users_exports2.bulkGetGlobalUsersById(userIds);
   let toUpdate = [];
   for (let user of users2) {
@@ -14412,12 +14412,12 @@ async function addUsers2(groupId, userIds) {
   }
   await Promise.all(promises);
   if (toUpdate.length) {
-    await events_exports.group.usersAdded(toUpdate.length, group);
+    await events_exports.group.usersAdded(toUpdate.length, group2);
   }
   return toUpdate;
 }
 async function removeUsers2(groupId, userIds) {
-  const group = await groups_exports.get(groupId);
+  const group2 = await groups_exports.get(groupId);
   const users2 = await users_exports2.bulkGetGlobalUsersById(userIds);
   let toUpdate = [];
   for (let user of users2) {
@@ -14435,36 +14435,36 @@ async function removeUsers2(groupId, userIds) {
   }
   await Promise.all(promises);
   if (toUpdate.length) {
-    await events_exports.group.usersDeleted(toUpdate.length, group);
+    await events_exports.group.usersDeleted(toUpdate.length, group2);
   }
   return toUpdate;
 }
 async function updateGroupApps(groupId, opts) {
-  const group = await get6(groupId);
-  if (!group.roles) {
-    group.roles = {};
+  const group2 = await get6(groupId);
+  if (!group2.roles) {
+    group2.roles = {};
   }
   if (opts.appsToAdd) {
     for (let add of opts.appsToAdd) {
-      group.roles[add.appId] = add.roleId;
+      group2.roles[add.appId] = add.roleId;
     }
   }
   if (opts.appsToRemove) {
     for (let remove7 of opts.appsToRemove) {
-      delete group.roles[remove7.appId];
+      delete group2.roles[remove7.appId];
     }
   }
-  return await save4(group);
+  return await save4(group2);
 }
 async function cleanupApp(appId) {
   const groupList = await fetch9();
   const toUpdate = [];
-  for (let group of groupList) {
-    if (!group.roles || !group.roles[appId]) {
+  for (let group2 of groupList) {
+    if (!group2.roles || !group2.roles[appId]) {
       continue;
     }
-    delete group.roles[appId];
-    toUpdate.push(group);
+    delete group2.roles[appId];
+    toUpdate.push(group2);
   }
   return await groups_exports.bulkSave(toUpdate);
 }
@@ -14518,7 +14518,7 @@ __export(plugins_exports, {
   storePlugin: () => storePlugin
 });
 async function storePlugin(metadata, directory, source) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   const version = metadata.package.version, name = metadata.package.name, description = metadata.package.description, hash2 = metadata.schema.hash;
   const bucketPath = objectStore_exports2.getPluginS3Dir(name);
   const files = await objectStore_exports2.uploadDirectory(
@@ -14545,7 +14545,7 @@ async function storePlugin(metadata, directory, source) {
   const pluginId = db_exports.generatePluginID(name);
   let rev;
   try {
-    const existing = await db.get(pluginId);
+    const existing = await db2.get(pluginId);
     rev = existing._rev;
   } catch (err) {
     rev = void 0;
@@ -14569,11 +14569,11 @@ async function storePlugin(metadata, directory, source) {
     };
   }
   const write2 = async () => {
-    const response = await db.put(doc);
+    const response2 = await db2.put(doc);
     await events_exports.plugin.imported(doc);
     return {
       ...doc,
-      _rev: response.rev
+      _rev: response2.rev
     };
   };
   if (!rev) {
@@ -14583,15 +14583,15 @@ async function storePlugin(metadata, directory, source) {
   }
 }
 async function deletePlugin(pluginId) {
-  const db = tenancy.getGlobalDB();
+  const db2 = tenancy.getGlobalDB();
   try {
-    const plugin = await db.get(pluginId);
+    const plugin = await db2.get(pluginId);
     const bucketPath = objectStore_exports2.getPluginS3Dir(plugin.name);
     await objectStore_exports2.deleteFolder(
       objectStore_exports2.ObjectStoreBuckets.PLUGINS,
       bucketPath
     );
-    await db.remove(pluginId, plugin._rev);
+    await db2.remove(pluginId, plugin._rev);
     await events_exports.plugin.deleted(plugin);
     await removePlugin();
   } catch (err) {
@@ -14600,9 +14600,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);
@@ -14710,11 +14710,11 @@ async function save5(doc) {
     doc._id = generateAuditLogID(doc.timestamp);
   }
   try {
-    const db = context_exports.getAuditLogsDB();
-    const response = await db.put(doc);
+    const db2 = context_exports.getAuditLogsDB();
+    const response2 = await db2.put(doc);
     return {
       ...doc,
-      _rev: response.rev
+      _rev: response2.rev
     };
   } catch (err) {
     logging_exports.logAlert("Failed to write audit log", err);
@@ -14738,9 +14738,9 @@ async function search(search6, bookmark) {
   );
 }
 function dump(params2) {
-  const db = context_exports.getAuditLogsDB();
+  const db2 = context_exports.getAuditLogsDB();
   const stream3 = new MemoryStream();
-  const promise = db.dump(stream3, {
+  const promise = db2.dump(stream3, {
     filter: (doc) => {
       var _a;
       const auditLog = doc;
@@ -14768,8 +14768,8 @@ function dump(params2) {
     }
   });
   const returnStream = new MemoryStream();
-  stream3.on("data", (data) => {
-    const json2 = JSON.parse(Buffer.from(data).toString());
+  stream3.on("data", (data2) => {
+    const json2 = JSON.parse(Buffer.from(data2).toString());
     if (Array.isArray(json2.docs)) {
       let str = "";
       for (let doc of json2.docs) {
@@ -14798,9 +14798,9 @@ var init_auditLogs4 = __esm({
 var require_Helper = __commonJS({
   "../string-templates/src/helpers/Helper.js"(exports2, module2) {
     var Helper = class {
-      constructor(name, fn, useValueFallback = true) {
+      constructor(name, fn2, useValueFallback = true) {
         this.name = name;
-        this.fn = fn;
+        this.fn = fn2;
         this.useValueFallback = useValueFallback;
       }
       register(handlebars) {
@@ -15092,14 +15092,14 @@ var require_javascript = __commonJS({
       return value;
     };
     var getContextValue = (path2, context) => {
-      let data = context;
+      let data2 = context;
       path2.split(".").forEach((key) => {
-        if (data == null || typeof data !== "object") {
+        if (data2 == null || typeof data2 !== "object") {
           return null;
         }
-        data = data[removeSquareBrackets(key)];
+        data2 = data2[removeSquareBrackets(key)];
       });
-      return data;
+      return data2;
     };
     module2.exports.processJS = (handlebars, context) => {
       if (process && process.env.NO_JS) {
@@ -15224,9 +15224,9 @@ var require_preprocessor = __commonJS({
       FINALISE: "finalise"
     };
     var Preprocessor = class {
-      constructor(name, fn) {
+      constructor(name, fn2) {
         this.name = name;
-        this.fn = fn;
+        this.fn = fn2;
       }
       process(fullString, statement, opts) {
         const output = this.fn(statement, opts);
@@ -15289,9 +15289,9 @@ var require_postprocessor = __commonJS({
       CONVERT_LITERALS: "convert-literals"
     };
     var Postprocessor = class {
-      constructor(name, fn) {
+      constructor(name, fn2) {
         this.name = name;
-        this.fn = fn;
+        this.fn = fn2;
       }
       process(statement) {
         return this.fn(statement);
@@ -17181,11 +17181,11 @@ async function fetch11(params2) {
     throw new Error("Audit logs not available - license required.");
   }
   const filter2 = getSearchFilters(params2);
-  const response = await search(filter2, params2.bookmark);
+  const response2 = await search(filter2, params2.bookmark);
   return {
-    hasNextPage: response.hasNextPage,
-    bookmark: response.bookmark,
-    data: await enrich(response.rows)
+    hasNextPage: response2.hasNextPage,
+    bookmark: response2.bookmark,
+    data: await enrich(response2.rows)
   };
 }
 function download(params2) {
@@ -17409,16 +17409,16 @@ __export(processing_exports, {
 });
 async function init11(opts) {
   await getBackupQueue().process(async (job) => {
-    const data = job.data;
+    const data2 = job.data;
     try {
-      if (data.export) {
+      if (data2.export) {
         return exportProcessor(job, opts);
-      } else if (data.import) {
+      } else if (data2.import) {
         return importProcessor(job, opts);
       }
     } catch (err) {
       logging_exports.logAlert(
-        `Failed to perform backup for app ID: ${data.appId}`,
+        `Failed to perform backup for app ID: ${data2.appId}`,
         err
       );
     }
@@ -17483,14 +17483,14 @@ async function runBackup(trigger, tenantId, appId, opts) {
   }
 }
 async function importProcessor(job, opts) {
-  const data = job.data;
-  const appId = data.appId, backupId = data.import.backupId, nameForBackup = data.import.nameForBackup, createdBy = data.import.createdBy;
+  const data2 = job.data;
+  const appId = data2.appId, backupId = data2.import.backupId, nameForBackup = data2.import.nameForBackup, createdBy = data2.import.createdBy;
   const tenantId = tenancy.getTenantIDFromAppID(appId);
   return tenancy.doInTenant(tenantId, async () => {
     const devAppId = db_exports.getDevAppID(appId);
     const { rev } = await backup_default2.updateRestoreStatus(
-      data.docId,
-      data.docRev,
+      data2.docId,
+      data2.docRev,
       "started" /* STARTED */
     );
     await runBackup("restoring" /* RESTORING */, tenantId, appId, {
@@ -17513,22 +17513,22 @@ 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(data2.docId, rev, status2);
   });
 }
 async function exportProcessor(job, opts) {
-  const data = job.data;
-  const appId = data.appId, trigger = data.export.trigger, name = data.export.name;
+  const data2 = job.data;
+  const appId = data2.appId, trigger = data2.export.trigger, name = data2.export.name;
   const tenantId = tenancy.getTenantIDFromAppID(appId);
   await tenancy.doInTenant(tenantId, async () => {
     const { rev } = await backup_default2.updateBackupStatus(
-      data.docId,
-      data.docRev,
+      data2.docId,
+      data2.docRev,
       "started" /* STARTED */
     );
     return runBackup(trigger, tenantId, appId, {
       processing: opts,
-      doc: { id: data.docId, rev },
+      doc: { id: data2.docId, rev },
       name
     });
   });
@@ -17608,8 +17608,8 @@ var init_users8 = __esm({
       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);
@@ -17792,17 +17792,17 @@ var init_groups7 = __esm({
     init_groups6();
     init_groups3();
     save6 = async (ctx) => {
-      const group = ctx.request.body;
-      group.name = group.name.trim();
-      delete group.roles;
-      if (group._id) {
-        const oldGroup = await get6(group._id);
-        group.roles = oldGroup.roles;
-      }
-      const response = await save4(group);
+      const group2 = ctx.request.body;
+      group2.name = group2.name.trim();
+      delete group2.roles;
+      if (group2._id) {
+        const oldGroup = await get6(group2._id);
+        group2.roles = oldGroup.roles;
+      }
+      const response2 = await save4(group2);
       ctx.body = {
-        _id: response.id,
-        _rev: response.rev
+        _id: response2.id,
+        _rev: response2.rev
       };
     };
     updateGroupUsers = async (ctx) => {
@@ -18129,18 +18129,18 @@ async function importBackup(ctx) {
   await checkAppID(ctx, appId);
   const backupId = ctx.params.backupId;
   const nameForBackup = ctx.request.body.name;
-  const response = await backups_default.triggerAppRestore(
+  const response2 = await backups_default.triggerAppRestore(
     appId,
     backupId,
     nameForBackup,
     (_a = ctx.user) == null ? void 0 : _a._id
   );
-  if (!response) {
+  if (!response2) {
     ctx.throw(500, "Unable to start restore.");
   }
-  await events_exports.backup.appBackupRestored(response.metadata);
+  await events_exports.backup.appBackupRestored(response2.metadata);
   ctx.body = {
-    restoredId: response == null ? void 0 : response.restoreId,
+    restoredId: response2 == null ? void 0 : response2.restoreId,
     message: "Restore triggered - process starting."
   };
 }
@@ -18830,9 +18830,9 @@ var init_src3 = __esm({
 });
 
 // ../pro/packages/pro/src/api/controllers/global/scim/groups.ts
-function cleanResponse(group, excludedAttributes) {
+function cleanResponse(group2, excludedAttributes) {
   for (const attr of excludedAttributes.split(",")) {
-    delete group[attr];
+    delete group2[attr];
   }
 }
 var import_lodash, import_scim_patch2, import_scim2_parse_filter, get9, create5, find4, remove6, update6;
@@ -18867,21 +18867,21 @@ var init_groups9 = __esm({
     create5 = async (ctx) => {
       const groupToCreate = mappers_exports.group.fromScimGroup(ctx.request.body);
       const createdGroup = await groups_exports2.save(groupToCreate);
-      const group = await groups_exports2.get(createdGroup.id);
-      ctx.body = mappers_exports.group.toScimGroupResponse(group);
+      const group2 = await groups_exports2.get(createdGroup.id);
+      ctx.body = mappers_exports.group.toScimGroupResponse(group2);
     };
     find4 = async (ctx) => {
       const { id } = ctx.params;
       if (typeof id !== "string") {
         ctx.throw(404);
       }
-      const group = await groups_exports2.get(id);
-      const response = mappers_exports.group.toScimGroupResponse(group);
+      const group2 = await groups_exports2.get(id);
+      const response2 = mappers_exports.group.toScimGroupResponse(group2);
       const { excludedAttributes } = ctx.request.query;
       if (excludedAttributes) {
-        cleanResponse(response, excludedAttributes);
+        cleanResponse(response2, excludedAttributes);
       }
-      ctx.body = response;
+      ctx.body = response2;
     };
     remove6 = async (ctx) => {
       const { id } = ctx.params;
@@ -18894,11 +18894,11 @@ var init_groups9 = __esm({
     };
     update6 = async (ctx) => {
       const { id } = ctx.params;
-      const group = await groups_exports2.get(id);
-      if (!group) {
+      const group2 = await groups_exports2.get(id);
+      if (!group2) {
         ctx.throw(404);
       }
-      const scimGroup = mappers_exports.group.toScimGroupResponse(group);
+      const scimGroup = mappers_exports.group.toScimGroupResponse(group2);
       const patchs = ctx.request.body;
       try {
         (0, import_scim_patch2.patchBodyValidation)(patchs);
@@ -18916,7 +18916,7 @@ var init_groups9 = __esm({
         }
         const groupToUpdate = {
           ...mappers_exports.group.fromScimGroup(patchedScimGroup),
-          _rev: group._rev
+          _rev: group2._rev
         };
         await groups_exports2.save(groupToUpdate);
       }
@@ -19025,7 +19025,7 @@ var init_users10 = __esm({
     init_src2();
     toScimUserResponse = (user) => {
       const { isSync, roles, ...scimInfo } = user.scimInfo || {};
-      const response = {
+      const response2 = {
         ...scimInfo,
         schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
         id: user._id,
@@ -19037,13 +19037,13 @@ var init_users10 = __esm({
         active: user.status === "active" /* ACTIVE */
       };
       if (user.firstName || user.lastName) {
-        response.name = {
+        response2.name = {
           formatted: [user.firstName, user.lastName].filter((s) => s).join(" "),
           familyName: user.lastName,
           givenName: user.firstName
         };
       }
-      return response;
+      return response2;
     };
     isScimUserResponse = (user) => {
       return !!(user == null ? void 0 : user.id);
@@ -19135,31 +19135,31 @@ __export(groups_exports5, {
 var toScimGroupResponse, isScimGroup, fromScimGroup;
 var init_groups10 = __esm({
   "../pro/packages/pro/src/mappers/groups.ts"() {
-    toScimGroupResponse = (group) => {
+    toScimGroupResponse = (group2) => {
       var _a;
       return {
         schemas: ["urn:ietf:params:scim:schemas:core:2.0:Group"],
-        id: group._id,
-        externalId: group.scimInfo.externalId,
+        id: group2._id,
+        externalId: group2.scimInfo.externalId,
         meta: {
           resourceType: "Group",
-          created: new Date(group.createdAt),
-          lastModified: new Date(group.updatedAt)
+          created: new Date(group2.createdAt),
+          lastModified: new Date(group2.updatedAt)
         },
-        displayName: group.name,
-        members: (_a = group.users) == null ? void 0 : _a.map((u) => ({ value: u._id }))
+        displayName: group2.name,
+        members: (_a = group2.users) == null ? void 0 : _a.map((u) => ({ value: u._id }))
       };
     };
-    isScimGroup = (group) => {
-      return !!(group == null ? void 0 : group.id);
+    isScimGroup = (group2) => {
+      return !!(group2 == null ? void 0 : group2.id);
     };
-    fromScimGroup = (group) => {
-      const existingGroup = isScimGroup(group) ? group : void 0;
+    fromScimGroup = (group2) => {
+      const existingGroup = isScimGroup(group2) ? group2 : void 0;
       const g = {
         _id: existingGroup == null ? void 0 : existingGroup.id,
-        name: group.displayName,
+        name: group2.displayName,
         scimInfo: {
-          externalId: group.externalId,
+          externalId: group2.externalId,
           isSync: true
         },
         icon: "UserGroup",
@@ -19635,11 +19635,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_fs11.default.createWriteStream(path2);
-      await db.dump(writeStream, exportOpts);
+      await db2.dump(writeStream, exportOpts);
       return path2;
     } else {
       const memStream = new MemoryStream2();
@@ -19647,7 +19647,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;
     }
   });
@@ -19751,12 +19751,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(
@@ -19772,11 +19772,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
     })
@@ -19795,7 +19795,7 @@ 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") {
@@ -19825,7 +19825,7 @@ function getGlobalDBFile(tmpPath) {
 function getListOfAppsInMulti(tmpPath) {
   return import_fs12.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;
@@ -19863,12 +19863,12 @@ async function importApp(appId, db, template) {
   } 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;
 }
 var import_path11, import_fs12, uuid4, tar4;
@@ -19897,54 +19897,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],
@@ -20481,15 +20481,15 @@ var init_sql = __esm({
       }
       // right now we only do filters on the specific table being queried
       addFilters(query, filters, opts) {
-        function iterate(structure, fn) {
+        function iterate(structure, fn2) {
           for (let [key, value] of Object.entries(structure)) {
             const updatedKey = db_exports.removeKeyNumbering(key);
             const isRelationshipField = updatedKey.includes(".");
             if (!opts.relationship && !isRelationshipField) {
-              fn(`${opts.tableName}.${updatedKey}`, value);
+              fn2(`${opts.tableName}.${updatedKey}`, value);
             }
             if (opts.relationship && isRelationshipField) {
-              fn(updatedKey, value);
+              fn2(updatedKey, value);
             }
           }
         }
@@ -20902,8 +20902,8 @@ var init_sql = __esm({
         if (operation === "DELETE" /* DELETE */) {
           row = processFn(await this.getReturningRow(queryFn, json2));
         }
-        const response = await queryFn(input, operation);
-        const results = processFn(response);
+        const response2 = await queryFn(input, operation);
+        const results = processFn(response2);
         if (operation === "CREATE" /* CREATE */ || operation === "UPDATE" /* UPDATE */) {
           let id;
           if (sqlClient === "mssql" /* MS_SQL */) {
@@ -21040,18 +21040,18 @@ var init_postgres = __esm({
         this.open = false;
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.openConnection();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         } finally {
           await this.closeConnection();
         }
-        return response;
+        return response2;
       }
       getBindingIdentifier() {
         return `$${this.index++}`;
@@ -21182,20 +21182,20 @@ var init_postgres = __esm({
         }
       }
       async create(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows.length ? response.rows : [{ created: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows.length ? response2.rows : [{ created: true }];
       }
       async read(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows;
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows;
       }
       async update(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows.length ? response.rows : [{ updated: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows.length ? response2.rows : [{ updated: true }];
       }
       async delete(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows.length ? response.rows : [{ deleted: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows.length ? response2.rows : [{ deleted: true }];
       }
       async query(json2) {
         const operation = this._operation(json2).toLowerCase();
@@ -21208,8 +21208,8 @@ var init_postgres = __esm({
           await this.closeConnection();
           return responses;
         } else {
-          const response = await this.internalQuery(input);
-          return response.rows.length ? response.rows : [{ [operation]: true }];
+          const response2 = await this.internalQuery(input);
+          return response2.rows.length ? response2.rows : [{ [operation]: true }];
         }
       }
     };
@@ -21383,16 +21383,16 @@ var init_dynamodb = __esm({
         this.client = new import_aws_sdk2.default.DynamoDB.DocumentClient(this.config);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           const scanRes = await new import_aws_sdk2.default.DynamoDB(this.config).listTables().promise();
-          response.connected = !!scanRes.$response;
+          response2.connected = !!scanRes.$response;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       async create(query) {
         const params2 = {
@@ -21407,11 +21407,11 @@ var init_dynamodb = __esm({
           IndexName: query.index ? query.index : void 0,
           ...query.json
         };
-        const response = await this.client.query(params2).promise();
-        if (response.Items) {
-          return response.Items;
+        const response2 = await this.client.query(params2).promise();
+        if (response2.Items) {
+          return response2.Items;
         }
-        return response;
+        return response2;
       }
       async scan(query) {
         const params2 = {
@@ -21419,11 +21419,11 @@ var init_dynamodb = __esm({
           IndexName: query.index ? query.index : void 0,
           ...query.json
         };
-        const response = await this.client.scan(params2).promise();
-        if (response.Items) {
-          return response.Items;
+        const response2 = await this.client.scan(params2).promise();
+        if (response2.Items) {
+          return response2.Items;
         }
-        return response;
+        return response2;
       }
       async describe(query) {
         const params2 = {
@@ -21797,16 +21797,16 @@ var init_mongodb = __esm({
         this.client = new import_mongodb.MongoClient(config.connectionString, options2);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.connect();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       async connect() {
         return this.client.connect();
@@ -21877,8 +21877,8 @@ var init_mongodb = __esm({
       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 json2 = this.createObjectIds(query.json);
           switch (query.extra.actionType) {
             case "insertOne": {
@@ -21903,8 +21903,8 @@ var init_mongodb = __esm({
       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 json2 = this.createObjectIds(query.json);
           switch (query.extra.actionType) {
             case "find": {
@@ -21946,8 +21946,8 @@ var init_mongodb = __esm({
       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");
@@ -21984,8 +21984,8 @@ var init_mongodb = __esm({
       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");
@@ -22021,9 +22021,9 @@ var init_mongodb = __esm({
         var _a;
         try {
           await this.connect();
-          const db = this.client.db(this.config.db);
-          const collection = db.collection(query.extra.collection);
-          let response = [];
+          const db2 = this.client.db(this.config.db);
+          const collection = db2.collection(query.extra.collection);
+          let response2 = [];
           if (((_a = query.extra) == null ? void 0 : _a.actionType) === "pipeline") {
             for await (const doc of collection.aggregate(
               query.steps.map(({ key, value }) => {
@@ -22032,17 +22032,17 @@ var init_mongodb = __esm({
                 return this.createObjectIds(temp);
               })
             )) {
-              response.push(doc);
+              response2.push(doc);
             }
           } else {
             const stages = query.json;
             for await (const doc of collection.aggregate(
               stages ? this.createObjectIds(stages) : []
             )) {
-              response.push(doc);
+              response2.push(doc);
             }
           }
-          return response;
+          return response2;
         } catch (err) {
           console.error("Error writing to mongodb", err);
           throw err;
@@ -22298,16 +22298,16 @@ var init_couchdb = __esm({
         this.client = db_exports.DatabaseWithConnection(config.database, config.url);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           const result = await this.query("exists", "validation error", {});
-          response.connected = result === true;
+          response2.connected = result === true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       async query(command, errorMsg, query) {
         try {
@@ -22457,16 +22457,16 @@ var init_microsoftSqlServer = __esm({
         }
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.connect();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       getBindingIdentifier() {
         return `@p${this.index++}`;
@@ -22592,23 +22592,23 @@ var init_microsoftSqlServer = __esm({
       }
       async read(query) {
         await this.connect();
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.recordset;
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.recordset;
       }
       async create(query) {
         await this.connect();
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.recordset || [{ created: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.recordset || [{ created: true }];
       }
       async update(query) {
         await this.connect();
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.recordset || [{ updated: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.recordset || [{ updated: true }];
       }
       async delete(query) {
         await this.connect();
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.recordset || [{ deleted: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.recordset || [{ deleted: true }];
       }
       async query(json2) {
         const schema = this.config.schema;
@@ -22782,16 +22782,16 @@ var init_s3 = __esm({
         this.client = new import_aws_sdk3.default.S3(this.config);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.client.listBuckets().promise();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       async create(query) {
         var _a;
@@ -22812,14 +22812,14 @@ var init_s3 = __esm({
         return await this.client.createBucket(params2).promise();
       }
       async read(query) {
-        const response = await this.client.listObjects({
+        const response2 = await this.client.listObjects({
           Bucket: query.bucket,
           Delimiter: query.delimiter,
           Marker: query.marker,
           MaxKeys: query.maxKeys,
           Prefix: query.prefix
         }).promise();
-        return response.Contents;
+        return response2.Contents;
       }
       async readCsv(query) {
         const stream3 = this.client.getObject({
@@ -22831,11 +22831,11 @@ var init_s3 = __esm({
           stream3.on("error", (err) => {
             reject(err);
           });
-          const response = (0, import_csvtojson.default)().fromStream(stream3).on("error", () => {
+          const response2 = (0, import_csvtojson.default)().fromStream(stream3).on("error", () => {
             csvError = true;
           });
           stream3.on("finish", () => {
-            resolve2(response);
+            resolve2(response2);
           });
         }).catch((err) => {
           if (csvError) {
@@ -23121,7 +23121,7 @@ var init_mysql = __esm({
         };
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
@@ -23129,11 +23129,11 @@ var init_mysql = __esm({
             { sql: "SELECT 1+1 AS checkRes" },
             { connect: true }
           );
-          response.connected = (result == null ? void 0 : result.checkRes) == 2;
+          response2.connected = (result == null ? void 0 : result.checkRes) == 2;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       getBindingIdentifier() {
         return "?";
@@ -23157,8 +23157,8 @@ var init_mysql = __esm({
           }
           const baseBindings = query.bindings || [];
           const bindings = (opts == null ? void 0 : opts.disableCoercion) ? baseBindings : bindingTypeCoerce(baseBindings);
-          const response = await this.client.query(query.sql, bindings);
-          return response[0];
+          const response2 = await this.client.query(query.sql, bindings);
+          return response2[0];
         } finally {
           if ((opts == null ? void 0 : opts.connect) && this.client) {
             await this.disconnect();
@@ -23324,16 +23324,16 @@ var init_arangodb = __esm({
         this.client = new import_arangojs.Database(newConfig);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.client.get();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         }
-        return response;
+        return response2;
       }
       async read(query) {
         try {
@@ -23478,51 +23478,51 @@ var init_rest = __esm({
         this.startTimeMs = import_perf_hooks.performance.now();
         this.config = config;
       }
-      async parseResponse(response, pagination3) {
-        let data, raw, headers;
-        const contentType = response.headers.get("content-type") || "";
+      async parseResponse(response2, pagination3) {
+        let data2, raw, headers;
+        const contentType = response2.headers.get("content-type") || "";
         try {
           if (contentType.includes("application/json")) {
-            data = await response.json();
-            raw = JSON.stringify(data);
+            data2 = await response2.json();
+            raw = JSON.stringify(data2);
           } else if (contentType.includes("text/xml") || contentType.includes("application/xml")) {
-            const rawXml = await response.text();
-            data = await xmlParser(rawXml, {
+            const rawXml = await response2.text();
+            data2 = await xmlParser(rawXml, {
               explicitArray: false,
               trim: true,
               explicitRoot: false
             }) || {};
-            const keys2 = Object.keys(data);
-            if (keys2.length === 1 && Array.isArray(data[keys2[0]])) {
-              data = data[keys2[0]];
+            const keys2 = Object.keys(data2);
+            if (keys2.length === 1 && Array.isArray(data2[keys2[0]])) {
+              data2 = data2[keys2[0]];
             }
             raw = rawXml;
           } else if (contentType.includes("application/pdf")) {
-            data = await response.arrayBuffer();
-            raw = Buffer.from(data);
+            data2 = await response2.arrayBuffer();
+            raw = Buffer.from(data2);
           } else {
-            data = await response.text();
-            raw = data;
+            data2 = await response2.text();
+            raw = data2;
           }
         } catch (err) {
           throw "Failed to parse response body.";
         }
         const size = formatBytes(
-          response.headers.get("content-length") || Buffer.byteLength(raw, "utf8")
+          response2.headers.get("content-length") || Buffer.byteLength(raw, "utf8")
         );
         const time = `${Math.round(import_perf_hooks.performance.now() - this.startTimeMs)}ms`;
-        headers = response.headers.raw();
+        headers = response2.headers.raw();
         for (let [key, value] of Object.entries(headers)) {
           headers[key] = Array.isArray(value) ? value[0] : value;
         }
         let nextCursor = null;
         if (pagination3 == null ? void 0 : pagination3.responseParam) {
-          nextCursor = (0, import_lodash3.get)(data, pagination3.responseParam);
+          nextCursor = (0, import_lodash3.get)(data2, pagination3.responseParam);
         }
         return {
-          data,
+          data: data2,
           info: {
-            code: response.status,
+            code: response2.status,
             size,
             time
           },
@@ -23704,8 +23704,8 @@ var init_rest = __esm({
         if (await blacklist_exports.isBlacklisted(url)) {
           throw new Error("Cannot connect to URL.");
         }
-        const response = await (0, import_node_fetch8.default)(url, input);
-        return await this.parseResponse(response, pagination3);
+        const response2 = await (0, import_node_fetch8.default)(url, input);
+        return await this.parseResponse(response2, pagination3);
       }
       async create(opts) {
         return this._req({ ...opts, method: "POST" });
@@ -23868,7 +23868,7 @@ var init_googlesheets = __esm({
         return parts.length > 5 ? parts[5] : spreadsheetId;
       }
       async fetchAccessToken(payload) {
-        const response = await (0, import_node_fetch9.default)("https://www.googleapis.com/oauth2/v4/token", {
+        const response2 = await (0, import_node_fetch9.default)("https://www.googleapis.com/oauth2/v4/token", {
           method: "POST",
           body: JSON.stringify({
             ...payload,
@@ -23878,8 +23878,8 @@ var init_googlesheets = __esm({
             "Content-Type": "application/json"
           }
         });
-        const json2 = await response.json();
-        if (response.status !== 200) {
+        const json2 = await response2.json();
+        if (response2.status !== 200) {
           throw new Error(
             `Error authenticating with google sheets. ${json2.error_description}`
           );
@@ -24116,9 +24116,9 @@ var init_googlesheets = __esm({
           }
           const filtered2 = filters_exports.runLuceneQuery(rows2, query.filters);
           const headerValues = sheet.headerValues;
-          let response = [];
+          let response2 = [];
           for (let row of filtered2) {
-            response.push(
+            response2.push(
               this.buildRowObject(headerValues, row._rawData, row._rowNumber)
             );
           }
@@ -24129,14 +24129,14 @@ var init_googlesheets = __esm({
               });
             }
             const [sortField, sortInfo] = Object.entries(query.sort)[0];
-            response = filters_exports.luceneSort(
-              response,
+            response2 = filters_exports.luceneSort(
+              response2,
               sortField,
               sortInfo.direction,
               sortInfo.type
             );
           }
-          return response;
+          return response2;
         } catch (err) {
           console.error("Error reading from google sheets", err);
           throw err;
@@ -24440,18 +24440,18 @@ var init_redis4 = __esm({
         });
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         try {
           await this.client.ping();
-          response.connected = true;
+          response2.connected = true;
         } catch (e) {
-          response.error = e.message;
+          response2.error = e.message;
         } finally {
           await this.disconnect();
         }
-        return response;
+        return response2;
       }
       async disconnect() {
         return this.client.quit();
@@ -24467,11 +24467,11 @@ var init_redis4 = __esm({
       }
       async create(query) {
         return this.redisContext(async () => {
-          const response = await this.client.set(query.key, query.value);
+          const response2 = await this.client.set(query.key, query.value);
           if (query.ttl) {
             await this.client.expire(query.key, query.ttl);
           }
-          return response;
+          return response2;
         });
       }
       async read(query) {
@@ -24867,27 +24867,27 @@ var init_oracle = __esm({
         return (columnsResponse.rows || []).map((row) => row.TABLE_NAME);
       }
       async testConnection() {
-        const response = {
+        const response2 = {
           connected: false
         };
         let connection;
         try {
           connection = await this.getConnection();
-          response.connected = true;
+          response2.connected = true;
         } catch (err) {
-          response.connected = false;
-          response.error = err.message;
+          response2.connected = false;
+          response2.error = err.message;
         } finally {
           if (connection) {
             try {
               await connection.close();
             } catch (err) {
-              response.connected = false;
-              response.error = err.message;
+              response2.connected = false;
+              response2.error = err.message;
             }
           }
         }
-        return response;
+        return response2;
       }
       async internalQuery(query) {
         let connection;
@@ -24908,20 +24908,20 @@ var init_oracle = __esm({
         }
       }
       async create(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows && response.rows.length ? response.rows : [{ created: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows && response2.rows.length ? response2.rows : [{ created: true }];
       }
       async read(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows ? response.rows : [];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows ? response2.rows : [];
       }
       async update(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows && response.rows.length ? response.rows : [{ updated: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows && response2.rows.length ? response2.rows : [{ updated: true }];
       }
       async delete(query) {
-        const response = await this.internalQuery(getSqlQuery(query));
-        return response.rows && response.rows.length ? response.rows : [{ deleted: true }];
+        const response2 = await this.internalQuery(getSqlQuery(query));
+        return response2.rows && response2.rows.length ? response2.rows : [{ deleted: true }];
       }
       async query(json2) {
         var _a, _b, _c;
@@ -24939,15 +24939,15 @@ var init_oracle = __esm({
             const queryFn = (query) => this.internalQuery(query);
             deletedRows = await this.getReturningRow(queryFn, json2);
           }
-          const response = await this.internalQuery(input);
+          const response2 = await this.internalQuery(input);
           if ((_a = deletedRows == null ? void 0 : deletedRows.rows) == null ? void 0 : _a.length) {
             return deletedRows.rows;
-          } else if ((_b = response.rows) == null ? void 0 : _b.length) {
-            return response.rows;
+          } else if ((_b = response2.rows) == null ? void 0 : _b.length) {
+            return response2.rows;
           } else {
-            if (response.lastRowid && ((_c = json2.endpoint) == null ? void 0 : _c.entityId) && operation !== "DELETE" /* DELETE */) {
+            if (response2.lastRowid && ((_c = json2.endpoint) == null ? void 0 : _c.entityId) && operation !== "DELETE" /* DELETE */) {
               const lastRow = await this.internalQuery({
-                sql: `SELECT * FROM "${json2.endpoint.entityId}" WHERE ROWID = '${response.lastRowid}'`
+                sql: `SELECT * FROM "${json2.endpoint.entityId}" WHERE ROWID = '${response2.lastRowid}'`
               });
               return lastRow.rows;
             } else {
@@ -25119,8 +25119,8 @@ async function enrichDatasourceWithValues(datasource2) {
   };
 }
 async function enrich2(datasource2) {
-  const { datasource: response } = await enrichDatasourceWithValues(datasource2);
-  return response;
+  const { datasource: response2 } = await enrichDatasourceWithValues(datasource2);
+  return response2;
 }
 async function get11(datasourceId, opts) {
   const appDb = context_exports.getAppDB();
@@ -25243,11 +25243,11 @@ var init_datasources3 = __esm({
 });
 
 // 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
     })
@@ -25259,7 +25259,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.";
@@ -25271,14 +25271,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;
@@ -25318,22 +25318,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);
-  webhook._rev = response.rev;
+  const response2 = await db2.put(webhook);
+  webhook._rev = response2.rev;
   return webhook;
 }
 async function destroy6(id, rev) {
-  const db = context_exports.getAppDB();
+  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, rev);
 }
 var init_webhook2 = __esm({
   "src/sdk/app/automations/webhook.ts"() {
@@ -25404,8 +25404,8 @@ async function processUser(user, opts = {}) {
   return user;
 }
 async function getRawGlobalUser(userId) {
-  const db = tenancy.getGlobalDB();
-  return db.get(getGlobalIDFromUserMetadataID2(userId));
+  const db2 = tenancy.getGlobalDB();
+  return db2.get(getGlobalIDFromUserMetadataID2(userId));
 }
 async function getGlobalUser(userId) {
   const appId = context_exports.getAppId();
@@ -25414,14 +25414,14 @@ async function getGlobalUser(userId) {
 }
 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
       })
@@ -25480,7 +25480,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;
@@ -25497,7 +25497,7 @@ async function syncUsersToApp(appId, users2, groups) {
       }
       let metadata;
       try {
-        metadata = await db.get(metadataId);
+        metadata = await db2.get(metadataId);
       } catch (err) {
         if (err.status !== 404) {
           throw err;
@@ -25511,7 +25511,7 @@ async function syncUsersToApp(appId, users2, groups) {
         }
       }
       if (deletedUser || !roleId) {
-        await db.remove(metadata);
+        await db2.remove(metadata);
         continue;
       }
       if (roleId) {
@@ -25519,7 +25519,7 @@ async function syncUsersToApp(appId, users2, groups) {
       }
       let combined = sdk_default.users.combineMetadataAndUser(ctxUser, metadata);
       if (combined) {
-        await db.put(combined);
+        await db2.put(combined);
       }
     }
   });
@@ -25720,7 +25720,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 */) {
@@ -25737,7 +25737,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;
@@ -25761,18 +25761,18 @@ __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 response2 = await db2.allDocs(
     getRowParams2(null, null, {
       include_docs: true
     })
   );
-  return response.rows.map((row) => row.doc);
+  return response2.rows.map((row) => row.doc);
 }
 var init_rows4 = __esm({
   "src/sdk/app/rows/rows.ts"() {
@@ -25831,15 +25831,15 @@ function combineMetadataAndUser(user, metadata) {
   return null;
 }
 async function rawUserMetadata() {
-  const db = context_exports.getAppDB();
-  return (await db.allDocs(
+  const db2 = context_exports.getAppDB();
+  return (await db2.allDocs(
     getUserMetadataParams2(null, {
       include_docs: true
     })
   )).rows.map((row) => row.doc);
 }
 async function syncGlobalUsers() {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const resp = await Promise.all([getGlobalUsers(), rawUserMetadata()]);
   const users2 = resp[0];
   const metadata = resp[1];
@@ -25851,20 +25851,20 @@ async function syncGlobalUsers() {
     }
   }
   let foundEmails = [];
-  for (let data of metadata) {
-    if (!data._id) {
+  for (let data2 of metadata) {
+    if (!data2._id) {
       continue;
     }
-    const alreadyExisting = data.email && foundEmails.indexOf(data.email) !== -1;
-    const globalId = getGlobalIDFromUserMetadataID2(data._id);
+    const alreadyExisting = data2.email && foundEmails.indexOf(data2.email) !== -1;
+    const globalId = getGlobalIDFromUserMetadataID2(data2._id);
     if (!users2.find((user) => user._id === globalId) || alreadyExisting) {
-      toWrite.push({ ...data, _deleted: true });
+      toWrite.push({ ...data2, _deleted: true });
     }
-    if (data.email) {
-      foundEmails.push(data.email);
+    if (data2.email) {
+      foundEmails.push(data2.email);
     }
   }
-  await db.bulkDocs(toWrite);
+  await db2.bulkDocs(toWrite);
 }
 var import_lodash6;
 var init_utils17 = __esm({
@@ -25997,13 +25997,13 @@ __export(plugins_exports2, {
   processUploaded: () => processUploaded
 });
 async function fetch16(type) {
-  const db = tenancy.getGlobalDB();
-  const response = await db.allDocs(
+  const db2 = tenancy.getGlobalDB();
+  const response2 = await db2.allDocs(
     db_exports.getPluginParams(null, {
       include_docs: true
     })
   );
-  let plugins2 = response.rows.map((row) => row.doc);
+  let plugins2 = response2.rows.map((row) => row.doc);
   plugins2 = objectStore_exports2.enrichPluginURLs(plugins2);
   if (type) {
     return plugins2.filter((plugin) => {
@@ -26210,8 +26210,8 @@ async function getFullUser(ctx, userId) {
   delete global._id;
   delete global._rev;
   try {
-    const db = context_exports.getAppDB();
-    metadata = await db.get(userId);
+    const db2 = context_exports.getAppDB();
+    metadata = await db2.get(userId);
   } catch (err) {
   }
   delete metadata.csrfToken;
@@ -26250,20 +26250,20 @@ async function fetchMetadata(ctx) {
   ctx.body = users2;
 }
 async function updateMetadata(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const user = ctx.request.body;
   delete user.roles;
   const metadata = {
     tableId: InternalTables.USER_METADATA,
     ...user
   };
-  ctx.body = await db.put(metadata);
+  ctx.body = await db2.put(metadata);
 }
 async function destroyMetadata(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   try {
-    const dbUser = await db.get(ctx.params.id);
-    await db.remove(dbUser._id, dbUser._rev);
+    const dbUser = await db2.get(ctx.params.id);
+    await db2.remove(dbUser._id, dbUser._rev);
   } catch (err) {
   }
   ctx.body = {
@@ -26364,7 +26364,7 @@ async function getDatasourceAndQuery(json2) {
   return makeExternalQuery(datasource2, json2);
 }
 async function findRow(ctx, tableId, rowId) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   let row;
   if (tableId === InternalTables.USER_METADATA) {
     ctx.params = {
@@ -26373,7 +26373,7 @@ async function findRow(ctx, tableId, rowId) {
     await findMetadata(ctx);
     row = ctx.body;
   } else {
-    row = await db.get(rowId);
+    row = await db2.get(rowId);
   }
   if (row.tableId !== tableId) {
     throw "Supplied tableId does not match the rows tableId";
@@ -26599,9 +26599,9 @@ async function run19({ inputs, context }) {
         }
       ]
     });
-    const response = (_c = (_b = (_a = completion == null ? void 0 : completion.data) == null ? void 0 : _a.choices[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content;
+    const response2 = (_c = (_b = (_a = completion == null ? void 0 : completion.data) == null ? void 0 : _a.choices[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content;
     return {
-      response,
+      response: response2,
       success: true
     };
   } catch (err) {
@@ -26749,8 +26749,8 @@ function formatResponse(resp) {
   }
   return resp;
 }
-function hasExtraData(response) {
-  return typeof response === "object" && !Array.isArray(response) && response && response.data != null && response.info != null;
+function hasExtraData(response2) {
+  return typeof response2 === "object" && !Array.isArray(response2) && response2 && response2.data != null && response2.info != null;
 }
 var utils_default = {
   hasExtraData,
@@ -26813,7 +26813,7 @@ var _Thread = class {
     const timeout2 = this.timeoutMs;
     return new Promise((resolve2, reject) => {
       function fire(worker) {
-        worker.execute(job, (err, response) => {
+        worker.execute(job, (err, response2) => {
           if (err && err.type === "TimeoutError") {
             reject(
               new Error(`Query response time exceeded ${timeout2}ms timeout.`)
@@ -26821,7 +26821,7 @@ var _Thread = class {
           } else if (err) {
             reject(err);
           } else {
-            resolve2(response);
+            resolve2(response2);
           }
         });
       }
@@ -27178,13 +27178,13 @@ function request(ctx, request2) {
   logging_exports.correlation.setHeader(request2.headers);
   return request2;
 }
-async function checkResponse(response, errorMsg, { ctx } = {}) {
-  if (response.status !== 200) {
+async function checkResponse(response2, errorMsg, { ctx } = {}) {
+  if (response2.status !== 200) {
     let error;
     try {
-      error = await response.json();
+      error = await response2.json();
     } catch (err) {
-      error = await response.text();
+      error = await response2.text();
     }
     const msg = `Unable to ${errorMsg} - ${error.message ? error.message : error}`;
     if (ctx) {
@@ -27193,10 +27193,10 @@ async function checkResponse(response, errorMsg, { ctx } = {}) {
       throw msg;
     }
   }
-  return response.json();
+  return response2.json();
 }
 async function sendSmtpEmail(to, from, subject, contents, cc, bcc, automation) {
-  const response = await (0, import_node_fetch10.default)(
+  const response2 = await (0, import_node_fetch10.default)(
     checkSlashesInUrl2(environment_default.WORKER_URL + `/api/global/email/send`),
     request(void 0, {
       method: "POST",
@@ -27212,7 +27212,7 @@ async function sendSmtpEmail(to, from, subject, contents, cc, bcc, automation) {
       }
     })
   );
-  return checkResponse(response, "send email");
+  return checkResponse(response2, "send email");
 }
 
 // src/automations/steps/sendSmtpEmail.ts
@@ -27279,7 +27279,7 @@ async function run3({ inputs }) {
   }
   to = to || void 0;
   try {
-    let response = await sendSmtpEmail(
+    let response2 = await sendSmtpEmail(
       to,
       from,
       subject,
@@ -27290,7 +27290,7 @@ async function run3({ inputs }) {
     );
     return {
       success: true,
-      response
+      response: response2
     };
   } catch (err) {
     return {
@@ -27328,9 +27328,9 @@ init_utils13();
 init_src();
 var SCREEN_PREFIX = DocumentType5.SCREEN + SEPARATOR7;
 async function createLinkView() {
-  const db = context_exports.getAppDB();
-  const designDoc = await db.get("_design/database");
-  const view = {
+  const db2 = context_exports.getAppDB();
+  const designDoc = await db2.get("_design/database");
+  const view2 = {
     map: function(doc) {
       if (doc.type === "link") {
         let doc1 = doc.doc1;
@@ -27352,9 +27352,9 @@ async function createLinkView() {
   };
   designDoc.views = {
     ...designDoc.views,
-    [ViewName6.LINK]: view
+    [ViewName6.LINK]: view2
   };
-  await db.put(designDoc);
+  await db2.put(designDoc);
 }
 
 // src/db/linkedRows/linkUtils.ts
@@ -27365,7 +27365,7 @@ var IncludeDocs = {
 };
 async function getLinkDocuments(args) {
   const { tableId, rowId, includeDocs } = args;
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   let params2;
   if (rowId != null) {
     params2 = { key: [tableId, rowId] };
@@ -27374,7 +27374,7 @@ async function getLinkDocuments(args) {
   }
   params2.include_docs = !!includeDocs;
   try {
-    let linkRows = (await db.query(getQueryIndex3(ViewName6.LINK), params2)).rows;
+    let linkRows = (await db2.query(getQueryIndex3(ViewName6.LINK), params2)).rows;
     const foundIds = [];
     linkRows = linkRows.filter((link) => {
       if (tableId && link.key[0] !== tableId || rowId && link.key[1] !== rowId) {
@@ -27410,12 +27410,12 @@ function getLinkedTableIDs(table) {
   return Object.values(table.schema).filter((column) => column.type === "link" /* LINK */).map((column) => column.tableId);
 }
 async function getLinkedTable(id, tables) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   let linkedTable = tables.find((table) => table._id === id);
   if (linkedTable) {
     return linkedTable;
   }
-  linkedTable = await db.get(id);
+  linkedTable = await db2.get(id);
   if (linkedTable) {
     tables.push(linkedTable);
   }
@@ -27744,9 +27744,9 @@ var LinkController = class {
           throw new Error("Cannot overwrite existing column.");
         }
         linkedTable.schema[field.fieldName] = linkedField;
-        const response = await this._db.put(linkedTable);
+        const response2 = await this._db.put(linkedTable);
         if (linkedTable._id === table._id) {
-          table._rev = response.rev;
+          table._rev = response2.rev;
         }
       }
     }
@@ -28196,10 +28196,10 @@ async function getLinksForRows(rows2) {
   );
 }
 async function getFullLinkedDocs(links) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const linkedRowIds = links.map((link) => link.id);
   const uniqueRowIds = [...new Set(linkedRowIds)];
-  let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
+  let dbRows = (await db2.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
     (row) => row.doc
   );
   const linked = linkedRowIds.map((id) => dbRows.find((row) => row && row._id === id)).filter((row) => row != null);
@@ -28328,9 +28328,7 @@ async function runView(view, calculation, group, data) {
       }))
     );
     let fn = (doc, emit2) => emit2(doc._id);
-    (0, eval)(
-      "fn = " + ((_a = view == null ? void 0 : view.map) == null ? void 0 : _a.replace("function (doc)", "function (doc, emit)"))
-    );
+    eval("fn = " + ((_a = view == null ? void 0 : view.map) == null ? void 0 : _a.replace("function (doc)", "function (doc, emit)")));
     const queryFns = {
       meta: view.meta,
       map: fn
@@ -28464,16 +28462,16 @@ function parseFilterExpression(filters) {
 function parseEmitExpression(field, groupBy) {
   return `emit(doc["${groupBy || "_id"}"], doc["${field}"]);`;
 }
-function viewBuilder_default({ field, tableId, groupBy, filters = [], calculation }, groupByMulti) {
+function viewBuilder_default({ field, tableId, groupBy, filters = [], calculation: calculation2 }, groupByMulti) {
   if (filters && filters.length > 0 && filters[0].conjunction) {
     delete filters[0].conjunction;
   }
   let schema = null, statFilter = null;
   let groupBySchema = groupByMulti ? GROUP_PROPERTY_MULTI : GROUP_PROPERTY;
-  if (calculation) {
+  if (calculation2) {
     schema = {
       ...groupBy ? groupBySchema : FIELD_PROPERTY,
-      ...SCHEMA_MAP[calculation]
+      ...SCHEMA_MAP[calculation2]
     };
     if (!filters.find(
       (filter2) => filter2.key === field && filter2.condition === CONDITIONS.NOT_EMPTY
@@ -28488,7 +28486,7 @@ function viewBuilder_default({ field, tableId, groupBy, filters = [], calculatio
   const emitExpression = parseEmitExpression(field, groupBy);
   const tableExpression = `doc.tableId === "${tableId}"`;
   const coreExpression = statFilter ? `(${tableExpression} && ${statFilter})` : tableExpression;
-  const reduction = field && calculation ? { reduce: `_${calculation}` } : {};
+  const reduction = field && calculation2 ? { reduce: `_${calculation2}` } : {};
   return {
     meta: {
       field,
@@ -28496,7 +28494,7 @@ function viewBuilder_default({ field, tableId, groupBy, filters = [], calculatio
       groupBy,
       filters,
       schema,
-      calculation
+      calculation: calculation2
     },
     map: `function (doc) {
       if (${coreExpression} ${filterExpression}) {
@@ -28508,36 +28506,36 @@ function viewBuilder_default({ field, tableId, groupBy, filters = [], calculatio
 }
 
 // src/api/controllers/view/utils.ts
-async function migrateToInMemoryView(db, viewName) {
-  const designDoc = await db.get("_design/database");
-  const view = viewBuilder_default(designDoc.views[viewName].meta);
+async function migrateToInMemoryView(db2, viewName) {
+  const designDoc = await db2.get("_design/database");
+  const view2 = viewBuilder_default(designDoc.views[viewName].meta);
   delete designDoc.views[viewName];
-  await db.put(designDoc);
-  await exports.saveView(db, null, viewName, view);
-}
-async function migrateToDesignView(db, viewName) {
-  let view = await db.get(generateMemoryViewID(viewName));
-  const designDoc = await db.get("_design/database");
-  designDoc.views[viewName] = viewBuilder_default(view.view.meta);
-  await db.put(designDoc);
-  await db.remove(view._id, view._rev);
-}
-async function getFromDesignDoc(db, viewName) {
-  const designDoc = await db.get("_design/database");
-  let view = designDoc.views[viewName];
-  if (view == null) {
+  await db2.put(designDoc);
+  await exports.saveView(db2, null, viewName, view2);
+}
+async function migrateToDesignView(db2, viewName) {
+  let view2 = await db2.get(generateMemoryViewID(viewName));
+  const designDoc = await db2.get("_design/database");
+  designDoc.views[viewName] = viewBuilder_default(view2.view.meta);
+  await db2.put(designDoc);
+  await db2.remove(view2._id, view2._rev);
+}
+async function getFromDesignDoc(db2, viewName) {
+  const designDoc = await db2.get("_design/database");
+  let view2 = designDoc.views[viewName];
+  if (view2 == null) {
     throw { status: 404, message: "Unable to get view" };
   }
-  return view;
+  return view2;
 }
-async function getFromMemoryDoc(db, viewName) {
-  let view = await db.get(generateMemoryViewID(viewName));
-  if (view) {
-    view = view.view;
+async function getFromMemoryDoc(db2, viewName) {
+  let view2 = await db2.get(generateMemoryViewID(viewName));
+  if (view2) {
+    view2 = view2.view;
   } else {
     throw { status: 404, message: "Unable to get view" };
   }
-  return view;
+  return view2;
 }
 
 // src/api/controllers/row/internal.ts
@@ -28551,7 +28549,7 @@ init_src2();
 var { isEqual: isEqual2 } = require("lodash");
 var { cloneDeep: cloneDeep8 } = require("lodash/fp");
 async function updateRelatedFormula(table, enrichedRows) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   if (!table.relatedFormula) {
     return;
   }
@@ -28578,7 +28576,7 @@ async function updateRelatedFormula(table, enrichedRows) {
         if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
           continue;
         }
-        relatedTable = await db.get(tableId);
+        relatedTable = await db2.get(tableId);
       } catch (err) {
       }
       for (let column of Object.values(relatedTable.schema)) {
@@ -28600,7 +28598,7 @@ async function updateRelatedFormula(table, enrichedRows) {
 async function finaliseRow(table, row, { oldTable, updateFormula } = {
   updateFormula: true
 }) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   row.type = "row";
   let enrichedRow = await outputProcessing(table, cloneDeep8(row), {
     squash: false
@@ -28611,22 +28609,22 @@ async function finaliseRow(table, row, { oldTable, updateFormula } = {
   });
   if (oldTable && !isEqual2(oldTable, table)) {
     try {
-      await db.put(table);
+      await db2.put(table);
     } catch (err) {
       if (err.status === 409) {
-        const updatedTable = await db.get(table._id);
-        let response2 = processAutoColumn(null, updatedTable, row, {
+        const updatedTable = await db2.get(table._id);
+        let response3 = processAutoColumn(null, updatedTable, row, {
           reprocessing: true
         });
-        await db.put(response2.table);
-        row = response2.row;
+        await db2.put(response3.table);
+        row = response3.row;
       } else {
         throw err;
       }
     }
   }
-  const response = await db.put(row);
-  enrichedRow._rev = response.rev;
+  const response2 = await db2.put(row);
+  enrichedRow._rev = response2.rev;
   enrichedRow = await processFormulas(table, enrichedRow, { dynamic: false });
   if (updateFormula) {
     await updateRelatedFormula(table, enrichedRow);
@@ -28643,52 +28641,52 @@ var CALCULATION_TYPES = {
   COUNT: "count",
   STATS: "stats"
 };
-async function getView(db, viewName) {
+async function getView(db2, viewName) {
   let mainGetter = environment_default.SELF_HOSTED ? getFromDesignDoc : getFromMemoryDoc;
   let secondaryGetter = environment_default.SELF_HOSTED ? getFromMemoryDoc : getFromDesignDoc;
   let migration = environment_default.SELF_HOSTED ? migrateToDesignView : migrateToInMemoryView;
   let viewInfo, migrate = false;
   try {
-    viewInfo = await mainGetter(db, viewName);
+    viewInfo = await mainGetter(db2, viewName);
   } catch (err) {
     if (err.status !== 404) {
       viewInfo = null;
     } else {
-      viewInfo = await secondaryGetter(db, viewName);
+      viewInfo = await secondaryGetter(db2, viewName);
       migrate = !!viewInfo;
     }
   }
   if (migrate) {
-    await migration(db, viewName);
+    await migration(db2, viewName);
   }
   if (!viewInfo) {
     throw "View does not exist.";
   }
   return viewInfo;
 }
-async function getRawTableData(ctx, db, tableId) {
+async function getRawTableData(ctx, db2, tableId) {
   let rows2;
   if (tableId === InternalTables.USER_METADATA) {
     await fetchMetadata(ctx);
     rows2 = ctx.body;
   } else {
-    const response = await db.allDocs(
+    const response2 = await db2.allDocs(
       getRowParams2(tableId, null, {
         include_docs: true
       })
     );
-    rows2 = response.rows.map((row) => row.doc);
+    rows2 = response2.rows.map((row) => row.doc);
   }
   return rows2;
 }
 async function patch(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const inputs = ctx.request.body;
   const tableId = inputs.tableId;
   const isUserTable = tableId === InternalTables.USER_METADATA;
   let oldRow;
   try {
-    let dbTable2 = await db.get(tableId);
+    let dbTable2 = await db2.get(tableId);
     oldRow = await outputProcessing(
       dbTable2,
       await findRow(ctx, tableId, inputs._id)
@@ -28702,7 +28700,7 @@ async function patch(ctx) {
       throw "Row does not exist";
     }
   }
-  let dbTable = await db.get(tableId);
+  let dbTable = await db2.get(tableId);
   let combinedRow = (0, import_fp3.cloneDeep)(oldRow);
   for (let key of Object.keys(inputs)) {
     if (!dbTable.schema[key])
@@ -28736,13 +28734,13 @@ async function patch(ctx) {
   });
 }
 async function save8(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   let inputs = ctx.request.body;
   inputs.tableId = ctx.params.tableId;
   if (!inputs._rev && !inputs._id) {
     inputs._id = generateRowID2(inputs.tableId);
   }
-  const dbTable = await db.get(inputs.tableId);
+  const dbTable = await db2.get(inputs.tableId);
   const tableClone = (0, import_fp3.cloneDeep)(dbTable);
   let { table, row } = inputProcessing(ctx.user, tableClone, inputs);
   const validateResult = await validate3({
@@ -28769,49 +28767,49 @@ async function fetchView(ctx) {
     ctx.params.tableId = viewName;
     return fetch18(ctx);
   }
-  const db = context_exports.getAppDB();
-  const { calculation, group, field } = ctx.query;
-  const viewInfo = await getView(db, viewName);
-  let response;
+  const db2 = context_exports.getAppDB();
+  const { calculation: calculation2, group: group2, field } = ctx.query;
+  const viewInfo = await getView(db2, viewName);
+  let response2;
   if (environment_default.SELF_HOSTED) {
-    response = await db.query(`database/${viewName}`, {
-      include_docs: !calculation,
-      group: !!group
+    response2 = await db2.query(`database/${viewName}`, {
+      include_docs: !calculation2,
+      group: !!group2
     });
   } else {
     const tableId = viewInfo.meta.tableId;
-    const data = await getRawTableData(ctx, db, tableId);
-    response = await runView(
+    const data2 = await getRawTableData(ctx, db2, tableId);
+    response2 = await runView(
       viewInfo,
-      calculation,
-      !!group,
-      data
+      calculation2,
+      !!group2,
+      data2
     );
   }
   let rows2;
-  if (!calculation) {
-    response.rows = response.rows.map((row) => row.doc);
+  if (!calculation2) {
+    response2.rows = response2.rows.map((row) => row.doc);
     let table;
     try {
-      table = await db.get(viewInfo.meta.tableId);
+      table = await db2.get(viewInfo.meta.tableId);
     } catch (err) {
       table = {
         schema: {}
       };
     }
-    rows2 = await outputProcessing(table, response.rows);
+    rows2 = await outputProcessing(table, response2.rows);
   }
-  if (calculation === CALCULATION_TYPES.STATS) {
-    response.rows = response.rows.map((row) => ({
+  if (calculation2 === CALCULATION_TYPES.STATS) {
+    response2.rows = response2.rows.map((row) => ({
       group: row.key,
       field,
       ...row.value,
       avg: row.value.sum / row.value.count
     }));
-    rows2 = response.rows;
+    rows2 = response2.rows;
   }
-  if (calculation === CALCULATION_TYPES.COUNT || calculation === CALCULATION_TYPES.SUM) {
-    rows2 = response.rows.map((row) => ({
+  if (calculation2 === CALCULATION_TYPES.COUNT || calculation2 === CALCULATION_TYPES.SUM) {
+    rows2 = response2.rows.map((row) => ({
       group: row.key,
       field,
       value: row.value
@@ -28820,28 +28818,28 @@ async function fetchView(ctx) {
   return rows2;
 }
 async function fetch18(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const tableId = ctx.params.tableId;
-  let table = await db.get(tableId);
-  let rows2 = await getRawTableData(ctx, db, tableId);
+  let table = await db2.get(tableId);
+  let rows2 = await getRawTableData(ctx, db2, tableId);
   return outputProcessing(table, rows2);
 }
 async function find5(ctx) {
-  const db = db_exports.getDB(ctx.appId);
-  const table = await db.get(ctx.params.tableId);
+  const db2 = db_exports.getDB(ctx.appId);
+  const table = await db2.get(ctx.params.tableId);
   let row = await findRow(ctx, ctx.params.tableId, ctx.params.rowId);
   row = await outputProcessing(table, row);
   return row;
 }
 async function destroy7(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const { _id } = ctx.request.body;
-  let row = await db.get(_id);
+  let row = await db2.get(_id);
   let _rev = ctx.request.body._rev || row._rev;
   if (row.tableId !== ctx.params.tableId) {
     throw "Supplied tableId doesn't match the row's tableId";
   }
-  const table = await db.get(row.tableId);
+  const table = await db2.get(row.tableId);
   row = await outputProcessing(table, row, { squash: false });
   await updateLinks({
     eventType: EventType.ROW_DELETE,
@@ -28850,22 +28848,22 @@ async function destroy7(ctx) {
   });
   await cleanupAttachments(table, { row });
   await updateRelatedFormula(table, row);
-  let response;
+  let response2;
   if (ctx.params.tableId === InternalTables.USER_METADATA) {
     ctx.params = {
       id: _id
     };
     await destroyMetadata(ctx);
-    response = ctx.body;
+    response2 = ctx.body;
   } else {
-    response = await db.remove(_id, _rev);
+    response2 = await db2.remove(_id, _rev);
   }
-  return { response, row };
+  return { response: response2, row };
 }
 async function bulkDestroy(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const tableId = ctx.params.tableId;
-  const table = await db.get(tableId);
+  const table = await db2.get(tableId);
   let { rows: rows2 } = ctx.request.body;
   const processedRows = await outputProcessing(table, rows2, {
     squash: false
@@ -28887,7 +28885,7 @@ async function bulkDestroy(ctx) {
       })
     );
   } else {
-    await db.bulkDocs(processedRows.map((row) => ({ ...row, _deleted: true })));
+    await db2.bulkDocs(processedRows.map((row) => ({ ...row, _deleted: true })));
   }
   await cleanupAttachments(table, { rows: processedRows });
   await updateRelatedFormula(table, processedRows);
@@ -28899,35 +28897,35 @@ async function search3(ctx) {
     return { rows: await fetch18(ctx) };
   }
   const { tableId } = ctx.params;
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const { paginate, query, ...params2 } = ctx.request.body;
   params2.version = ctx.version;
   params2.tableId = tableId;
   let table;
   if (params2.sort && !params2.sortType) {
-    table = await db.get(tableId);
+    table = await db2.get(tableId);
     const schema = table.schema;
     const sortField = schema[params2.sort];
     params2.sortType = sortField.type == "number" ? "number" : "string";
   }
-  let response;
+  let response2;
   if (paginate) {
-    response = await paginatedSearch2(query, params2);
+    response2 = await paginatedSearch2(query, params2);
   } else {
-    response = await fullSearch2(query, params2);
+    response2 = await fullSearch2(query, params2);
   }
-  if (response.rows && response.rows.length) {
+  if (response2.rows && response2.rows.length) {
     if (tableId === InternalTables.USER_METADATA) {
-      response.rows = await getGlobalUsersFromMetadata(response.rows);
+      response2.rows = await getGlobalUsersFromMetadata(response2.rows);
     }
-    table = table || await db.get(tableId);
-    response.rows = await outputProcessing(table, response.rows);
+    table = table || await db2.get(tableId);
+    response2.rows = await outputProcessing(table, response2.rows);
   }
-  return response;
+  return response2;
 }
 async function exportRows(ctx) {
-  const db = context_exports.getAppDB();
-  const table = await db.get(ctx.params.tableId);
+  const db2 = context_exports.getAppDB();
+  const table = await db2.get(ctx.params.tableId);
   const rowIds = ctx.request.body.rows;
   let format = ctx.query.format;
   if (typeof format !== "string") {
@@ -28936,11 +28934,11 @@ async function exportRows(ctx) {
   const { columns, query } = ctx.request.body;
   let result;
   if (rowIds) {
-    let response = (await db.allDocs({
+    let response2 = (await db2.allDocs({
       include_docs: true,
       keys: rowIds
     })).rows.map((row) => row.doc);
-    result = await outputProcessing(table, response);
+    result = await outputProcessing(table, response2);
   } else if (query) {
     let searchResponse = await search3(ctx);
     result = searchResponse.rows;
@@ -28972,30 +28970,30 @@ async function exportRows(ctx) {
   }
 }
 async function fetchEnrichedRow(ctx) {
-  const db = context_exports.getAppDB();
+  const db2 = context_exports.getAppDB();
   const tableId = ctx.params.tableId;
   const rowId = ctx.params.rowId;
   let [table, row] = await Promise.all([
-    db.get(tableId),
+    db2.get(tableId),
     findRow(ctx, tableId, rowId)
   ]);
   const linkVals = await getLinkDocuments({
     tableId,
     rowId
   });
-  let response = (await db.allDocs({
+  let response2 = (await db2.allDocs({
     include_docs: true,
     keys: linkVals.map((linkVal) => linkVal.id)
   })).rows.map((row2) => row2.doc);
   let groups = {}, tables = {};
-  for (let row2 of response) {
+  for (let row2 of response2) {
     if (!row2.tableId) {
       row2.tableId = getTableIDFromRowID(row2._id);
     }
     const linkedTableId = row2.tableId;
     if (groups[linkedTableId] == null) {
       groups[linkedTableId] = [row2];
-      tables[linkedTableId] = await db.get(linkedTableId);
+      tables[linkedTableId] = await db2.get(linkedTableId);
     } else {
       groups[linkedTableId].push(row2);
     }
@@ -29448,7 +29446,7 @@ var ExternalRequest = class {
       if (!lookupField || !row[lookupField]) {
         continue;
       }
-      const response = await getDatasourceAndQuery({
+      const response2 = await getDatasourceAndQuery({
         endpoint: getEndpoint(tableId2, "READ" /* READ */),
         filters: {
           equal: {
@@ -29456,7 +29454,7 @@ var ExternalRequest = class {
           }
         }
       });
-      const rows2 = !response[0].read ? response : [];
+      const rows2 = !response2[0].read ? response2 : [];
       const storeTo = isMany ? field.throughFrom || linkPrimaryKey : fieldName;
       related[storeTo] = { rows: rows2, isMany, tableId: tableId2 };
     }
@@ -29634,16 +29632,16 @@ var ExternalRequest = class {
         table
       }
     };
-    const response = await getDatasourceAndQuery(json2);
+    const response2 = await getDatasourceAndQuery(json2);
     if (operation !== "READ" /* READ */ && processed.manyRelationships) {
       await this.handleManyRelationships(
         table._id || "",
-        response[0],
+        response2[0],
         processed.manyRelationships
       );
     }
-    const output = this.outputProcessing(response, table, relationships);
-    return operation === "READ" /* READ */ && Array.isArray(response) ? output : { row: output[0], table };
+    const output = this.outputProcessing(response2, table, relationships);
+    return operation === "READ" /* READ */ && Array.isArray(response2) ? output : { row: output[0], table };
   }
 };
 
@@ -29718,11 +29716,11 @@ async function fetch19(ctx) {
 async function find6(ctx) {
   const id = ctx.params.rowId;
   const tableId = ctx.params.tableId;
-  const response = await handleRequest("READ" /* READ */, tableId, {
+  const response2 = await handleRequest("READ" /* READ */, tableId, {
     id: breakRowIdField(id),
     includeSqlRelationships: 0 /* EXCLUDE */
   });
-  return response ? response[0] : response;
+  return response2 ? response2[0] : response2;
 }
 async function destroy8(ctx) {
   const tableId = ctx.params.tableId;
@@ -29860,13 +29858,13 @@ async function fetchEnrichedRow2(ctx) {
     ctx.throw(400, "Datasource has not been configured for plus API.");
   }
   const tables = datasource2.entities;
-  const response = await handleRequest("READ" /* READ */, tableId, {
+  const response2 = await handleRequest("READ" /* READ */, tableId, {
     id,
     datasource: datasource2,
     includeSqlRelationships: 1 /* INCLUDE */
   });
   const table = tables[tableName];
-  const row = response[0];
+  const row = response2[0];
   for (let [fieldName, field] of Object.entries(table.schema)) {
     if (field.type !== "link" /* LINK */ || !row[fieldName] || row[fieldName].length === 0) {
       continue;
@@ -29956,7 +29954,7 @@ async function destroy9(ctx) {
   const appId = ctx.appId;
   const inputs = ctx.request.body;
   const tableId = getTableId(ctx);
-  let response, row;
+  let response2, row;
   if (inputs.rows) {
     let { rows: rows2 } = await quotas_exports4.addQuery(
       () => pickApi(tableId).bulkDestroy(ctx),
@@ -29965,7 +29963,7 @@ async function destroy9(ctx) {
       }
     );
     await quotas_exports4.removeRows(rows2.length);
-    response = rows2;
+    response2 = rows2;
     for (let row2 of rows2) {
       ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:delete`, appId, row2);
     }
@@ -29974,13 +29972,13 @@ async function destroy9(ctx) {
       datasourceId: tableId
     });
     await quotas_exports4.removeRow();
-    response = resp.response;
+    response2 = resp.response;
     row = resp.row;
     ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:delete`, appId, row);
   }
   ctx.status = 200;
   ctx.row = row || {};
-  ctx.body = response;
+  ctx.body = response2;
 }
 async function search5(ctx) {
   const tableId = getTableId(ctx);
@@ -30520,8 +30518,8 @@ function getAuthConfig(ctx) {
   return authConfigCtx;
 }
 async function execute2(ctx, opts = { rowsOnly: false, isAutomation: false }) {
-  const db = context_exports.getAppDB();
-  const query = await db.get(ctx.params.queryId);
+  const db2 = context_exports.getAppDB();
+  const query = await db2.get(ctx.params.queryId);
   const { datasource: datasource2, envVars } = await sdk_default.datasources.getWithEnvVars(
     query.datasourceId
   );
@@ -30643,9 +30641,9 @@ async function run8({ inputs, appId, emitter: emitter2 }) {
   });
   try {
     await executeV2(ctx, { isAutomation: true });
-    const { data, ...rest2 } = ctx.body;
+    const { data: data2, ...rest2 } = ctx.body;
     return {
-      response: data,
+      response: data2,
       info: rest2,
       success: true
     };
@@ -30760,8 +30758,8 @@ async function run9({ inputs }) {
     if (request2.body) {
       JSON.parse(request2.body);
     }
-    const response = await (0, import_node_fetch12.default)(url, request2);
-    const { status: status2, message } = await getFetchResponse(response);
+    const response2 = await (0, import_node_fetch12.default)(url, request2);
+    const { status: status2, message } = await getFetchResponse(response2);
     return {
       httpStatus: status2,
       response: message,
@@ -30892,9 +30890,9 @@ async function run11({ inputs }) {
       success: false
     };
   }
-  let response;
+  let response2;
   try {
-    response = await (0, import_node_fetch13.default)(url, {
+    response2 = await (0, import_node_fetch13.default)(url, {
       method: "post",
       body: JSON.stringify({
         username,
@@ -30912,7 +30910,7 @@ async function run11({ inputs }) {
       success: false
     };
   }
-  const { status: status2, message } = await getFetchResponse(response);
+  const { status: status2, message } = await getFetchResponse(response2);
   return {
     httpStatus: status2,
     success: status2 === 200 || status2 === 204,
@@ -30974,9 +30972,9 @@ async function run12({ inputs }) {
       success: false
     };
   }
-  let response;
+  let response2;
   try {
-    response = await (0, import_node_fetch14.default)(url, {
+    response2 = await (0, import_node_fetch14.default)(url, {
       method: "post",
       body: JSON.stringify({
         text
@@ -30992,7 +30990,7 @@ async function run12({ inputs }) {
       success: false
     };
   }
-  const { status: status2, message } = await getFetchResponse(response);
+  const { status: status2, message } = await getFetchResponse(response2);
   return {
     httpStatus: status2,
     response: message,
@@ -31080,9 +31078,9 @@ async function run13({ inputs }) {
       success: false
     };
   }
-  let response;
+  let response2;
   try {
-    response = await (0, import_node_fetch15.default)(url, {
+    response2 = await (0, import_node_fetch15.default)(url, {
       method: "post",
       body: JSON.stringify({
         platform: "budibase",
@@ -31104,7 +31102,7 @@ async function run13({ inputs }) {
       success: false
     };
   }
-  const { status: status2, message } = await getFetchResponse(response);
+  const { status: status2, message } = await getFetchResponse(response2);
   return {
     success: status2 === 200,
     httpStatus: status2,
@@ -31198,9 +31196,9 @@ async function run14({ inputs }) {
       success: false
     };
   }
-  let response;
+  let response2;
   try {
-    response = await (0, import_node_fetch16.default)(url, {
+    response2 = await (0, import_node_fetch16.default)(url, {
       method: "post",
       body: JSON.stringify({
         value1,
@@ -31221,7 +31219,7 @@ async function run14({ inputs }) {
       success: false
     };
   }
-  const { status: status2, message } = await getFetchResponse(response);
+  const { status: status2, message } = await getFetchResponse(response2);
   return {
     httpStatus: status2,
     success: status2 === 200,
@@ -31868,10 +31866,10 @@ var Orchestrator = class {
   }
   async getMetadata() {
     const metadataId = generateAutomationMetadataID(this._automation._id);
-    const db = context_exports.getAppDB();
+    const db2 = context_exports.getAppDB();
     let metadata;
     try {
-      metadata = await db.get(metadataId);
+      metadata = await db2.get(metadataId);
     } catch (err) {
       metadata = {
         _id: metadataId,
@@ -31926,13 +31924,13 @@ var Orchestrator = class {
     } else {
       metadata.errorCount = 0;
     }
-    const db = context_exports.getAppDB();
+    const db2 = context_exports.getAppDB();
     try {
-      await db.put(metadata);
+      await db2.put(metadata);
     } catch (err) {
       logging_exports.logAlertWithInfo(
         "Failed to write automation metadata",
-        db.name,
+        db2.name,
         automation._id,
         err
       );
@@ -32184,8 +32182,8 @@ function execute3(job, callback) {
     await context_exports.doInEnvironmentContext(envVars, async () => {
       const automationOrchestrator = new Orchestrator(job);
       try {
-        const response = await automationOrchestrator.execute();
-        callback(null, response);
+        const response2 = await automationOrchestrator.execute();
+        callback(null, response2);
       } catch (err) {
         callback(err);
       }