@budibase/pro 3.2.20 → 3.2.22

package/dist/index.js

@@ -5744,7 +5744,7 @@ var src_exports = {};
 __export(src_exports, {
   Method: () => Method,
   ai: () => ai_exports2,
-  api: () => api_exports2,
+  api: () => api_exports,
   auditLogs: () => auditLogs_exports3,
   automations: () => automations_exports,
   backups: () => backups_default,
@@ -8775,65 +8775,12 @@ var removeCustomAIConfigs = async (count) => {
 var users_exports = {};
 __export(users_exports, {
   addAppBuilder: () => addAppBuilder2,
-  createActivity: () => createActivity2,
   db: () => db3,
   removeAppBuilder: () => removeAppBuilder2
 });
 
-// src/sdk/api/api.ts
-var import_backend_core25 = require("@budibase/backend-core");
-var api2 = new api_default(import_backend_core25.env.ACCOUNT_PORTAL_URL);
-var createActivity = async (userId, data) => {
-  const response = await send(
-    (options) => api2.post(`/api/users/${userId}/activity`, options),
-    {
-      body: data
-    }
-  );
-  if (!response) {
-    return;
-  }
-  if (response.status !== 201) {
-    const text = await response.text();
-    const message = `Error creating account user activity: ${text}`;
-    import_backend_core25.logging.logAlert(message);
-    throw new Error(message);
-  }
-  return response.json();
-};
-var send = async (requestFn, baseOptions) => {
-  const headers = await authorizationHeaders();
-  const options = {
-    ...baseOptions,
-    headers: {
-      ...baseOptions.headers,
-      ...headers
-    }
-  };
-  return requestFn(options);
-};
-var authorizationHeaders = async () => {
-  if (import_backend_core25.env.SELF_HOSTED) {
-    const licenseInfo = await licenseInfo_exports.get();
-    if (licenseInfo.licenseKey) {
-      const licenseKey = licenseInfo.licenseKey;
-      return {
-        [import_backend_core25.constants.Header.LICENSE_KEY]: licenseKey
-      };
-    } else {
-      return {};
-    }
-  } else {
-    const tenantId = import_backend_core25.tenancy.getTenantId();
-    return {
-      [import_backend_core25.constants.Header.API_KEY]: import_backend_core25.env.ACCOUNT_PORTAL_API_KEY,
-      [import_backend_core25.constants.Header.TENANT_ID]: tenantId
-    };
-  }
-};
-
 // src/sdk/users/users.ts
-var import_backend_core28 = require("@budibase/backend-core");
+var import_backend_core27 = require("@budibase/backend-core");
 
 // src/sdk/groups/index.ts
 var groups_exports2 = {};
@@ -8856,11 +8803,11 @@ __export(groups_exports2, {
 });
 
 // src/sdk/groups/groups.ts
-var import_backend_core27 = require("@budibase/backend-core");
+var import_backend_core26 = require("@budibase/backend-core");
 
 // src/api/errors.ts
-var import_backend_core26 = require("@budibase/backend-core");
-var GroupNameUnavailableError = class extends import_backend_core26.HTTPError {
+var import_backend_core25 = require("@budibase/backend-core");
+var GroupNameUnavailableError = class extends import_backend_core25.HTTPError {
   constructor(groupName) {
     super(`Group name "${groupName}" is unavailable`, 409);
   }
@@ -8872,7 +8819,7 @@ async function findHighestRole(groups, appId) {
     let potentialRoles = [];
     for (let group of groups) {
       if (group.roles) {
-        const role = group.roles[import_backend_core27.db.getProdAppID(appId)];
+        const role = group.roles[import_backend_core26.db.getProdAppID(appId)];
         if (role) {
           potentialRoles.push(role);
         }
@@ -8881,7 +8828,7 @@ async function findHighestRole(groups, appId) {
     const allRoleNumbersArr = await Promise.all(
       potentialRoles.map(async (roleId) => {
         return {
-          [roleId]: await import_backend_core27.roles.roleToNumber(roleId)
+          [roleId]: await import_backend_core26.roles.roleToNumber(roleId)
         };
       })
     );
@@ -8900,7 +8847,7 @@ async function findHighestRole(groups, appId) {
     }
     return highestGroupRole;
   } catch (error) {
-    import_backend_core27.logging.logAlert(
+    import_backend_core26.logging.logAlert(
       `Error finding higest role for ${groups.length} on app ${appId}`,
       error
     );
@@ -8922,7 +8869,7 @@ async function getGroupBuilderAppIds(user, opts) {
     return [];
   }
   const groups = await groupList(user.userGroups, opts?.groups);
-  const prodAppId = opts?.appId ? import_backend_core27.db.getProdAppID(opts?.appId) : null;
+  const prodAppId = opts?.appId ? import_backend_core26.db.getProdAppID(opts?.appId) : null;
   let appIds = [];
   for (let group of groups) {
     const groupApps = group.builder?.apps;
@@ -8939,7 +8886,7 @@ async function getGroupRoleId(user, appId, opts) {
     return null;
   }
   let groups = await groupList(user.userGroups, opts?.groups);
-  const prodAppId = import_backend_core27.db.getProdAppID(appId);
+  const prodAppId = import_backend_core26.db.getProdAppID(appId);
   if (user.roles?.[prodAppId]) {
     return user.roles[prodAppId];
   }
@@ -8965,7 +8912,7 @@ async function enrichUserRolesFromGroups(user) {
   }
   allGroupAppIds = [...new Set(allGroupAppIds)];
   for (let appId of allGroupAppIds) {
-    await import_backend_core27.context.doInAppContext(appId, async () => {
+    await import_backend_core26.context.doInAppContext(appId, async () => {
       if (user.roles[appId]) {
         return;
       }
@@ -9004,11 +8951,11 @@ async function getCreatorsCountInGroup(group) {
   if (!usersInGroup.length) {
     return 0;
   }
-  const globalDb = import_backend_core27.tenancy.getGlobalDB();
+  const globalDb = import_backend_core26.tenancy.getGlobalDB();
   const users7 = await Promise.all(
     usersInGroup.map((user) => globalDb.get(user._id))
   );
-  const creatorsInGroup = await Promise.all(users7.map(import_backend_core27.userUtils.isCreator));
+  const creatorsInGroup = await Promise.all(users7.map(import_backend_core26.userUtils.isCreator));
   return creatorsInGroup.filter((x) => !!x).length;
 }
 async function save3(group) {
@@ -9019,13 +8966,13 @@ async function save3(group) {
   if (!group._id) {
     group._id = groups_exports.generateUserGroupID();
     await guardNameAvailability(group.name);
-    eventPromises.push(import_backend_core27.events.group.created(group));
+    eventPromises.push(import_backend_core26.events.group.created(group));
   } else {
     const oldGroup = await groups_exports.get(group._id);
     if (oldGroup.name !== group.name) {
       await guardNameAvailability(group.name);
     }
-    eventPromises.push(import_backend_core27.events.group.updated(group));
+    eventPromises.push(import_backend_core26.events.group.updated(group));
     if (JSON.stringify(oldGroup.roles) !== JSON.stringify(group.roles)) {
       const usersCountInGroup = oldGroup.users?.length || 0;
       let creatorsCountBeforeSave = 0;
@@ -9033,13 +8980,13 @@ async function save3(group) {
         creatorsCountBeforeSave = await getCreatorsCountInGroup(oldGroup);
       }
       if (Object.values(group.roles).includes(
-        import_backend_core27.roles.BUILTIN_ROLE_IDS.ADMIN
+        import_backend_core26.roles.BUILTIN_ROLE_IDS.ADMIN
       )) {
         newCreators = usersCountInGroup - creatorsCountBeforeSave;
       } else {
         newCreators = -usersCountInGroup;
       }
-      eventPromises.push(import_backend_core27.events.group.permissionsEdited(group));
+      eventPromises.push(import_backend_core26.events.group.permissionsEdited(group));
     }
   }
   await Promise.all(eventPromises);
@@ -9070,12 +9017,12 @@ async function remove(groupId, revision) {
     throw new Error("Group not found");
   }
   const isAdminGroup = Object.values(group.roles || {}).includes(
-    import_backend_core27.roles.BUILTIN_ROLE_IDS.ADMIN
+    import_backend_core26.roles.BUILTIN_ROLE_IDS.ADMIN
   );
   let recalculateCreatorsQuotasFn = () => {
   };
   if (isAdminGroup) {
-    const globalDb = import_backend_core27.tenancy.getGlobalDB();
+    const globalDb = import_backend_core26.tenancy.getGlobalDB();
     const usersInGroup = await groups_exports.getGroupUsers(groupId);
     const users7 = await Promise.all(
       usersInGroup.map((user) => {
@@ -9087,7 +9034,7 @@ async function remove(groupId, revision) {
       userGroups: user.userGroups.filter((grp) => grp !== groupId)
     }));
     const creatorsEval = await Promise.all(
-      usersWithoutGroup.map(import_backend_core27.userUtils.isCreator)
+      usersWithoutGroup.map(import_backend_core26.userUtils.isCreator)
     );
     const creatorsCount = creatorsEval.filter((x) => !!x).length;
     const creatorsToRemove = usersInGroup.length - creatorsCount;
@@ -9096,14 +9043,14 @@ async function remove(groupId, revision) {
     }
   }
   let resp = await groups_exports.destroy(groupId, revision);
-  await import_backend_core27.events.group.deleted(group);
+  await import_backend_core26.events.group.deleted(group);
   await removeGroup();
   await recalculateCreatorsQuotasFn();
   return resp;
 }
 async function addUsers2(groupId, userIds) {
   const group = await groups_exports.get(groupId);
-  const users7 = await import_backend_core27.users.bulkGetGlobalUsersById(userIds);
+  const users7 = await import_backend_core26.users.bulkGetGlobalUsersById(userIds);
   let toUpdate = [];
   for (let user of users7) {
     if (!user.userGroups) {
@@ -9120,12 +9067,12 @@ async function addUsers2(groupId, userIds) {
     ...user,
     userGroups: [...user?.userGroups || [], groupId]
   }));
-  await import_backend_core27.users.bulkUpdateGlobalUsers(updatedUsers);
+  await import_backend_core26.users.bulkUpdateGlobalUsers(updatedUsers);
   const isAdminGroup = Object.values(group.roles || {}).includes(
-    import_backend_core27.roles.BUILTIN_ROLE_IDS.ADMIN
+    import_backend_core26.roles.BUILTIN_ROLE_IDS.ADMIN
   );
   if (isAdminGroup) {
-    const creatorsEval = await Promise.all(toUpdate.map(import_backend_core27.userUtils.isCreator));
+    const creatorsEval = await Promise.all(toUpdate.map(import_backend_core26.userUtils.isCreator));
     const creatorsCount = creatorsEval.filter((x) => !!x).length;
     const creatorsToAdd = toUpdate.length - creatorsCount;
     if (creatorsToAdd) {
@@ -9134,15 +9081,15 @@ async function addUsers2(groupId, userIds) {
   }
   let promises = [];
   for (let userId of userIds) {
-    promises.push(import_backend_core27.cache.user.invalidateUser(userId));
+    promises.push(import_backend_core26.cache.user.invalidateUser(userId));
   }
   await Promise.all(promises);
-  await import_backend_core27.events.group.usersAdded(updatedUsers.length, group);
+  await import_backend_core26.events.group.usersAdded(updatedUsers.length, group);
   return updatedUsers;
 }
 async function removeUsers2(groupId, userIds) {
   const group = await groups_exports.get(groupId);
-  const users7 = await import_backend_core27.users.bulkGetGlobalUsersById(userIds);
+  const users7 = await import_backend_core26.users.bulkGetGlobalUsersById(userIds);
   let toUpdate = [];
   for (let user of users7) {
     if (!user.userGroups || !user.userGroups.includes(groupId)) {
@@ -9152,12 +9099,12 @@ async function removeUsers2(groupId, userIds) {
     user.userGroups.splice(idx, 1);
     toUpdate.push(user);
   }
-  await import_backend_core27.users.bulkUpdateGlobalUsers(toUpdate);
+  await import_backend_core26.users.bulkUpdateGlobalUsers(toUpdate);
   const isAdminGroup = Object.values(group.roles || {}).includes(
-    import_backend_core27.roles.BUILTIN_ROLE_IDS.ADMIN
+    import_backend_core26.roles.BUILTIN_ROLE_IDS.ADMIN
   );
   if (isAdminGroup) {
-    const creatorsEval = await Promise.all(toUpdate.map(import_backend_core27.userUtils.isCreator));
+    const creatorsEval = await Promise.all(toUpdate.map(import_backend_core26.userUtils.isCreator));
     const creatorsCount = creatorsEval.filter((x) => !!x).length;
     const creatorsToRemove = toUpdate.length - creatorsCount;
     if (creatorsToRemove) {
@@ -9166,11 +9113,11 @@ async function removeUsers2(groupId, userIds) {
   }
   let promises = [];
   for (let userId of userIds) {
-    promises.push(import_backend_core27.cache.user.invalidateUser(userId));
+    promises.push(import_backend_core26.cache.user.invalidateUser(userId));
   }
   await Promise.all(promises);
   if (toUpdate.length) {
-    await import_backend_core27.events.group.usersDeleted(toUpdate.length, group);
+    await import_backend_core26.events.group.usersDeleted(toUpdate.length, group);
   }
   return toUpdate;
 }
@@ -9207,7 +9154,7 @@ async function addAppBuilder(groupId, appId) {
   if (!await isAppBuildersEnabled()) {
     throw new Error("Feature not enabled, please check license");
   }
-  const prodAppId = import_backend_core27.db.getProdAppID(appId);
+  const prodAppId = import_backend_core26.db.getProdAppID(appId);
   const group = await get4(groupId);
   group.builder ??= { apps: [] };
   if (!group.builder.apps.includes(appId)) {
@@ -9219,7 +9166,7 @@ async function removeAppBuilder(groupId, appId) {
   if (!await isAppBuildersEnabled()) {
     throw new Error("Feature not enabled, please check license");
   }
-  const prodAppId = import_backend_core27.db.getProdAppID(appId);
+  const prodAppId = import_backend_core26.db.getProdAppID(appId);
   const group = await get4(groupId);
   if (group.builder?.apps.includes(appId)) {
     group.builder.apps = group.builder.apps.filter((id) => id !== prodAppId);
@@ -9228,10 +9175,10 @@ async function removeAppBuilder(groupId, appId) {
 }
 async function adjustGroupCreatorsQuotas() {
   if (!await isUserGroupsEnabled()) {
-    const globalDb = import_backend_core27.tenancy.getGlobalDB();
+    const globalDb = import_backend_core26.tenancy.getGlobalDB();
     const groups = await fetch3() || [];
     const adminGroups = groups.filter(
-      (group) => Object.values(group?.roles || {}).includes(import_backend_core27.roles.BUILTIN_ROLE_IDS.ADMIN)
+      (group) => Object.values(group?.roles || {}).includes(import_backend_core26.roles.BUILTIN_ROLE_IDS.ADMIN)
     );
     for (let group of adminGroups) {
       const usersInGroup = await groups_exports.getGroupUsers(group._id);
@@ -9245,7 +9192,7 @@ async function adjustGroupCreatorsQuotas() {
         userGroups: user.userGroups.filter((grp) => grp !== group._id)
       }));
       const creatorsEval = await Promise.all(
-        usersWithoutGroup.map(import_backend_core27.userUtils.isCreator)
+        usersWithoutGroup.map(import_backend_core26.userUtils.isCreator)
       );
       const creatorsCount = creatorsEval.filter((x) => !!x).length;
       const creatorsToRemove = usersInGroup.length - creatorsCount;
@@ -9258,25 +9205,19 @@ async function adjustGroupCreatorsQuotas() {
 }
 
 // src/sdk/users/users.ts
-import_backend_core28.users.UserDB.init(quotas_exports5, groups_exports2, features_exports2);
-var db3 = import_backend_core28.users.UserDB;
-var createActivity2 = async (userId) => {
-  const data = {
-    timestamp: Date.now()
-  };
-  return createActivity(userId, data);
-};
+import_backend_core27.users.UserDB.init(quotas_exports5, groups_exports2, features_exports2);
+var db3 = import_backend_core27.users.UserDB;
 async function addAppBuilder2(user, appId) {
   if (!await isAppBuildersEnabled()) {
     throw new Error("Feature not enabled, please check license");
   }
-  await import_backend_core28.users.addAppBuilder(user, appId);
+  await import_backend_core27.users.addAppBuilder(user, appId);
 }
 async function removeAppBuilder2(user, appId) {
   if (!await isAppBuildersEnabled()) {
     throw new Error("Feature not enabled, please check license");
   }
-  await import_backend_core28.users.removeAppBuilder(user, appId);
+  await import_backend_core27.users.removeAppBuilder(user, appId);
 }
 
 // src/sdk/automations/index.ts
@@ -9293,14 +9234,14 @@ __export(logging_exports, {
   storeLog: () => storeLog
 });
 var import_types25 = require("@budibase/types");
-var import_backend_core31 = require("@budibase/backend-core");
+var import_backend_core30 = require("@budibase/backend-core");
 
 // src/db/automations.ts
 var import_types24 = require("@budibase/types");
-var import_backend_core30 = require("@budibase/backend-core");
+var import_backend_core29 = require("@budibase/backend-core");
 
 // src/utilities/delay.ts
-var import_backend_core29 = require("@budibase/backend-core");
+var import_backend_core28 = require("@budibase/backend-core");
 async function backOff(fn, errMsg) {
   let error;
   let attempts = 5, success = false, response, first = true;
@@ -9318,7 +9259,7 @@ async function backOff(fn, errMsg) {
     }
   }
   if (!success) {
-    import_backend_core29.logging.logWarn(`Failed to backoff: ${errMsg}`, error);
+    import_backend_core28.logging.logWarn(`Failed to backoff: ${errMsg}`, error);
   }
   return response;
 }
@@ -9331,7 +9272,7 @@ var {
   AutomationViewMode: AutomationViewMode2,
   ViewName: ViewName3,
   getQueryIndex
-} = import_backend_core30.db;
+} = import_backend_core29.db;
 var EARLIEST_DATE = (/* @__PURE__ */ new Date(0)).toISOString();
 var EXPIRED_LIMIT = 100;
 var oldestLogDate = async () => {
@@ -9384,9 +9325,9 @@ function generateAutomationLogID(isoDate, status2, automationId) {
   return `${DocumentType4.AUTOMATION_LOG}${SEPARATOR4}${isoDate}${SEPARATOR4}${automationId}${SEPARATOR4}${status2}`;
 }
 async function getAllLogs(startDate, endDate, opts = { docs: true }) {
-  let db4 = import_backend_core30.context.getProdAppDB();
+  let db4 = import_backend_core29.context.getProdAppDB();
   if (!await db4.exists()) {
-    db4 = import_backend_core30.context.getDevAppDB();
+    db4 = import_backend_core29.context.getDevAppDB();
   }
   const optional = { status: opts.status };
   const limit = opts?.limit ? opts.limit : opts?.paginate ? GENERIC_PAGE_SIZE + 1 : void 0;
@@ -9404,9 +9345,9 @@ async function getAllLogs(startDate, endDate, opts = { docs: true }) {
   });
 }
 async function getLogsByView(startDate, endDate, viewParams = {}) {
-  let db4 = import_backend_core30.context.getProdAppDB();
+  let db4 = import_backend_core29.context.getProdAppDB();
   if (!await db4.exists()) {
-    db4 = import_backend_core30.context.getDevAppDB();
+    db4 = import_backend_core29.context.getDevAppDB();
   }
   let response;
   try {
@@ -9436,7 +9377,7 @@ async function getLogsByView(startDate, endDate, viewParams = {}) {
   return pagination(response, { paginate: true, pageSize: GENERIC_PAGE_SIZE });
 }
 async function writeLog(automation, results) {
-  const db4 = import_backend_core30.context.getProdAppDB();
+  const db4 = import_backend_core29.context.getProdAppDB();
   const automationId = automation._id;
   const name2 = automation.name;
   const status2 = getStatus(results);
@@ -9455,12 +9396,12 @@ async function writeLog(automation, results) {
   return id;
 }
 async function updateAppMetadataWithErrors(logIds, { clearing } = { clearing: false }) {
-  const db4 = import_backend_core30.context.getProdAppDB();
+  const db4 = import_backend_core29.context.getProdAppDB();
   await backOff(async () => {
-    const metadata2 = await db4.get(import_backend_core30.db.DocumentType.APP_METADATA);
+    const metadata2 = await db4.get(import_backend_core29.db.DocumentType.APP_METADATA);
     for (let logId of logIds) {
-      const parts = logId.split(import_backend_core30.db.SEPARATOR);
-      const autoId = `${parts[parts.length - 3]}${import_backend_core30.db.SEPARATOR}${parts[parts.length - 2]}`;
+      const parts = logId.split(import_backend_core29.db.SEPARATOR);
+      const autoId = `${parts[parts.length - 3]}${import_backend_core29.db.SEPARATOR}${parts[parts.length - 2]}`;
       let errors = {};
       if (metadata2.automationErrors) {
         errors = metadata2.automationErrors;
@@ -9480,7 +9421,7 @@ async function updateAppMetadataWithErrors(logIds, { clearing } = { clearing: fa
       metadata2.automationErrors = errors;
     }
     await db4.put(metadata2);
-    await import_backend_core30.cache.app.invalidateAppMetadata(metadata2.appId, metadata2);
+    await import_backend_core29.cache.app.invalidateAppMetadata(metadata2.appId, metadata2);
   }, "Failed to update app metadata with automation log error");
 }
 async function getExpiredLogs() {
@@ -9496,7 +9437,7 @@ async function getExpiredLogs() {
   }
 }
 async function clearOldHistory() {
-  const db4 = import_backend_core30.context.getProdAppDB();
+  const db4 = import_backend_core29.context.getProdAppDB();
   try {
     const expired = await getExpiredLogs();
     if (!expired.data || expired.data.length === 0) {
@@ -9508,7 +9449,7 @@ async function clearOldHistory() {
       _deleted: true
     }));
     const errorLogIds = expired.data.filter((doc2) => {
-      const parts = doc2.id.split(import_backend_core30.db.SEPARATOR);
+      const parts = doc2.id.split(import_backend_core29.db.SEPARATOR);
       const status2 = parts[parts.length - 1];
       return status2 === import_types24.AutomationStatus.ERROR;
     }).map((doc2) => doc2.id);
@@ -9517,7 +9458,7 @@ async function clearOldHistory() {
       await updateAppMetadataWithErrors(errorLogIds, { clearing: true });
     }
   } catch (err) {
-    import_backend_core30.logging.logAlert(
+    import_backend_core29.logging.logAlert(
       `Failed to cleanup automation log history - Database "${db4.name}"`,
       err
     );
@@ -9559,7 +9500,7 @@ async function logSearch(options) {
   );
 }
 async function storeLog(automation, results) {
-  if (!import_backend_core31.db.isProdAppID(import_backend_core31.context.getAppId())) {
+  if (!import_backend_core30.db.isProdAppID(import_backend_core30.context.getAppId())) {
     return;
   }
   const status2 = getStatus(results);
@@ -9578,7 +9519,7 @@ __export(plugins_exports, {
   storePlugin: () => storePlugin
 });
 var import_types26 = require("@budibase/types");
-var import_backend_core32 = require("@budibase/backend-core");
+var import_backend_core31 = require("@budibase/backend-core");
 
 // src/utilities/fileSystem.ts
 var import_fs3 = __toESM(require("fs"));
@@ -9589,11 +9530,11 @@ function loadJSFile(directory2, name2) {
 
 // src/sdk/plugins/index.ts
 async function storePlugin(metadata, directory, source) {
-  const db = import_backend_core32.tenancy.getGlobalDB();
+  const db = import_backend_core31.tenancy.getGlobalDB();
   const version = metadata.package.version, name = metadata.package.name, description = metadata.package.description, hash = metadata.schema.hash;
-  const bucketPath = import_backend_core32.objectStore.getPluginS3Dir(name);
-  const files = await import_backend_core32.objectStore.uploadDirectory(
-    import_backend_core32.objectStore.ObjectStoreBuckets.PLUGINS,
+  const bucketPath = import_backend_core31.objectStore.getPluginS3Dir(name);
+  const files = await import_backend_core31.objectStore.uploadDirectory(
+    import_backend_core31.objectStore.ObjectStoreBuckets.PLUGINS,
     directory,
     bucketPath
   );
@@ -9612,7 +9553,7 @@ async function storePlugin(metadata, directory, source) {
     }
   }
   const iconFileName = iconFile ? iconFile.name : null;
-  const pluginId = import_backend_core32.db.generatePluginID(name);
+  const pluginId = import_backend_core31.db.generatePluginID(name);
   let rev;
   try {
     const existing = await db.get(pluginId);
@@ -9640,7 +9581,7 @@ async function storePlugin(metadata, directory, source) {
   }
   const write = async () => {
     const response = await db.put(doc);
-    await import_backend_core32.events.plugin.imported(doc);
+    await import_backend_core31.events.plugin.imported(doc);
     return {
       ...doc,
       _rev: response.rev
@@ -9653,16 +9594,16 @@ async function storePlugin(metadata, directory, source) {
   }
 }
 async function deletePlugin(pluginId2) {
-  const db4 = import_backend_core32.tenancy.getGlobalDB();
+  const db4 = import_backend_core31.tenancy.getGlobalDB();
   try {
     const plugin = await db4.get(pluginId2);
-    const bucketPath2 = import_backend_core32.objectStore.getPluginS3Dir(plugin.name);
-    await import_backend_core32.objectStore.deleteFolder(
-      import_backend_core32.objectStore.ObjectStoreBuckets.PLUGINS,
+    const bucketPath2 = import_backend_core31.objectStore.getPluginS3Dir(plugin.name);
+    await import_backend_core31.objectStore.deleteFolder(
+      import_backend_core31.objectStore.ObjectStoreBuckets.PLUGINS,
       bucketPath2
     );
     await db4.remove(pluginId2, plugin._rev);
-    await import_backend_core32.events.plugin.deleted(plugin);
+    await import_backend_core31.events.plugin.deleted(plugin);
     await removePlugin();
   } catch (err) {
     const errMsg = err?.message ? err?.message : err;
@@ -9670,14 +9611,14 @@ async function deletePlugin(pluginId2) {
   }
 }
 async function checkPluginQuotas() {
-  const db4 = import_backend_core32.tenancy.getGlobalDB();
+  const db4 = import_backend_core31.tenancy.getGlobalDB();
   try {
-    const allPlugins = await db4.allDocs(import_backend_core32.db.getPluginParams());
+    const allPlugins = await db4.allDocs(import_backend_core31.db.getPluginParams());
     const pluginCount = allPlugins.rows.length;
     console.log(`Syncing plugin count: ${pluginCount}`);
     await updatePluginCount(pluginCount);
   } catch (err) {
-    import_backend_core32.logging.logAlert("Unable to retrieve plugins for quota check", err);
+    import_backend_core31.logging.logAlert("Unable to retrieve plugins for quota check", err);
   }
 }
 
@@ -9694,9 +9635,9 @@ __export(environmentVariables_exports2, {
 
 // src/sdk/environmentVariables/environmentVariables.ts
 var import_types27 = require("@budibase/types");
-var import_backend_core33 = require("@budibase/backend-core");
+var import_backend_core32 = require("@budibase/backend-core");
 function isEncryptionKeyAvailable() {
-  return !!import_backend_core33.env.ENCRYPTION_KEY;
+  return !!import_backend_core32.env.ENCRYPTION_KEY;
 }
 async function fetch4() {
   const doc2 = await environmentVariables_exports.get();
@@ -9764,10 +9705,10 @@ __export(auditLogs_exports3, {
 var import_types30 = require("@budibase/types");
 
 // src/db/auditLogs.ts
-var import_backend_core34 = require("@budibase/backend-core");
+var import_backend_core33 = require("@budibase/backend-core");
 var import_types28 = require("@budibase/types");
 var MemoryStream = require("memorystream");
-var builder = new import_backend_core34.sql.Sql(import_types28.SqlClient.SQL_LITE);
+var builder = new import_backend_core33.sql.Sql(import_types28.SqlClient.SQL_LITE);
 async function getAuditLogSqlQuery(filters, bookmark, limit) {
   const request = {
     operation: import_types28.Operation.READ,
@@ -9795,7 +9736,7 @@ async function getAuditLogSqlQuery(filters, bookmark, limit) {
   return { sql: query.sql, bindings: query.bindings };
 }
 function generateAuditLogID(timestamp) {
-  return `${import_backend_core34.DocumentType.AUDIT_LOG}${import_backend_core34.SEPARATOR}${timestamp}${import_backend_core34.SEPARATOR}${import_backend_core34.utils.newid()}`;
+  return `${import_backend_core33.DocumentType.AUDIT_LOG}${import_backend_core33.SEPARATOR}${timestamp}${import_backend_core33.SEPARATOR}${import_backend_core33.utils.newid()}`;
 }
 async function save4(doc2) {
   if (!doc2._id) {
@@ -9805,21 +9746,21 @@ async function save4(doc2) {
     doc2.type = import_types28.AUDIT_LOG_TYPE;
   }
   try {
-    const db4 = import_backend_core34.context.getAuditLogsDB();
+    const db4 = import_backend_core33.context.getAuditLogsDB();
     const response = await db4.put(doc2);
     return {
       ...doc2,
       _rev: response.rev
     };
   } catch (err) {
-    import_backend_core34.logging.logAlert("Failed to write audit log", err);
+    import_backend_core33.logging.logAlert("Failed to write audit log", err);
   }
 }
 async function searchSQL(filters, bookmark, opts) {
   if (!bookmark) {
     bookmark = 1;
   }
-  const db4 = import_backend_core34.context.getAuditLogsDB();
+  const db4 = import_backend_core33.context.getAuditLogsDB();
   try {
     const limit = GENERIC_PAGE_SIZE + 1;
     const mainQuery = await getAuditLogSqlQuery(filters, bookmark, limit);
@@ -9851,9 +9792,9 @@ async function searchSQL(filters, bookmark, opts) {
   }
 }
 async function migrate() {
-  const db4 = import_backend_core34.context.getAuditLogsDB();
+  const db4 = import_backend_core33.context.getAuditLogsDB();
   const auditLogs = (await db4.allDocs(
-    import_backend_core34.db.getDocParams(import_backend_core34.DocumentType.AUDIT_LOG, null, {
+    import_backend_core33.db.getDocParams(import_backend_core33.DocumentType.AUDIT_LOG, null, {
       include_docs: true
     })
   )).rows.map((row) => row.doc);
@@ -9864,12 +9805,12 @@ async function migrate() {
   await db4.bulkDocs(updatedLogs);
 }
 function dump(params) {
-  const db4 = import_backend_core34.context.getAuditLogsDB();
+  const db4 = import_backend_core33.context.getAuditLogsDB();
   const stream = new MemoryStream();
   const promise = db4.dump(stream, {
     filter: (doc2) => {
       const auditLog = doc2;
-      if (!auditLog._id?.startsWith(import_backend_core34.DocumentType.AUDIT_LOG)) {
+      if (!auditLog._id?.startsWith(import_backend_core33.DocumentType.AUDIT_LOG)) {
         return false;
       }
       let allMatched = true;
@@ -9910,14 +9851,14 @@ function dump(params) {
 }
 
 // src/sdk/auditLogs/auditLogs.ts
-var import_backend_core36 = require("@budibase/backend-core");
+var import_backend_core35 = require("@budibase/backend-core");
 
 // src/sdk/auditLogs/utils.ts
 var import_types29 = require("@budibase/types");
 var import_string_templates = require("@budibase/string-templates");
-var import_backend_core35 = require("@budibase/backend-core");
-var MIN_DATE = import_backend_core35.constants.MIN_VALID_DATE.toISOString();
-var MAX_DATE2 = import_backend_core35.constants.MAX_VALID_DATE.toISOString();
+var import_backend_core34 = require("@budibase/backend-core");
+var MIN_DATE = import_backend_core34.constants.MIN_VALID_DATE.toISOString();
+var MAX_DATE2 = import_backend_core34.constants.MAX_VALID_DATE.toISOString();
 function fillDates(params) {
   if (params.startDate || params.endDate) {
     params.startDate = params.startDate || MIN_DATE;
@@ -9927,7 +9868,7 @@ function fillDates(params) {
 }
 async function getSearchFilters(params) {
   if (Array.isArray(params.appIds)) {
-    params.appIds = params.appIds.map((appId) => import_backend_core35.db.getProdAppID(appId));
+    params.appIds = params.appIds.map((appId) => import_backend_core34.db.getProdAppID(appId));
   }
   const filter2 = {};
   function addStringParams(key, params2) {
@@ -10005,7 +9946,7 @@ function getEventFriendlyName(event, metadata2) {
 
 // src/sdk/auditLogs/auditLogs.ts
 async function write2(event, metadata2, opts) {
-  if (!await isAuditLogsEnabled() || !import_backend_core36.utils.isAudited(event)) {
+  if (!await isAuditLogsEnabled() || !import_backend_core35.utils.isAudited(event)) {
     return;
   }
   const friendly = getEventFriendlyName(event, metadata2);
@@ -10026,18 +9967,18 @@ async function write2(event, metadata2, opts) {
   const fallback = {};
   try {
     if (opts?.appId) {
-      doc2.appId = import_backend_core36.db.getProdAppID(opts.appId);
-      const appMetadata = await import_backend_core36.cache.app.getAppMetadata(opts.appId);
+      doc2.appId = import_backend_core35.db.getProdAppID(opts.appId);
+      const appMetadata = await import_backend_core35.cache.app.getAppMetadata(opts.appId);
       if ("name" in appMetadata) {
         fallback.appName = appMetadata.name;
       }
     }
     if (opts?.userId) {
-      const user = await import_backend_core36.users.getById(opts?.userId);
+      const user = await import_backend_core35.users.getById(opts?.userId);
       fallback.email = user.email;
     }
   } catch (err) {
-    import_backend_core36.logging.logAlert(
+    import_backend_core35.logging.logAlert(
       "Failed to retrieve fallback information for audit log",
       err
     );
@@ -10049,17 +9990,17 @@ async function enrich(logs) {
   const allUserIds = logs.map((log) => log.userId);
   const hasAppIdLogs = logs.filter((log) => log.appId);
   const allAppIds = hasAppIdLogs.map(
-    (log) => import_backend_core36.db.getDevAppID(log.appId)
+    (log) => import_backend_core35.db.getDevAppID(log.appId)
   );
-  const userList = await import_backend_core36.users.bulkGetGlobalUsersById(
+  const userList = await import_backend_core35.users.bulkGetGlobalUsersById(
     [...new Set(allUserIds)],
     { cleanup: true }
   );
-  const appList = await import_backend_core36.db.getAppsByIDs([...new Set(allAppIds)]);
+  const appList = await import_backend_core35.db.getAppsByIDs([...new Set(allAppIds)]);
   let enriched = [];
   for (let log of logs) {
     const user = userList.find((user2) => user2?._id === log.userId);
-    const app = appList.find((app2) => import_backend_core36.db.isSameAppID(app2?.appId, log.appId));
+    const app = appList.find((app2) => import_backend_core35.db.isSameAppID(app2?.appId, log.appId));
     const enrichedLog = {
       event: log.event,
       timestamp: log.timestamp,
@@ -10144,7 +10085,7 @@ __export(roles_exports, {
   assign: () => assign,
   unAssign: () => unAssign
 });
-var import_backend_core37 = require("@budibase/backend-core");
+var import_backend_core36 = require("@budibase/backend-core");
 async function assign(userIds, opts) {
   if (!await isExpandedPublicApiEnabled()) {
     throw new Error("Unable to assign roles - license required.");
@@ -10152,11 +10093,11 @@ async function assign(userIds, opts) {
   const users7 = await db3.bulkGet(userIds);
   for (let user of users7) {
     if (opts.role && opts.role.roleId) {
-      const prodAppId = import_backend_core37.db.getProdAppID(opts.role.appId);
+      const prodAppId = import_backend_core36.db.getProdAppID(opts.role.appId);
       user.roles[prodAppId] = opts.role.roleId;
     }
     if (opts.appBuilder) {
-      const prodAppId = import_backend_core37.db.getProdAppID(opts.appBuilder.appId);
+      const prodAppId = import_backend_core36.db.getProdAppID(opts.appBuilder.appId);
       const existing = user.builder?.apps || [];
       user.builder = {
         apps: existing.concat([prodAppId])
@@ -10183,13 +10124,13 @@ async function unAssign(userIds, opts) {
   const users7 = await db3.bulkGet(userIds);
   for (let user of users7) {
     if (opts.role) {
-      const prodAppId = import_backend_core37.db.getProdAppID(opts.role?.appId);
+      const prodAppId = import_backend_core36.db.getProdAppID(opts.role?.appId);
       if (user.roles[prodAppId] === opts.role.roleId) {
         delete user.roles[prodAppId];
       }
     }
     if (opts.appBuilder && user.builder?.apps) {
-      const prodAppId = import_backend_core37.db.getProdAppID(opts.appBuilder.appId);
+      const prodAppId = import_backend_core36.db.getProdAppID(opts.appBuilder.appId);
       user.builder.apps = user.builder.apps.filter((appId) => appId !== prodAppId);
     }
     if (opts.builder && user.builder) {
@@ -10207,7 +10148,7 @@ __export(applications_exports, {
   buildExportFn: () => buildExportFn,
   buildImportFn: () => buildImportFn
 });
-var import_backend_core38 = require("@budibase/backend-core");
+var import_backend_core37 = require("@budibase/backend-core");
 function buildImportFn(importFn) {
   return async (ctx, next) => {
     if (!await isExpandedPublicApiEnabled()) {
@@ -10216,7 +10157,7 @@ function buildImportFn(importFn) {
     if (!ctx.request.files?.appExport) {
       ctx.throw(400, "Must provide app export file for import.");
     }
-    await import_backend_core38.context.doInAppContext(ctx.params.appId, async () => {
+    await import_backend_core37.context.doInAppContext(ctx.params.appId, async () => {
       await importFn(ctx);
       ctx.body = void 0;
       ctx.status = 204;
@@ -10230,7 +10171,7 @@ function buildExportFn(exportFn) {
       ctx.throw(403, "Endpoint unavailable, license required.");
     }
     const { encryptPassword, excludeRows } = ctx.request.body;
-    await import_backend_core38.context.doInAppContext(ctx.params.appId, async () => {
+    await import_backend_core37.context.doInAppContext(ctx.params.appId, async () => {
       ctx.request.body = {
         encryptPassword,
         excludeRows
@@ -10243,15 +10184,15 @@ function buildExportFn(exportFn) {
 }
 
 // src/sdk/backups/backup.ts
-var import_backend_core40 = require("@budibase/backend-core");
+var import_backend_core39 = require("@budibase/backend-core");
 var import_types31 = require("@budibase/types");
 
 // src/sdk/backups/queue.ts
-var import_backend_core39 = require("@budibase/backend-core");
+var import_backend_core38 = require("@budibase/backend-core");
 var backupQueue;
 function init2() {
-  backupQueue = import_backend_core39.queue.createQueue(
-    import_backend_core39.queue.JobQueue.APP_BACKUP,
+  backupQueue = import_backend_core38.queue.createQueue(
+    import_backend_core38.queue.JobQueue.APP_BACKUP,
     {
       maxStalledCount: 3,
       jobOptions: {
@@ -10319,8 +10260,8 @@ async function updateAppBackup(backupId, backupName) {
 async function deleteAppBackup(backupId) {
   const metadata2 = await backups_exports.getAppBackupMetadata(backupId);
   if (metadata2.filename) {
-    await import_backend_core40.objectStore.deleteFile(
-      import_backend_core40.objectStore.ObjectStoreBuckets.BACKUPS,
+    await import_backend_core39.objectStore.deleteFile(
+      import_backend_core39.objectStore.ObjectStoreBuckets.BACKUPS,
       metadata2.filename
     );
   }
@@ -10334,15 +10275,15 @@ async function getBackupDownloadStream(backupId) {
   if (!metadata2.filename) {
     throw new Error("Backup incomplete - cannot download.");
   }
-  const stream = await import_backend_core40.objectStore.getReadStream(
-    import_backend_core40.objectStore.ObjectStoreBuckets.BACKUPS,
+  const stream = await import_backend_core39.objectStore.getReadStream(
+    import_backend_core39.objectStore.ObjectStoreBuckets.BACKUPS,
     metadata2.filename
   );
   return { metadata: metadata2, stream };
 }
 async function downloadAppBackup(backupId) {
   const { stream } = await getBackupDownloadStream(backupId);
-  const path2 = (0, import_path4.join)(import_backend_core40.objectStore.budibaseTempDir(), import_backend_core40.utils.newid());
+  const path2 = (0, import_path4.join)(import_backend_core39.objectStore.budibaseTempDir(), import_backend_core39.utils.newid());
   const writeStream = import_fs4.default.createWriteStream(path2);
   return new Promise((resolve, reject) => {
     stream.on("error", reject);
@@ -10377,7 +10318,7 @@ async function triggerAppBackup(appId, trigger, opts = {}) {
       ...opts
     }
   });
-  await import_backend_core40.events.backup.appBackupTriggered(
+  await import_backend_core39.events.backup.appBackupTriggered(
     appId,
     backup.id,
     import_types31.AppBackupType.BACKUP,
@@ -10437,7 +10378,7 @@ var processing_exports = {};
 __export(processing_exports, {
   init: () => init3
 });
-var import_backend_core41 = require("@budibase/backend-core");
+var import_backend_core40 = require("@budibase/backend-core");
 var import_types32 = require("@budibase/types");
 var import_fs5 = __toESM(require("fs"));
 async function init3(opts) {
@@ -10450,7 +10391,7 @@ async function init3(opts) {
         return importProcessor(job, opts);
       }
     } catch (err) {
-      import_backend_core41.logging.logAlert(
+      import_backend_core40.logging.logAlert(
         `Failed to perform backup for app ID: ${data.appId}`,
         err
       );
@@ -10458,11 +10399,11 @@ async function init3(opts) {
   });
 }
 async function removeExistingApp(devId) {
-  const devDb = import_backend_core41.db.getDB(devId, { skip_setup: true });
+  const devDb = import_backend_core40.db.getDB(devId, { skip_setup: true });
   await devDb.destroy();
 }
 async function runBackup(trigger, tenantId, appId, opts) {
-  const devAppId = import_backend_core41.db.getDevAppID(appId), prodAppId = import_backend_core41.db.getProdAppID(appId);
+  const devAppId = import_backend_core40.db.getDevAppID(appId), prodAppId = import_backend_core40.db.getProdAppID(appId);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const updateMetadata = async (status2, updateOpts) => {
     if (opts?.doc) {
@@ -10492,9 +10433,9 @@ async function runBackup(trigger, tenantId, appId, opts) {
     const tarPath = await opts.processing.exportAppFn(devAppId, { tar: true });
     const contents = await opts.processing.statsFn(devAppId);
     let filename = `${prodAppId}/backup-${timestamp}.tar.gz`;
-    const bucket = import_backend_core41.objectStore.ObjectStoreBuckets.BACKUPS;
+    const bucket = import_backend_core40.objectStore.ObjectStoreBuckets.BACKUPS;
     const fileStream = import_fs5.default.createReadStream(tarPath);
-    await import_backend_core41.objectStore.streamUpload({
+    await import_backend_core40.objectStore.streamUpload({
       bucket,
       filename,
       stream: fileStream,
@@ -10513,16 +10454,16 @@ async function runBackup(trigger, tenantId, appId, opts) {
       import_fs5.default.rmSync(tarPath);
     }
   } catch (err) {
-    import_backend_core41.logging.logAlert("App backup error", err);
+    import_backend_core40.logging.logAlert("App backup error", err);
     await updateMetadata(import_types32.AppBackupStatus.FAILED);
   }
 }
 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 tenantId = import_backend_core41.tenancy.getTenantIDFromAppID(appId);
-  return import_backend_core41.tenancy.doInTenant(tenantId, async () => {
-    const devAppId = import_backend_core41.db.getDevAppID(appId);
+  const tenantId = import_backend_core40.tenancy.getTenantIDFromAppID(appId);
+  return import_backend_core40.tenancy.doInTenant(tenantId, async () => {
+    const devAppId = import_backend_core40.db.getDevAppID(appId);
     const { rev: rev2 } = await backup_default.updateRestoreStatus(
       data.docId,
       data.docRev,
@@ -10537,7 +10478,7 @@ async function importProcessor(job, opts) {
     await removeExistingApp(devAppId);
     let status2 = import_types32.AppBackupStatus.COMPLETE;
     try {
-      await opts.importAppFn(devAppId, import_backend_core41.db.getDB(devAppId), {
+      await opts.importAppFn(devAppId, import_backend_core40.db.getDB(devAppId), {
         file: {
           type: "application/gzip",
           path: path2
@@ -10545,7 +10486,7 @@ async function importProcessor(job, opts) {
         key: path2
       });
     } catch (err) {
-      import_backend_core41.logging.logAlert("App restore error", err);
+      import_backend_core40.logging.logAlert("App restore error", err);
       status2 = import_types32.AppBackupStatus.FAILED;
     }
     await backup_default.updateRestoreStatus(data.docId, rev2, status2);
@@ -10557,8 +10498,8 @@ async function importProcessor(job, opts) {
 async function exportProcessor(job, opts) {
   const data = job.data;
   const appId = data.appId, trigger = data.export.trigger, name2 = data.export.name;
-  const tenantId = import_backend_core41.tenancy.getTenantIDFromAppID(appId);
-  await import_backend_core41.tenancy.doInTenant(tenantId, async () => {
+  const tenantId = import_backend_core40.tenancy.getTenantIDFromAppID(appId);
+  await import_backend_core40.tenancy.doInTenant(tenantId, async () => {
     try {
       const { rev: rev2 } = await backup_default.updateBackupStatus(
         data.docId,
@@ -10570,7 +10511,7 @@ async function exportProcessor(job, opts) {
         name: name2
       });
     } catch (err) {
-      import_backend_core41.logging.logAlert("App backup error", err);
+      import_backend_core40.logging.logAlert("App backup error", err);
     }
   });
 }
@@ -10604,12 +10545,12 @@ __export(users_exports3, {
   update: () => update3
 });
 var import_merge2 = __toESM(require_merge2());
-var import_backend_core42 = require("@budibase/backend-core");
+var import_backend_core41 = require("@budibase/backend-core");
 var import_types33 = require("@budibase/types");
 async function get5(params) {
-  const db4 = import_backend_core42.tenancy.getGlobalDB();
-  const builder2 = new import_backend_core42.db.QueryBuilder(db4.name, import_types33.SearchIndex.USER);
-  builder2.setIndexBuilder(import_backend_core42.db.searchIndexes.createUserIndex);
+  const db4 = import_backend_core41.tenancy.getGlobalDB();
+  const builder2 = new import_backend_core41.db.QueryBuilder(db4.name, import_types33.SearchIndex.USER);
+  builder2.setIndexBuilder(import_backend_core41.db.searchIndexes.createUserIndex);
   builder2.setLimit(params.pageSize);
   builder2.addEqual("scimInfo.isSync", true);
   for (const [key, value] of Object.entries(params.filters?.equal ?? {})) {
@@ -10624,13 +10565,13 @@ async function get5(params) {
   };
 }
 async function find(id) {
-  return await import_backend_core42.users.getById(id);
+  return await import_backend_core41.users.getById(id);
 }
 async function create(user) {
   const existingUser = await db3.getUserByEmail(user.email);
   if (existingUser) {
     if (existingUser.scimInfo?.isSync) {
-      throw new import_backend_core42.HTTPError(`User is already synched`, 409);
+      throw new import_backend_core41.HTTPError(`User is already synched`, 409);
     }
     user = {
       ...existingUser,
@@ -10659,7 +10600,7 @@ __export(groups_exports3, {
   create: () => create2
 });
 var import_merge3 = __toESM(require_merge2());
-var import_backend_core43 = require("@budibase/backend-core");
+var import_backend_core42 = require("@budibase/backend-core");
 async function create2(data) {
   const existingGroup = await getByName(data.name);
   let groupId;
@@ -10668,7 +10609,7 @@ async function create2(data) {
     groupId = createdGroup.id;
   } else {
     if (existingGroup.scimInfo?.isSync) {
-      throw new import_backend_core43.HTTPError(`Group is already synched`, 409);
+      throw new import_backend_core42.HTTPError(`Group is already synched`, 409);
     }
     groupId = existingGroup._id;
     if (existingGroup.users) {
@@ -10692,16 +10633,16 @@ __export(logger_exports, {
   logResponse: () => logResponse
 });
 var import_dayjs = __toESM(require_dayjs_min());
-var import_backend_core44 = require("@budibase/backend-core");
-var { DocWritethrough } = import_backend_core44.cache.docWritethrough;
+var import_backend_core43 = require("@budibase/backend-core");
+var { DocWritethrough } = import_backend_core43.cache.docWritethrough;
 function getLogDocId() {
-  return `${import_backend_core44.db.DocumentType.SCIM_LOG}${import_backend_core44.db.SEPARATOR}${(0, import_dayjs.default)().format(
+  return `${import_backend_core43.db.DocumentType.SCIM_LOG}${import_backend_core43.db.SEPARATOR}${(0, import_dayjs.default)().format(
     "YYYYMMDD"
   )}`;
 }
 var getDB2 = async () => {
-  const dbName = import_backend_core44.context.getScimDBName();
-  return new DocWritethrough(import_backend_core44.db.getDB(dbName), getLogDocId());
+  const dbName = import_backend_core43.context.getScimDBName();
+  return new DocWritethrough(import_backend_core43.db.getDB(dbName), getLogDocId());
 };
 async function logRequest(request) {
   const logId = Date.now().toString();
@@ -10737,7 +10678,7 @@ __export(middleware_exports, {
 });
 
 // src/middleware/licensing.ts
-var import_backend_core45 = require("@budibase/backend-core");
+var import_backend_core44 = require("@budibase/backend-core");
 var import_types34 = require("@budibase/types");
 var licensing = (opts = {
   checkUsersLimit: true
@@ -10745,7 +10686,7 @@ var licensing = (opts = {
   return async (ctx, next) => {
     const licensingCheck = opts.licensingCheck ? opts.licensingCheck : () => !!ctx.user;
     if (licensingCheck(ctx)) {
-      if (import_backend_core45.env.SELF_HOSTED && import_backend_core45.env.DEFAULT_LICENSE) {
+      if (import_backend_core44.env.SELF_HOSTED && import_backend_core44.env.DEFAULT_LICENSE) {
         ctx.user.license = SELF_FREE_LICENSE;
         return next();
       }
@@ -10753,7 +10694,7 @@ var licensing = (opts = {
         populateLicense: opts.populateLicense,
         populateFreeLicense: opts.populateFreeLicense
       });
-      if (opts.checkUsersLimit && (import_backend_core45.utils.isServingApp(ctx) || import_backend_core45.utils.isServingBuilder(ctx) || import_backend_core45.utils.isServingBuilderPreview(ctx) || import_backend_core45.utils.isPublicApiRequest(ctx))) {
+      if (opts.checkUsersLimit && (import_backend_core44.utils.isServingApp(ctx) || import_backend_core44.utils.isServingBuilder(ctx) || import_backend_core44.utils.isServingBuilderPreview(ctx) || import_backend_core44.utils.isPublicApiRequest(ctx))) {
         await quotas_exports5.usageLimitIsExceeded(
           import_types34.StaticQuotaName.USERS,
           import_types34.QuotaUsageType.STATIC
@@ -10785,17 +10726,17 @@ var requireFeatures = (...featureFlags) => {
 };
 
 // src/middleware/doInScimContext.ts
-var import_backend_core46 = require("@budibase/backend-core");
+var import_backend_core45 = require("@budibase/backend-core");
 var doInScimContext = async (ctx, next) => {
   let logId;
-  if (!import_backend_core46.env.DISABLE_SCIM_CALLS) {
+  if (!import_backend_core45.env.DISABLE_SCIM_CALLS) {
     logId = await logger_exports.logRequest({
       // koa response stringify only returns status, message and header
       ...ctx.request.toJSON(),
       body: ctx.request.body
     });
   }
-  return await import_backend_core46.context.doInScimContext(async () => {
+  return await import_backend_core45.context.doInScimContext(async () => {
     const result = await next();
     if (logId) {
       await logger_exports.logResponse(logId, {
@@ -10815,8 +10756,8 @@ var requireSCIM = async (ctx, next) => {
 };
 
 // src/middleware/scimSyncResourceRestricted.ts
-var import_backend_core47 = require("@budibase/backend-core");
-var scimUserOnly = (paramId) => scimSyncChecks(import_backend_core47.users.getById, paramId, true);
+var import_backend_core46 = require("@budibase/backend-core");
+var scimUserOnly = (paramId) => scimSyncChecks(import_backend_core46.users.getById, paramId, true);
 var scimGroupOnly = (paramId) => scimSyncChecks(groups_exports.get, paramId, true);
 var internalGroupOnly = (paramId) => scimSyncChecks(groups_exports.get, paramId, false);
 function scimSyncChecks(getter, paramId, scimRequired) {
@@ -10834,8 +10775,8 @@ function scimSyncChecks(getter, paramId, scimRequired) {
 }
 
 // src/api/index.ts
-var api_exports2 = {};
-__export(api_exports2, {
+var api_exports = {};
+__export(api_exports, {
   ai: () => ai_default,
   appBackups: () => backups_default2,
   auditLogs: () => auditLogs_default,
@@ -10852,7 +10793,7 @@ __export(ai_exports2, {
 });
 
 // src/ai/LargeLanguageModel.ts
-var import_backend_core48 = require("@budibase/backend-core");
+var import_backend_core47 = require("@budibase/backend-core");
 var import_types35 = require("@budibase/types");
 var import_shared_core = require("@budibase/shared-core");
 
@@ -10991,7 +10932,7 @@ var LargeLanguageModel = class _LargeLanguageModel {
     }
   }
   async init() {
-    let aiConfig = await import_backend_core48.configs.getAIConfig();
+    let aiConfig = await import_backend_core47.configs.getAIConfig();
     const bbAIEnabled = await isBudibaseAIEnabled();
     if (!aiConfig && !bbAIEnabled) {
       throw Error("AI config must be defined to use Budibase AI LLM features");
@@ -11075,12 +11016,12 @@ async function generateCronExpression2(ctx) {
 // src/api/routes/ai/index.ts
 var import_types36 = require("@budibase/types");
 var import_router = __toESM(require("@koa/router"));
-var import_backend_core49 = require("@budibase/backend-core");
+var import_backend_core48 = require("@budibase/backend-core");
 var router = new import_router.default();
 router.post(
   "/api/ai/cron",
   feature_exports.requireFeature(import_types36.Feature.BUDIBASE_AI),
-  import_backend_core49.auth.builderOrAdmin,
+  import_backend_core48.auth.builderOrAdmin,
   generateCronExpression2
 );
 var ai_default = router;
@@ -11181,10 +11122,10 @@ async function removeAppBuilder3(ctx) {
 var import_router2 = __toESM(require("@koa/router"));
 var import_joi = __toESM(require("joi"));
 var import_types37 = require("@budibase/types");
-var import_backend_core50 = require("@budibase/backend-core");
+var import_backend_core49 = require("@budibase/backend-core");
 var router2 = new import_router2.default();
 function buildGroupSaveValidation() {
-  return import_backend_core50.auth.joiValidator.body(
+  return import_backend_core49.auth.joiValidator.body(
     import_joi.default.object({
       _id: import_joi.default.string().optional(),
       _rev: import_joi.default.string().optional(),
@@ -11202,7 +11143,7 @@ function buildGroupSaveValidation() {
 }
 router2.post(
   "/api/global/groups",
-  import_backend_core50.auth.adminOnly,
+  import_backend_core49.auth.adminOnly,
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
   buildGroupSaveValidation(),
   save5
@@ -11213,38 +11154,38 @@ router2.post(
 ).delete(
   "/api/global/groups/:groupId/:rev",
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
-  import_backend_core50.auth.adminOnly,
+  import_backend_core49.auth.adminOnly,
   internalGroupOnly("groupId"),
   destroy3
 ).get(
   "/api/global/groups/:groupId",
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
-  import_backend_core50.auth.adminOnly,
+  import_backend_core49.auth.adminOnly,
   find2
 ).get(
   "/api/global/groups/:groupId/users",
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
-  import_backend_core50.auth.builderOrAdmin,
+  import_backend_core49.auth.builderOrAdmin,
   searchUsers
 ).post(
   "/api/global/groups/:groupId/users",
-  import_backend_core50.auth.adminOnly,
+  import_backend_core49.auth.adminOnly,
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
   internalGroupOnly("groupId"),
   updateGroupUsers
 ).post(
   "/api/global/groups/:groupId/apps",
-  import_backend_core50.auth.builderOrAdmin,
+  import_backend_core49.auth.builderOrAdmin,
   feature_exports.requireFeature(import_types37.Feature.USER_GROUPS),
   updateGroupApps2
 ).post(
   "/api/global/groups/:groupId/app/:appId/builder",
-  import_backend_core50.auth.builderOrAdmin,
+  import_backend_core49.auth.builderOrAdmin,
   feature_exports.requireFeatures(import_types37.Feature.USER_GROUPS, import_types37.Feature.APP_BUILDERS),
   addAppBuilder3
 ).delete(
   "/api/global/groups/:groupId/app/:appId/builder",
-  import_backend_core50.auth.builderOrAdmin,
+  import_backend_core49.auth.builderOrAdmin,
   feature_exports.requireFeatures(import_types37.Feature.USER_GROUPS, import_types37.Feature.APP_BUILDERS),
   removeAppBuilder3
 );
@@ -11252,7 +11193,7 @@ var groups_default = router2;
 
 // src/api/controllers/global/environmentVariables.ts
 var import_types38 = require("@budibase/types");
-var import_backend_core51 = require("@budibase/backend-core");
+var import_backend_core50 = require("@budibase/backend-core");
 async function status(ctx) {
   ctx.body = {
     encryptionKeyAvailable: environmentVariables_exports2.isEncryptionKeyAvailable()
@@ -11270,7 +11211,7 @@ async function create3(ctx) {
   if (production !== development) {
     environments.push(import_types38.AppEnvironment.DEVELOPMENT);
   }
-  await import_backend_core51.events.environmentVariable.created(name2, environments);
+  await import_backend_core50.events.environmentVariable.created(name2, environments);
   ctx.status = 200;
 }
 async function update4(ctx) {
@@ -11282,17 +11223,17 @@ async function update4(ctx) {
 async function destroy4(ctx) {
   const varName = ctx.params.varName;
   await environmentVariables_exports2.remove(varName);
-  await import_backend_core51.events.environmentVariable.deleted(varName);
+  await import_backend_core50.events.environmentVariable.deleted(varName);
   ctx.status = 200;
 }
 
 // src/api/routes/global/environmentVariables.ts
-var import_backend_core52 = require("@budibase/backend-core");
+var import_backend_core51 = require("@budibase/backend-core");
 var import_router3 = __toESM(require("@koa/router"));
 var import_joi2 = __toESM(require("joi"));
 var router3 = new import_router3.default();
 function buildEnvVarUpdateValidator() {
-  return import_backend_core52.auth.joiValidator.body(
+  return import_backend_core51.auth.joiValidator.body(
     import_joi2.default.object({
       name: import_joi2.default.string().optional(),
       production: import_joi2.default.string().required(),
@@ -11300,35 +11241,35 @@ function buildEnvVarUpdateValidator() {
     })
   );
 }
-router3.get("/api/env/variables/status", import_backend_core52.auth.builderOrAdmin, status).get("/api/env/variables", import_backend_core52.auth.builderOrAdmin, fetch7).post(
+router3.get("/api/env/variables/status", import_backend_core51.auth.builderOrAdmin, status).get("/api/env/variables", import_backend_core51.auth.builderOrAdmin, fetch7).post(
   "/api/env/variables",
-  import_backend_core52.auth.builderOrAdmin,
+  import_backend_core51.auth.builderOrAdmin,
   buildEnvVarUpdateValidator(),
   create3
 ).patch(
   "/api/env/variables/:varName",
-  import_backend_core52.auth.builderOrAdmin,
+  import_backend_core51.auth.builderOrAdmin,
   buildEnvVarUpdateValidator(),
   update4
 ).delete(
   "/api/env/variables/:varName",
-  import_backend_core52.auth.builderOrAdmin,
+  import_backend_core51.auth.builderOrAdmin,
   destroy4
 );
 var environmentVariables_default = router3;
 
 // src/api/controllers/global/auditLogs.ts
-var import_backend_core53 = require("@budibase/backend-core");
+var import_backend_core52 = require("@budibase/backend-core");
 async function search(ctx) {
   const search2 = ctx.request.body;
   const fetched = await auditLogs_exports3.fetch(search2);
-  await import_backend_core53.events.auditLog.filtered(search2);
+  await import_backend_core52.events.auditLog.filtered(search2);
   ctx.body = fetched;
 }
 async function download2(ctx) {
   const search2 = ctx.request.body;
   const { stream } = auditLogs_exports3.download(search2);
-  await import_backend_core53.events.auditLog.downloaded(search2);
+  await import_backend_core52.events.auditLog.downloaded(search2);
   ctx.attachment(`audit-logs-${Date.now()}.log`);
   ctx.body = stream;
 }
@@ -11340,11 +11281,11 @@ async function definitions2(ctx) {
 
 // src/api/routes/global/auditLogs.ts
 var import_types39 = require("@budibase/types");
-var import_backend_core54 = require("@budibase/backend-core");
+var import_backend_core53 = require("@budibase/backend-core");
 var import_router4 = __toESM(require("@koa/router"));
 var import_joi3 = __toESM(require("joi"));
 function buildAuditLogSearchValidator() {
-  return import_backend_core54.auth.joiValidator.body(
+  return import_backend_core53.auth.joiValidator.body(
     import_joi3.default.object({
       userIds: import_joi3.default.array().items(import_joi3.default.string()).optional(),
       appIds: import_joi3.default.array().items(import_joi3.default.string()).optional(),
@@ -11359,26 +11300,26 @@ function buildAuditLogSearchValidator() {
 var router4 = new import_router4.default();
 router4.post(
   "/api/global/auditlogs/search",
-  import_backend_core54.auth.adminOnly,
+  import_backend_core53.auth.adminOnly,
   buildAuditLogSearchValidator(),
   search
 ).get(
   "/api/global/auditlogs/download",
-  import_backend_core54.auth.adminOnly,
+  import_backend_core53.auth.adminOnly,
   // convert query string param to body
-  import_backend_core54.middleware.querystringToBody,
+  import_backend_core53.middleware.querystringToBody,
   buildAuditLogSearchValidator(),
   download2
 ).get(
   "/api/global/auditlogs/definitions",
-  import_backend_core54.auth.adminOnly,
+  import_backend_core53.auth.adminOnly,
   definitions2
 );
 var auditLogs_default = router4;
 
 // src/api/controllers/apps/backups.ts
 var import_types40 = require("@budibase/types");
-var import_backend_core55 = require("@budibase/backend-core");
+var import_backend_core54 = require("@budibase/backend-core");
 async function checkAppID(ctx, appId) {
   if (!await utils_exports2.appExists(appId)) {
     ctx.throw(400, `Provided app ID: ${appId} - is invalid.`);
@@ -11419,7 +11360,7 @@ async function importBackup(ctx) {
   if (!response) {
     ctx.throw(500, "Unable to start restore.");
   }
-  await import_backend_core55.events.backup.appBackupRestored(response.metadata);
+  await import_backend_core54.events.backup.appBackupRestored(response.metadata);
   ctx.body = {
     restoredId: response?.restoreId,
     message: "Restore triggered - process starting."
@@ -11469,10 +11410,10 @@ async function downloadBackup(ctx) {
 var import_router5 = __toESM(require("@koa/router"));
 var import_joi4 = __toESM(require("joi"));
 var import_types41 = require("@budibase/types");
-var import_backend_core56 = require("@budibase/backend-core");
+var import_backend_core55 = require("@budibase/backend-core");
 var router5 = new import_router5.default();
 function validateBackupSearch() {
-  return import_backend_core56.auth.joiValidator.body(
+  return import_backend_core55.auth.joiValidator.body(
     import_joi4.default.object({
       trigger: import_joi4.default.string().valid(...Object.values(import_types41.AppBackupTrigger)),
       type: import_joi4.default.string().valid(...Object.values(import_types41.AppBackupType)),
@@ -11482,26 +11423,26 @@ function validateBackupSearch() {
     })
   );
 }
-router5.post("/api/apps/:appId/backups", import_backend_core56.auth.builderOrAdmin, manualBackup).post(
+router5.post("/api/apps/:appId/backups", import_backend_core55.auth.builderOrAdmin, manualBackup).post(
   "/api/apps/:appId/backups/search",
-  import_backend_core56.auth.builderOrAdmin,
+  import_backend_core55.auth.builderOrAdmin,
   validateBackupSearch(),
   fetchBackups
 ).get(
   "/api/apps/:appId/backups/:backupId/file",
-  import_backend_core56.auth.builderOrAdmin,
+  import_backend_core55.auth.builderOrAdmin,
   downloadBackup
 ).patch(
   "/api/apps/:appId/backups/:backupId",
-  import_backend_core56.auth.builderOrAdmin,
+  import_backend_core55.auth.builderOrAdmin,
   updateBackup
 ).delete(
   "/api/apps/:appId/backups/:backupId",
-  import_backend_core56.auth.builderOrAdmin,
+  import_backend_core55.auth.builderOrAdmin,
   deleteBackup
 ).post(
   "/api/apps/:appId/backups/:backupId/import",
-  import_backend_core56.auth.builderOrAdmin,
+  import_backend_core55.auth.builderOrAdmin,
   importBackup
 );
 var backups_default2 = router5;
@@ -11511,7 +11452,7 @@ var import_router6 = __toESM(require("@koa/router"));
 
 // src/api/controllers/global/scim/users.ts
 var import_scim_patch = require("scim-patch");
-var import_backend_core57 = require("@budibase/backend-core");
+var import_backend_core56 = require("@budibase/backend-core");
 function tryGetQueryAsNumber(ctx, name2) {
   const value = ctx.request.query[name2];
   if (value === void 0) {
@@ -11549,7 +11490,7 @@ var create4 = async (ctx) => {
     const user = await users_exports3.create(userToCreate);
     ctx.body = mappers_exports.user.toScimUserResponse(user);
   } catch (e) {
-    if (e instanceof import_backend_core57.EmailUnavailableError) {
+    if (e instanceof import_backend_core56.EmailUnavailableError) {
       ctx.throw(409, "Email already in use");
     }
     throw e;
@@ -11758,11 +11699,11 @@ var scim_default = router6;
 var import_router7 = __toESM(require("@koa/router"));
 
 // src/api/controllers/global/users.ts
-var import_backend_core58 = require("@budibase/backend-core");
+var import_backend_core57 = require("@budibase/backend-core");
 async function addAppBuilder4(ctx) {
   const { userId, appId } = ctx.params;
   const user = await users_exports.db.getUser(userId);
-  if (import_backend_core58.users.isGlobalBuilder(user)) {
+  if (import_backend_core57.users.isGlobalBuilder(user)) {
     ctx.body = { message: "User already admin - no permissions updated." };
     return;
   }
@@ -11772,7 +11713,7 @@ async function addAppBuilder4(ctx) {
 async function removeAppBuilder4(ctx) {
   const { userId, appId } = ctx.params;
   const user = await users_exports.db.getUser(userId);
-  if (import_backend_core58.users.isGlobalBuilder(user)) {
+  if (import_backend_core57.users.isGlobalBuilder(user)) {
     ctx.body = { message: "User already admin - no permissions removed." };
     return;
   }
@@ -11782,16 +11723,16 @@ async function removeAppBuilder4(ctx) {
 
 // src/api/routes/global/users.ts
 var import_types43 = require("@budibase/types");
-var import_backend_core59 = require("@budibase/backend-core");
+var import_backend_core58 = require("@budibase/backend-core");
 var router7 = new import_router7.default();
 router7.post(
   "/api/global/users/:userId/app/:appId/builder",
-  import_backend_core59.auth.builderOrAdmin,
+  import_backend_core58.auth.builderOrAdmin,
   feature_exports.requireFeatures(import_types43.Feature.APP_BUILDERS),
   addAppBuilder4
 ).delete(
   "/api/global/users/:userId/app/:appId/builder",
-  import_backend_core59.auth.builderOrAdmin,
+  import_backend_core58.auth.builderOrAdmin,
   feature_exports.requireFeatures(import_types43.Feature.APP_BUILDERS),
   removeAppBuilder4
 );
@@ -11813,7 +11754,7 @@ __export(users_exports6, {
 });
 var import_types44 = require("@budibase/types");
 var import_scim2_parse_filter2 = require("scim2-parse-filter");
-var import_backend_core60 = require("@budibase/backend-core");
+var import_backend_core59 = require("@budibase/backend-core");
 var import_shared_core3 = require("@budibase/shared-core");
 var { unreachable } = import_shared_core3.utils;
 var toScimUserResponse = (user) => {
@@ -11842,7 +11783,7 @@ var isScimUserResponse = (user) => {
   return !!user?.id;
 };
 function tryGetEmail(user) {
-  if (import_backend_core60.utils.validEmail(user.userName)) {
+  if (import_backend_core59.utils.validEmail(user.userName)) {
     return user.userName;
   }
   if (!user.emails) {