@budibase/backend-core 2.29.9 → 2.29.14

package/dist/index.js

@@ -53704,7 +53704,10 @@ var require_strategy2 = __commonJS({
           var meta = state2;
           var callbackURL = meta.callbackURL;
           var oauth2 = self2._getOAuth2Client(meta);
-          var params2 = { grant_type: "authorization_code", redirect_uri: callbackURL };
+          var params2 = {
+            grant_type: "authorization_code",
+            redirect_uri: callbackURL
+          };
           if (state2.pkce) {
             params2.code_verifier = state2.params.verifier;
           }
@@ -53818,6 +53821,9 @@ var require_strategy2 = __commonJS({
                       try {
                         var json = JSON.parse(body2);
                         profile.id = json.sub;
+                        if (jwtClaims && jwtClaims.oid) {
+                          profile.id = jwtClaims.oid;
+                        }
                         if (!profile.id) {
                           profile.id = json.user_id;
                         }
@@ -54040,13 +54046,19 @@ var require_strategy2 = __commonJS({
             var verifier = base64url(crypto2.pseudoRandomBytes(32));
             switch (config.pkce) {
               case "S256":
-                params2.code_challenge = base64url(crypto2.createHash("sha256").update(verifier).digest());
+                params2.code_challenge = base64url(
+                  crypto2.createHash("sha256").update(verifier).digest()
+                );
                 break;
               case "plain":
                 params2.code_challenge = verifier;
                 break;
               default:
-                return self2.error(new Error("Unsupported code verifier transformation method: " + config.pkce));
+                return self2.error(
+                  new Error(
+                    "Unsupported code verifier transformation method: " + config.pkce
+                  )
+                );
             }
             params2.code_challenge_method = config.pkce;
             params2.verifier = verifier;
@@ -54204,9 +54216,9 @@ __export(src_exports, {
   sql: () => sql_exports,
   tenancy: () => tenancy,
   timers: () => timers_exports,
-  userUtils: () => utils_exports4,
+  userUtils: () => utils_exports5,
   users: () => users_exports3,
-  utils: () => utils_exports3
+  utils: () => utils_exports4
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -54739,20 +54751,6 @@ var SWITCHABLE_TYPES = {
   ["number" /* NUMBER */]: ["number" /* NUMBER */, "boolean" /* BOOLEAN */]
 };
 
-// ../shared-core/src/constants/rows.ts
-var CONSTANT_INTERNAL_ROW_COLS = [
-  "_id",
-  "_rev",
-  "type",
-  "createdAt",
-  "updatedAt",
-  "tableId"
-];
-var CONSTANT_EXTERNAL_ROW_COLS = ["_id", "_rev", "tableId"];
-function isInternalColumnName(name) {
-  return CONSTANT_INTERNAL_ROW_COLS.includes(name);
-}
-
 // ../shared-core/src/constants/index.ts
 var OperatorOptions = {
   Equals: {
@@ -56098,8 +56096,26 @@ var environment = {
     environment[key] = value;
   },
   ROLLING_LOG_MAX_SIZE: process.env.ROLLING_LOG_MAX_SIZE || "10M",
-  DISABLE_SCIM_CALLS: process.env.DISABLE_SCIM_CALLS
+  DISABLE_SCIM_CALLS: process.env.DISABLE_SCIM_CALLS,
+  BB_ADMIN_USER_EMAIL: process.env.BB_ADMIN_USER_EMAIL,
+  BB_ADMIN_USER_PASSWORD: process.env.BB_ADMIN_USER_PASSWORD,
+  OPENAI_API_KEY: process.env.OPENAI_API_KEY
 };
+var SECRETS = [
+  "API_ENCRYPTION_KEY",
+  "BB_ADMIN_USER_PASSWORD",
+  "COUCH_DB_PASSWORD",
+  "COUCH_DB_SQL_URL",
+  "COUCH_DB_URL",
+  "GOOGLE_CLIENT_SECRET",
+  "INTERNAL_API_KEY_FALLBACK",
+  "INTERNAL_API_KEY",
+  "JWT_SECRET",
+  "MINIO_ACCESS_KEY",
+  "MINIO_SECRET_KEY",
+  "OPENAI_API_KEY",
+  "REDIS_PASSWORD"
+];
 for (let [key, value] of Object.entries(environment)) {
   if (value === "0") {
     environment[key] = 0;
@@ -56497,1016 +56513,1650 @@ var DDInstrumentedDatabase = class {
   }
 };
 
-// src/db/couch/DatabaseImpl.ts
-var DATABASE_NOT_FOUND = "Database does not exist.";
-function buildNano(couchInfo) {
-  return (0, import_nano.default)({
-    url: couchInfo.url,
-    requestDefaults: {
-      headers: {
-        Authorization: couchInfo.cookie
-      }
-    },
-    parseUrl: false
-  });
-}
-var CouchDBError = class extends Error {
-  constructor(message, info) {
-    super(message);
-    const statusCode = info.status || info.statusCode || 500;
-    this.status = statusCode;
-    this.statusCode = statusCode;
-    this.reason = info.reason;
-    this.name = info.name;
-    this.errid = info.errid;
-    this.description = info.description;
-    this.error = info.error;
+// src/sql/utils.ts
+var utils_exports3 = {};
+__export(utils_exports3, {
+  breakExternalTableId: () => breakExternalTableId,
+  breakRowIdField: () => breakRowIdField,
+  buildExternalTableId: () => buildExternalTableId,
+  convertRowId: () => convertRowId,
+  generateRowIdField: () => generateRowIdField,
+  getNativeSql: () => getNativeSql,
+  isExternalTable: () => isExternalTable,
+  isExternalTableID: () => isExternalTableID,
+  isInternalTableID: () => isInternalTableID,
+  isInvalidISODateString: () => isInvalidISODateString,
+  isRowId: () => isRowId,
+  isValidFilter: () => isValidFilter,
+  isValidISODateString: () => isValidISODateString,
+  sqlLog: () => sqlLog
+});
+
+// src/db/index.ts
+var db_exports = {};
+__export(db_exports, {
+  APP_DEV: () => APP_DEV,
+  APP_DEV_PREFIX: () => APP_DEV_PREFIX2,
+  APP_PREFIX: () => APP_PREFIX2,
+  AutomationViewMode: () => AutomationViewMode,
+  BUDIBASE_DATASOURCE_TYPE: () => BUDIBASE_DATASOURCE_TYPE,
+  DEFAULT_BB_DATASOURCE_ID: () => DEFAULT_BB_DATASOURCE_ID,
+  DEFAULT_EMPLOYEE_TABLE_ID: () => DEFAULT_EMPLOYEE_TABLE_ID,
+  DEFAULT_EXPENSES_TABLE_ID: () => DEFAULT_EXPENSES_TABLE_ID,
+  DEFAULT_INVENTORY_TABLE_ID: () => DEFAULT_INVENTORY_TABLE_ID,
+  DEFAULT_JOBS_TABLE_ID: () => DEFAULT_JOBS_TABLE_ID,
+  DatabaseImpl: () => DatabaseImpl,
+  DatabaseWithConnection: () => DatabaseWithConnection,
+  DeprecatedViews: () => DeprecatedViews,
+  DocumentType: () => DocumentType,
+  InternalTable: () => InternalTable,
+  QueryBuilder: () => QueryBuilder,
+  Replication: () => Replication_default,
+  SEPARATOR: () => SEPARATOR,
+  SQLITE_DESIGN_DOC_ID: () => SQLITE_DESIGN_DOC_ID,
+  SQS_DATASOURCE_INTERNAL: () => SQS_DATASOURCE_INTERNAL,
+  StaticDatabases: () => StaticDatabases,
+  UNICODE_MAX: () => UNICODE_MAX,
+  ViewName: () => ViewName,
+  baseGlobalDBName: () => baseGlobalDBName,
+  checkErrorCode: () => checkErrorCode,
+  closePouchDB: () => closePouchDB,
+  createApiKeyView: () => createApiKeyView,
+  createNewUserEmailView: () => createNewUserEmailView,
+  createPlatformAccountEmailView: () => createPlatformAccountEmailView,
+  createPlatformUserView: () => createPlatformUserView,
+  createUserAppView: () => createUserAppView,
+  createView: () => createView,
+  dbExists: () => dbExists,
+  directCouchAllDbs: () => directCouchAllDbs,
+  directCouchCall: () => directCouchCall,
+  directCouchFind: () => directCouchFind,
+  directCouchQuery: () => directCouchQuery,
+  directCouchUrlCall: () => directCouchUrlCall,
+  doWithDB: () => doWithDB,
+  extractAppUUID: () => extractAppUUID,
+  fullSearch: () => fullSearch,
+  generateAppID: () => generateAppID,
+  generateAppUserID: () => generateAppUserID,
+  generateDevInfoID: () => generateDevInfoID,
+  generateGlobalUserID: () => generateGlobalUserID,
+  generatePluginID: () => generatePluginID,
+  generateRoleID: () => generateRoleID,
+  generateRowID: () => generateRowID,
+  generateTableID: () => generateTableID,
+  generateTemplateID: () => generateTemplateID,
+  generateUserMetadataID: () => generateUserMetadataID,
+  generateWorkspaceID: () => generateWorkspaceID,
+  getAllApps: () => getAllApps,
+  getAllDbs: () => getAllDbs,
+  getAppsByIDs: () => getAppsByIDs,
+  getCouchInfo: () => getCouchInfo,
+  getDB: () => getDB,
+  getDevAppID: () => getDevAppID2,
+  getDevAppIDs: () => getDevAppIDs,
+  getDevelopmentAppID: () => getDevelopmentAppID,
+  getDocParams: () => getDocParams,
+  getGlobalDBName: () => getGlobalDBName,
+  getGlobalIDFromUserMetadataID: () => getGlobalIDFromUserMetadataID,
+  getGlobalUserParams: () => getGlobalUserParams,
+  getPluginParams: () => getPluginParams,
+  getPouch: () => getPouch,
+  getPouchDB: () => getPouchDB,
+  getProdAppID: () => getProdAppID2,
+  getProdAppIDs: () => getProdAppIDs,
+  getQueryIndex: () => getQueryIndex,
+  getRoleParams: () => getRoleParams,
+  getRowParams: () => getRowParams,
+  getStartEndKeyURL: () => getStartEndKeyURL,
+  getTemplateParams: () => getTemplateParams,
+  getUrlInfo: () => getUrlInfo,
+  getUserMetadataParams: () => getUserMetadataParams,
+  getUsersByAppParams: () => getUsersByAppParams,
+  getWorkspaceParams: () => getWorkspaceParams,
+  init: () => init,
+  isDatasourceId: () => isDatasourceId,
+  isDevApp: () => isDevApp,
+  isDevAppID: () => isDevAppID,
+  isDocumentConflictError: () => isDocumentConflictError,
+  isGlobalUserID: () => isGlobalUserID,
+  isProdAppID: () => isProdAppID,
+  isSameAppID: () => isSameAppID,
+  isTableId: () => isTableId,
+  paginatedSearch: () => paginatedSearch,
+  pagination: () => pagination,
+  prefixRoleID: () => prefixRoleID,
+  queryGlobalView: () => queryGlobalView,
+  queryGlobalViewRaw: () => queryGlobalViewRaw,
+  queryPlatformView: () => queryPlatformView,
+  queryView: () => queryView,
+  queryViewRaw: () => queryViewRaw,
+  removeKeyNumbering: () => removeKeyNumbering2,
+  searchIndexes: () => searchIndexes_exports
+});
+
+// src/cache/appMetadata.ts
+var appMetadata_exports = {};
+__export(appMetadata_exports, {
+  AppState: () => AppState,
+  getAppMetadata: () => getAppMetadata,
+  invalidateAppMetadata: () => invalidateAppMetadata
+});
+
+// src/redis/init.ts
+var init_exports = {};
+__export(init_exports, {
+  getAppClient: () => getAppClient,
+  getCacheClient: () => getCacheClient,
+  getDocWritethroughClient: () => getDocWritethroughClient,
+  getInviteClient: () => getInviteClient,
+  getLockClient: () => getLockClient,
+  getPasswordResetClient: () => getPasswordResetClient,
+  getSessionClient: () => getSessionClient,
+  getSocketClient: () => getSocketClient,
+  getUserClient: () => getUserClient,
+  getWritethroughClient: () => getWritethroughClient,
+  init: () => init3,
+  shutdown: () => shutdown
+});
+
+// src/redis/redis.ts
+var import_ioredis = __toESM(require("ioredis"));
+
+// src/redis/utils.ts
+var utils_exports2 = {};
+__export(utils_exports2, {
+  Databases: () => Databases,
+  SEPARATOR: () => SEPARATOR2,
+  SelectableDatabase: () => SelectableDatabase,
+  addDbPrefix: () => addDbPrefix,
+  getRedisConnectionDetails: () => getRedisConnectionDetails,
+  getRedisOptions: () => getRedisOptions,
+  removeDbPrefix: () => removeDbPrefix
+});
+var SLOT_REFRESH_MS = 2e3;
+var CONNECT_TIMEOUT_MS = 1e4;
+var SEPARATOR2 = "-";
+var Databases = /* @__PURE__ */ ((Databases2) => {
+  Databases2["PW_RESETS"] = "pwReset";
+  Databases2["VERIFICATIONS"] = "verification";
+  Databases2["INVITATIONS"] = "invitation";
+  Databases2["DEV_LOCKS"] = "devLocks";
+  Databases2["DEBOUNCE"] = "debounce";
+  Databases2["SESSIONS"] = "session";
+  Databases2["USER_CACHE"] = "users";
+  Databases2["FLAGS"] = "flags";
+  Databases2["APP_METADATA"] = "appMetadata";
+  Databases2["QUERY_VARS"] = "queryVars";
+  Databases2["LICENSES"] = "license";
+  Databases2["GENERIC_CACHE"] = "data_cache";
+  Databases2["WRITE_THROUGH"] = "writeThrough";
+  Databases2["LOCKS"] = "locks";
+  Databases2["SOCKET_IO"] = "socket_io";
+  Databases2["BPM_EVENTS"] = "bpmEvents";
+  Databases2["DOC_WRITE_THROUGH"] = "docWriteThrough";
+  return Databases2;
+})(Databases || {});
+var SelectableDatabase = /* @__PURE__ */ ((SelectableDatabase2) => {
+  SelectableDatabase2[SelectableDatabase2["DEFAULT"] = 0] = "DEFAULT";
+  SelectableDatabase2[SelectableDatabase2["SOCKET_IO"] = 1] = "SOCKET_IO";
+  SelectableDatabase2[SelectableDatabase2["RATE_LIMITING"] = 2] = "RATE_LIMITING";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_2"] = 3] = "UNUSED_2";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_3"] = 4] = "UNUSED_3";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_4"] = 5] = "UNUSED_4";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_5"] = 6] = "UNUSED_5";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_6"] = 7] = "UNUSED_6";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_7"] = 8] = "UNUSED_7";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_8"] = 9] = "UNUSED_8";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_9"] = 10] = "UNUSED_9";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_10"] = 11] = "UNUSED_10";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_11"] = 12] = "UNUSED_11";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_12"] = 13] = "UNUSED_12";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_13"] = 14] = "UNUSED_13";
+  SelectableDatabase2[SelectableDatabase2["UNUSED_14"] = 15] = "UNUSED_14";
+  return SelectableDatabase2;
+})(SelectableDatabase || {});
+function getRedisConnectionDetails() {
+  let password = environment_default.REDIS_PASSWORD;
+  let url = environment_default.REDIS_URL.split("//");
+  url = url.length > 1 ? url[1] : url[0];
+  url = url.split("@");
+  if (url.length > 1) {
+    password = url[0].split(":")[1];
+    url = url[1];
+  } else {
+    url = url[0];
   }
-};
-function DatabaseWithConnection(dbName, connection, opts) {
-  const db = new DatabaseImpl(dbName, opts, connection);
-  return new DDInstrumentedDatabase(db);
+  const [host, port] = url.split(":");
+  const portNumber = parseInt(port);
+  return {
+    host,
+    password,
+    // assume default port for redis if invalid found
+    port: isNaN(portNumber) ? 6379 : portNumber
+  };
 }
-var DatabaseImpl = class _DatabaseImpl {
-  constructor(dbName, opts, connection) {
-    this.couchInfo = getCouchInfo();
-    this.name = dbName;
-    this.pouchOpts = opts || {};
-    if (connection) {
-      this.couchInfo = getCouchInfo(connection);
-      this.instanceNano = buildNano(this.couchInfo);
-    }
-    if (!_DatabaseImpl.nano) {
-      _DatabaseImpl.init();
-    }
+function getRedisOptions() {
+  const { host, password, port } = getRedisConnectionDetails();
+  let redisOpts = {
+    connectTimeout: CONNECT_TIMEOUT_MS,
+    port,
+    host,
+    password
+  };
+  let opts = redisOpts;
+  if (environment_default.REDIS_CLUSTERED) {
+    opts = {
+      connectTimeout: CONNECT_TIMEOUT_MS,
+      redisOptions: {
+        ...redisOpts,
+        tls: {}
+      },
+      slotsRefreshTimeout: SLOT_REFRESH_MS,
+      dnsLookup: (address, callback) => callback(null, address)
+    };
   }
-  static init() {
-    const couchInfo = getCouchInfo();
-    _DatabaseImpl.nano = buildNano(couchInfo);
+  return opts;
+}
+function addDbPrefix(db, key) {
+  if (key.includes(db)) {
+    return key;
   }
-  exists(docId) {
-    if (docId === void 0) {
-      return this.dbExists();
-    }
-    return this.docExists(docId);
+  return `${db}${SEPARATOR2}${key}`;
+}
+function removeDbPrefix(key) {
+  let parts = key.split(SEPARATOR2);
+  if (parts.length >= 2) {
+    parts.shift();
+    return parts.join(SEPARATOR2);
+  } else {
+    return parts[0];
   }
-  async dbExists() {
-    const response = await directCouchUrlCall({
-      url: `${this.couchInfo.url}/${this.name}`,
-      method: "HEAD",
-      cookie: this.couchInfo.cookie
-    });
-    return response.status === 200;
+}
+
+// src/logging/index.ts
+var logging_exports = {};
+__export(logging_exports, {
+  correlation: () => correlation_exports,
+  logAlert: () => logAlert,
+  logAlertWithInfo: () => logAlertWithInfo,
+  logWarn: () => logWarn,
+  logger: () => logger,
+  system: () => system_exports
+});
+
+// src/logging/correlation/correlation.ts
+var correlation_exports = {};
+__export(correlation_exports, {
+  getId: () => getId,
+  setHeader: () => setHeader
+});
+var correlator = require("correlation-id");
+var setHeader = (headers) => {
+  const correlationId = correlator.getId();
+  if (!correlationId) {
+    return;
   }
-  async docExists(id) {
-    try {
-      await this.performCall((db) => () => db.head(id));
-      return true;
-    } catch {
-      return false;
+  headers["x-budibase-correlation-id" /* CORRELATION_ID */] = correlationId;
+};
+function getId() {
+  return correlator.getId();
+}
+
+// src/logging/pino/logger.ts
+var import_pino = __toESM(require("pino"));
+var import_pino_pretty = __toESM(require("pino-pretty"));
+var import_dd_trace2 = __toESM(require("dd-trace"));
+var import_ext = require("dd-trace/ext");
+
+// src/logging/system.ts
+var system_exports = {};
+__export(system_exports, {
+  getLogReadStream: () => getLogReadStream,
+  getSingleFileMaxSizeInfo: () => getSingleFileMaxSizeInfo,
+  localFileDestination: () => localFileDestination
+});
+var import_fs4 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var rfs = __toESM(require("rotating-file-stream"));
+
+// src/objectStore/index.ts
+var objectStore_exports2 = {};
+__export(objectStore_exports2, {
+  ObjectStore: () => ObjectStore,
+  ObjectStoreBuckets: () => ObjectStoreBuckets,
+  SIGNED_FILE_PREFIX: () => SIGNED_FILE_PREFIX,
+  bucketTTLConfig: () => bucketTTLConfig,
+  budibaseTempDir: () => budibaseTempDir,
+  clientLibraryCDNUrl: () => clientLibraryCDNUrl,
+  clientLibraryPath: () => clientLibraryPath,
+  clientLibraryUrl: () => clientLibraryUrl,
+  createBucketIfNotExists: () => createBucketIfNotExists,
+  deleteFile: () => deleteFile,
+  deleteFiles: () => deleteFiles,
+  deleteFolder: () => deleteFolder,
+  downloadTarball: () => downloadTarball,
+  downloadTarballDirect: () => downloadTarballDirect,
+  enrichPluginURLs: () => enrichPluginURLs,
+  extractBucketAndPath: () => extractBucketAndPath,
+  getAppFileUrl: () => getAppFileUrl,
+  getGlobalFileS3Key: () => getGlobalFileS3Key,
+  getGlobalFileUrl: () => getGlobalFileUrl,
+  getObjectMetadata: () => getObjectMetadata,
+  getPluginIconKey: () => getPluginIconKey,
+  getPluginJSKey: () => getPluginJSKey,
+  getPluginS3Dir: () => getPluginS3Dir,
+  getPresignedUrl: () => getPresignedUrl,
+  getReadStream: () => getReadStream,
+  listAllObjects: () => listAllObjects,
+  processAutomationAttachment: () => processAutomationAttachment,
+  processObjectStoreAttachment: () => processObjectStoreAttachment,
+  retrieve: () => retrieve,
+  retrieveDirectory: () => retrieveDirectory,
+  retrieveToTmp: () => retrieveToTmp,
+  sanitizeBucket: () => sanitizeBucket,
+  sanitizeKey: () => sanitizeKey,
+  streamUpload: () => streamUpload,
+  upload: () => upload,
+  uploadDirectory: () => uploadDirectory
+});
+
+// src/objectStore/objectStore.ts
+var import_aws_sdk = __toESM(require("aws-sdk"));
+var import_stream2 = __toESM(require("stream"));
+var import_node_fetch2 = __toESM(require("node-fetch"));
+var import_tar_fs = __toESM(require("tar-fs"));
+var import_zlib = __toESM(require("zlib"));
+var import_util = require("util");
+var import_path2 = require("path");
+var import_fs3 = __toESM(require("fs"));
+
+// src/objectStore/utils.ts
+var import_path = __toESM(require("path"));
+var import_os = require("os");
+var import_fs2 = __toESM(require("fs"));
+var import_stream = __toESM(require("stream"));
+var ObjectStoreBuckets = {
+  BACKUPS: environment_default.BACKUPS_BUCKET_NAME,
+  APPS: environment_default.APPS_BUCKET_NAME,
+  TEMPLATES: environment_default.TEMPLATES_BUCKET_NAME,
+  GLOBAL: environment_default.GLOBAL_BUCKET_NAME,
+  PLUGINS: environment_default.PLUGIN_BUCKET_NAME,
+  TEMP: environment_default.TEMP_BUCKET_NAME
+};
+var bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
+try {
+  import_fs2.default.mkdirSync(bbTmp);
+} catch (e) {
+  if (e.code !== "EEXIST") {
+    throw e;
+  }
+}
+function budibaseTempDir() {
+  return bbTmp;
+}
+var bucketTTLConfig = (bucketName, days) => {
+  const lifecycleRule = {
+    ID: `${bucketName}-ExpireAfter${days}days`,
+    Prefix: "",
+    Status: "Enabled",
+    Expiration: {
+      Days: days
     }
+  };
+  const lifecycleConfiguration = {
+    Rules: [lifecycleRule]
+  };
+  return {
+    Bucket: bucketName,
+    LifecycleConfiguration: lifecycleConfiguration
+  };
+};
+async function processUrlAttachment(attachment) {
+  const response = await fetch(attachment.url);
+  if (!response.ok || !response.body) {
+    throw new Error(`Unexpected response ${response.statusText}`);
   }
-  nano() {
-    return this.instanceNano || _DatabaseImpl.nano;
+  const fallbackFilename = import_path.default.basename(new URL(attachment.url).pathname);
+  if (!response.body) {
+    throw new Error("No response received for attachment");
   }
-  getDb() {
-    return this.nano().db.use(this.name);
+  return {
+    filename: attachment.filename || fallbackFilename,
+    content: import_stream.default.Readable.fromWeb(response.body)
+  };
+}
+async function processObjectStoreAttachment(attachment) {
+  const result = extractBucketAndPath(attachment.url);
+  if (result === null) {
+    throw new Error("Invalid signed URL");
   }
-  async checkAndCreateDb() {
-    let shouldCreate = !this.pouchOpts?.skip_setup;
-    let exists2 = await this.exists();
-    if (!shouldCreate && !exists2) {
-      throw new Error("DB does not exist");
-    }
-    if (!exists2) {
-      try {
-        await this.nano().db.create(this.name);
-      } catch (err) {
-        if (err.statusCode !== 412) {
-          throw new CouchDBError(err.message, err);
-        }
-      }
-    }
-    return this.getDb();
+  const { bucket, path: objectPath } = result;
+  const readStream = await getReadStream(bucket, objectPath);
+  const fallbackFilename = import_path.default.basename(objectPath);
+  return {
+    bucket,
+    path: objectPath,
+    filename: attachment.filename || fallbackFilename,
+    content: readStream
+  };
+}
+async function processAutomationAttachment(attachment) {
+  const isFullyFormedUrl = attachment.url?.startsWith("http://") || attachment.url?.startsWith("https://");
+  if (isFullyFormedUrl) {
+    return await processUrlAttachment(attachment);
+  } else {
+    return await processObjectStoreAttachment(attachment);
   }
-  // this function fetches the DB and handles if DB creation is needed
-  async performCall(call) {
-    const db = this.getDb();
-    const fnc = await call(db);
-    try {
-      return await fnc();
-    } catch (err) {
-      if (err.statusCode === 404 && err.reason === DATABASE_NOT_FOUND) {
-        await this.checkAndCreateDb();
-        return await this.performCall(call);
-      }
-      throw new CouchDBError(`CouchDB error: ${err.message}`, err);
-    }
+}
+
+// src/objectStore/objectStore.ts
+var import_uuid2 = require("uuid");
+var import_promises = __toESM(require("fs/promises"));
+var sanitize = require("sanitize-s3-objectkey");
+var streamPipeline = (0, import_util.promisify)(import_stream2.default.pipeline);
+var STATE = {
+  bucketCreationPromises: {}
+};
+var SIGNED_FILE_PREFIX = "/files/signed";
+var CONTENT_TYPE_MAP = {
+  txt: "text/plain",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  json: "application/json",
+  gz: "application/gzip",
+  svg: "image/svg+xml",
+  form: "multipart/form-data"
+};
+var STRING_CONTENT_TYPES = [
+  CONTENT_TYPE_MAP.html,
+  CONTENT_TYPE_MAP.css,
+  CONTENT_TYPE_MAP.js,
+  CONTENT_TYPE_MAP.json
+];
+function sanitizeKey(input) {
+  return sanitize(sanitizeBucket(input)).replace(/\\/g, "/");
+}
+function sanitizeBucket(input) {
+  return input.replace(new RegExp(APP_DEV_PREFIX2, "g"), APP_PREFIX2);
+}
+function ObjectStore(bucket, opts = { presigning: false }) {
+  const config = {
+    s3ForcePathStyle: true,
+    signatureVersion: "v4",
+    apiVersion: "2006-03-01",
+    accessKeyId: environment_default.MINIO_ACCESS_KEY,
+    secretAccessKey: environment_default.MINIO_SECRET_KEY,
+    region: environment_default.AWS_REGION
+  };
+  if (bucket) {
+    config.params = {
+      Bucket: sanitizeBucket(bucket)
+    };
   }
-  async get(id) {
-    return this.performCall((db) => {
-      if (!id) {
-        throw new Error("Unable to get doc without a valid _id.");
-      }
-      return () => db.get(id);
-    });
+  if (!environment_default.MINIO_ENABLED && environment_default.AWS_SESSION_TOKEN) {
+    config.sessionToken = environment_default.AWS_SESSION_TOKEN;
   }
-  async getMultiple(ids, opts) {
-    ids = [...new Set(ids)];
-    const response = await this.allDocs({
-      keys: ids,
-      include_docs: true
-    });
-    const rowUnavailable = (row) => {
-      if (row.doc == null || "deleted" in row.value && row.value.deleted) {
-        return true;
-      }
-      return row.error === "not_found";
-    };
-    const rows = response.rows.filter((row) => !rowUnavailable(row));
-    const someMissing = rows.length !== response.rows.length;
-    if (!opts?.allowMissing && someMissing) {
-      const missing = response.rows.filter((row) => rowUnavailable(row));
-      const missingIds = missing.map((row) => row.key).join(", ");
-      throw new Error(`Unable to get documents: ${missingIds}`);
+  if (environment_default.MINIO_URL) {
+    if (opts.presigning && environment_default.MINIO_ENABLED) {
+      config.endpoint = "minio-service";
+    } else {
+      config.endpoint = environment_default.MINIO_URL;
     }
-    return rows.map((row) => row.doc);
   }
-  async remove(idOrDoc, rev) {
-    return this.performCall((db) => {
-      let _id;
-      let _rev;
-      if (isDocument(idOrDoc)) {
-        _id = idOrDoc._id;
-        _rev = idOrDoc._rev;
+  return new import_aws_sdk.default.S3(config);
+}
+async function createBucketIfNotExists(client, bucketName) {
+  bucketName = sanitizeBucket(bucketName);
+  try {
+    await client.headBucket({
+      Bucket: bucketName
+    }).promise();
+    return { created: false, exists: true };
+  } catch (err) {
+    const promises = STATE.bucketCreationPromises;
+    const doesntExist = err.statusCode === 404, noAccess = err.statusCode === 403;
+    if (promises[bucketName]) {
+      await promises[bucketName];
+      return { created: false, exists: true };
+    } else if (doesntExist || noAccess) {
+      if (doesntExist) {
+        promises[bucketName] = client.createBucket({
+          Bucket: bucketName
+        }).promise();
+        await promises[bucketName];
+        delete promises[bucketName];
+        return { created: true, exists: false };
       } else {
-        _id = idOrDoc;
-        _rev = rev;
-      }
-      if (!_id || !_rev) {
-        throw new Error("Unable to remove doc without a valid _id and _rev.");
+        throw new Error("Access denied to object store bucket." + err);
       }
-      return () => db.destroy(_id, _rev);
-    });
-  }
-  async post(document, opts) {
-    if (!document._id) {
-      document._id = newid();
+    } else {
+      throw new Error("Unable to write to object store bucket.");
     }
-    return this.put(document, opts);
   }
-  async put(document, opts) {
-    if (!document._id) {
-      throw new Error("Cannot store document without _id field.");
-    }
-    return this.performCall(async (db) => {
-      if (!document.createdAt) {
-        document.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      }
-      document.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      if (opts?.force && document._id) {
-        try {
-          const existing = await this.get(document._id);
-          if (existing) {
-            document._rev = existing._rev;
-          }
-        } catch (err) {
-          if (err.status !== 404) {
-            throw err;
-          }
-        }
+}
+async function upload({
+  bucket: bucketName,
+  filename,
+  path: path3,
+  type,
+  metadata,
+  body: body2,
+  ttl
+}) {
+  const extension = filename.split(".").pop();
+  const fileBytes = path3 ? (await import_promises.default.open(path3)).createReadStream() : body2;
+  const objectStore = ObjectStore(bucketName);
+  const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
+  if (ttl && bucketCreated.created) {
+    let ttlConfig = bucketTTLConfig(bucketName, ttl);
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
+  }
+  let contentType = type;
+  if (!contentType) {
+    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
+  }
+  const config = {
+    // windows file paths need to be converted to forward slashes for s3
+    Key: sanitizeKey(filename),
+    Body: fileBytes,
+    ContentType: contentType
+  };
+  if (metadata && typeof metadata === "object") {
+    for (let key of Object.keys(metadata)) {
+      if (!metadata[key] || typeof metadata[key] !== "string") {
+        delete metadata[key];
       }
-      return () => db.insert(document);
-    });
+    }
+    config.Metadata = metadata;
   }
-  async bulkDocs(documents) {
-    return this.performCall((db) => {
-      return () => db.bulk({ docs: documents });
-    });
+  return objectStore.upload(config).promise();
+}
+async function streamUpload({
+  bucket: bucketName,
+  stream: stream3,
+  filename,
+  type,
+  extra,
+  ttl
+}) {
+  if (!stream3) {
+    throw new Error("Stream to upload is invalid/undefined");
   }
-  async allDocs(params2) {
-    return this.performCall((db) => {
-      return () => db.list(params2);
-    });
+  const extension = filename.split(".").pop();
+  const objectStore = ObjectStore(bucketName);
+  const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
+  if (ttl && bucketCreated.created) {
+    let ttlConfig = bucketTTLConfig(bucketName, ttl);
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
   }
-  async _sqlQuery(url, method, body2) {
-    url = checkSlashesInUrl(`${this.couchInfo.sqlUrl}/${url}`);
-    const args = {
-      url,
-      method,
-      cookie: this.couchInfo.cookie
+  if (filename?.endsWith(".js")) {
+    extra = {
+      ...extra,
+      ContentType: "application/javascript"
+    };
+  } else if (filename?.endsWith(".svg")) {
+    extra = {
+      ...extra,
+      ContentType: "image"
     };
-    if (body2) {
-      args.body = body2;
-    }
-    return this.performCall(() => {
-      return async () => {
-        const response = await directCouchUrlCall(args);
-        const json = await response.json();
-        if (response.status > 300) {
-          throw json;
-        }
-        return json;
-      };
-    });
-  }
-  async sql(sql, parameters) {
-    const dbName = this.name;
-    const url = `/${dbName}/${SQLITE_DESIGN_DOC_ID}`;
-    return await this._sqlQuery(url, "POST", {
-      query: sql,
-      args: parameters
-    });
   }
-  // checks design document is accurate (cleans up tables)
-  // this will check the design document and remove anything from
-  // disk which is not supposed to be there
-  async sqlDiskCleanup() {
-    const dbName = this.name;
-    const url = `/${dbName}/_cleanup`;
-    try {
-      await this._sqlQuery(url, "POST");
-    } catch (err) {
-      if (err.status !== 500) {
-        throw err;
-      }
-    }
-  }
-  // removes a document from sqlite
-  async sqlPurgeDocument(docIds) {
-    if (!Array.isArray(docIds)) {
-      docIds = [docIds];
-    }
-    const dbName = this.name;
-    const url = `/${dbName}/_purge`;
-    return await this._sqlQuery(url, "POST", { docs: docIds });
+  let contentType = type;
+  if (!contentType) {
+    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
   }
-  async query(viewName, params2) {
-    return this.performCall((db) => {
-      const [database, view] = viewName.split("/");
-      return () => db.view(database, view, params2);
-    });
+  const bucket = sanitizeBucket(bucketName), objKey = sanitizeKey(filename);
+  const params2 = {
+    Bucket: bucket,
+    Key: objKey,
+    Body: stream3,
+    ContentType: contentType,
+    ...extra
+  };
+  const details = await objectStore.upload(params2).promise();
+  const headDetails = await objectStore.headObject({
+    Bucket: bucket,
+    Key: objKey
+  }).promise();
+  return {
+    ...details,
+    ContentLength: headDetails.ContentLength
+  };
+}
+async function retrieve(bucketName, filepath) {
+  const objectStore = ObjectStore(bucketName);
+  const params2 = {
+    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");
+  } else {
+    return response.Body;
   }
-  async destroy() {
-    if (environment_default.SQS_SEARCH_ENABLE && await this.exists(SQLITE_DESIGN_DOC_ID)) {
-      const definition = await this.get(SQLITE_DESIGN_DOC_ID);
-      definition.sql.tables = {};
-      await this.put(definition);
-      await this.sqlDiskCleanup();
+}
+async function listAllObjects(bucketName, path3) {
+  const objectStore = ObjectStore(bucketName);
+  const list = (params2 = {}) => {
+    return objectStore.listObjectsV2({
+      ...params2,
+      Bucket: sanitizeBucket(bucketName),
+      Prefix: sanitizeKey(path3)
+    }).promise();
+  };
+  let isTruncated = false, token, objects = [];
+  do {
+    let params2 = {};
+    if (token) {
+      params2.ContinuationToken = token;
     }
-    try {
-      return await this.nano().db.destroy(this.name);
-    } catch (err) {
-      if (err.statusCode === 404) {
-        return;
-      } else {
-        throw new CouchDBError(err.message, err);
-      }
+    const response = await list(params2);
+    if (response.Contents) {
+      objects = objects.concat(response.Contents);
     }
+    isTruncated = !!response.IsTruncated;
+    token = response.NextContinuationToken;
+  } while (isTruncated && token);
+  return objects;
+}
+function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
+  const objectStore = ObjectStore(bucketName, { presigning: true });
+  const params2 = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(key),
+    Expires: durationSeconds
+  };
+  const url = objectStore.getSignedUrl("getObject", params2);
+  if (!environment_default.MINIO_ENABLED) {
+    return url;
+  } else {
+    const signedUrl = new URL(url);
+    const path3 = signedUrl.pathname;
+    const query = signedUrl.search;
+    return `${SIGNED_FILE_PREFIX}${path3}${query}`;
   }
-  async compact() {
-    return this.performCall((db) => {
-      return () => db.compact();
-    });
-  }
-  // All below functions are in-frequently called, just utilise PouchDB
-  // for them as it implements them better than we can
-  async dump(stream3, opts) {
-    const pouch = getPouchDB(this.name);
-    return pouch.dump(stream3, opts);
-  }
-  async load(stream3) {
-    const pouch = getPouchDB(this.name);
-    return pouch.load(stream3);
-  }
-  async createIndex(opts) {
-    const pouch = getPouchDB(this.name);
-    return pouch.createIndex(opts);
-  }
-  async deleteIndex(opts) {
-    const pouch = getPouchDB(this.name);
-    return pouch.deleteIndex(opts);
-  }
-  async getIndexes() {
-    const pouch = getPouchDB(this.name);
-    return pouch.getIndexes();
-  }
-};
-
-// src/db/db.ts
-function getDB(dbName, opts) {
-  return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts));
 }
-async function doWithDB(dbName, cb, opts) {
-  const db = getDB(dbName, opts);
-  return await cb(db);
+async function retrieveToTmp(bucketName, filepath) {
+  bucketName = sanitizeBucket(bucketName);
+  filepath = sanitizeKey(filepath);
+  const data = await retrieve(bucketName, filepath);
+  const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
+  import_fs3.default.writeFileSync(outputPath, data);
+  return outputPath;
 }
-async function directCouchAllDbs(queryString) {
-  let couchPath = "/_all_dbs";
-  if (queryString) {
-    couchPath += `?${queryString}`;
+async function retrieveDirectory(bucketName, path3) {
+  let writePath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
+  import_fs3.default.mkdirSync(writePath);
+  const objects = await listAllObjects(bucketName, path3);
+  let streams = await Promise.all(
+    objects.map((obj) => getReadStream(bucketName, obj.Key))
+  );
+  let count = 0;
+  const writePromises = [];
+  for (let obj of objects) {
+    const filename = obj.Key;
+    const stream3 = streams[count++];
+    const possiblePath = filename.split("/");
+    const dirs = possiblePath.slice(0, possiblePath.length - 1);
+    const possibleDir = (0, import_path2.join)(writePath, ...dirs);
+    if (possiblePath.length > 1 && !import_fs3.default.existsSync(possibleDir)) {
+      import_fs3.default.mkdirSync(possibleDir, { recursive: true });
+    }
+    const writeStream = import_fs3.default.createWriteStream((0, import_path2.join)(writePath, ...possiblePath), {
+      mode: 420
+    });
+    stream3.pipe(writeStream);
+    writePromises.push(
+      new Promise((resolve, reject) => {
+        stream3.on("finish", resolve);
+        stream3.on("error", reject);
+        writeStream.on("error", reject);
+      })
+    );
   }
-  return await directCouchQuery(couchPath);
+  await Promise.all(writePromises);
+  return writePath;
 }
-async function directCouchFind(dbName, opts) {
-  const json = await directCouchQuery(`${dbName}/_find`, "POST", opts);
-  return { rows: json.docs, bookmark: json.bookmark };
+async function deleteFile(bucketName, filepath) {
+  const objectStore = ObjectStore(bucketName);
+  await createBucketIfNotExists(objectStore, bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Key: sanitizeKey(filepath)
+  };
+  return objectStore.deleteObject(params2).promise();
 }
-
-// src/context/mainContext.ts
-var TEST_APP_ID = null;
-function getGlobalDBName(tenantId) {
-  if (!tenantId) {
-    tenantId = getTenantId();
-  }
-  return baseGlobalDBName(tenantId);
+async function deleteFiles(bucketName, filepaths) {
+  const objectStore = ObjectStore(bucketName);
+  await createBucketIfNotExists(objectStore, bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: filepaths.map((path3) => ({ Key: sanitizeKey(path3) }))
+    }
+  };
+  return objectStore.deleteObjects(params2).promise();
 }
-function getAuditLogDBName(tenantId) {
-  if (!tenantId) {
-    tenantId = getTenantId();
+async function deleteFolder(bucketName, folder) {
+  bucketName = sanitizeBucket(bucketName);
+  folder = sanitizeKey(folder);
+  const client = ObjectStore(bucketName);
+  const listParams = {
+    Bucket: bucketName,
+    Prefix: folder
+  };
+  const existingObjectsResponse = await client.listObjects(listParams).promise();
+  if (existingObjectsResponse.Contents?.length === 0) {
+    return;
   }
-  if (tenantId === DEFAULT_TENANT_ID) {
-    return StaticDatabases.AUDIT_LOGS.name;
-  } else {
-    return `${tenantId}${SEPARATOR}${StaticDatabases.AUDIT_LOGS.name}`;
+  const deleteParams = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: []
+    }
+  };
+  existingObjectsResponse.Contents?.forEach((content) => {
+    deleteParams.Delete.Objects.push({ Key: content.Key });
+  });
+  const deleteResponse = await client.deleteObjects(deleteParams).promise();
+  if (deleteResponse.Deleted?.length === 1e3) {
+    return deleteFolder(bucketName, folder);
   }
 }
-function getScimDBName(tenantId) {
-  if (!tenantId) {
-    tenantId = getTenantId();
-  }
-  if (tenantId === DEFAULT_TENANT_ID) {
-    return StaticDatabases.SCIM_LOGS.name;
-  } else {
-    return `${tenantId}${SEPARATOR}${StaticDatabases.SCIM_LOGS.name}`;
-  }
-}
-function baseGlobalDBName(tenantId) {
-  if (!tenantId || tenantId === DEFAULT_TENANT_ID) {
-    return StaticDatabases.GLOBAL.name;
-  } else {
-    return `${tenantId}${SEPARATOR}${StaticDatabases.GLOBAL.name}`;
+async function uploadDirectory(bucketName, localPath, bucketPath) {
+  bucketName = sanitizeBucket(bucketName);
+  let uploads = [];
+  const files = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
+  for (let file of files) {
+    const path3 = sanitizeKey((0, import_path2.join)(bucketPath, file.name));
+    const local = (0, import_path2.join)(localPath, file.name);
+    if (file.isDirectory()) {
+      uploads.push(uploadDirectory(bucketName, local, path3));
+    } else {
+      uploads.push(
+        streamUpload({
+          bucket: bucketName,
+          filename: path3,
+          stream: import_fs3.default.createReadStream(local)
+        })
+      );
+    }
   }
+  await Promise.all(uploads);
+  return files;
 }
-function getPlatformURL() {
-  return environment_default.PLATFORM_URL;
-}
-function isMultiTenant() {
-  return !!environment_default.MULTI_TENANCY;
-}
-function isTenantIdSet() {
-  const context = Context.get();
-  return !!context?.tenantId;
-}
-function isTenancyEnabled() {
-  return environment_default.MULTI_TENANCY;
-}
-function getTenantIDFromAppID(appId) {
-  if (!appId) {
-    return void 0;
-  }
-  if (!isMultiTenant()) {
-    return DEFAULT_TENANT_ID;
+async function downloadTarballDirect(url, path3, headers = {}) {
+  path3 = sanitizeKey(path3);
+  const response = await (0, import_node_fetch2.default)(url, { headers });
+  if (!response.ok) {
+    throw new Error(`unexpected response ${response.statusText}`);
   }
-  const split = appId.split(SEPARATOR);
-  const hasDev = split[1] === "dev" /* DEV */;
-  if (hasDev && split.length === 3 || !hasDev && split.length === 2) {
-    return void 0;
+  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path3));
+}
+async function downloadTarball(url, bucketName, path3) {
+  bucketName = sanitizeBucket(bucketName);
+  path3 = sanitizeKey(path3);
+  const response = await (0, import_node_fetch2.default)(url);
+  if (!response.ok) {
+    throw new Error(`unexpected response ${response.statusText}`);
   }
-  if (hasDev) {
-    return split[2];
-  } else {
-    return split[1];
+  const tmpPath = (0, import_path2.join)(budibaseTempDir(), path3);
+  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+  if (!environment_default.isTest() && environment_default.SELF_HOSTED) {
+    await uploadDirectory(bucketName, tmpPath, path3);
   }
+  return tmpPath;
 }
-function updateContext(updates) {
-  let context;
+async function getReadStream(bucketName, path3) {
+  bucketName = sanitizeBucket(bucketName);
+  path3 = sanitizeKey(path3);
+  const client = ObjectStore(bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Key: path3
+  };
+  return client.getObject(params2).createReadStream();
+}
+async function getObjectMetadata(bucket, path3) {
+  bucket = sanitizeBucket(bucket);
+  path3 = sanitizeKey(path3);
+  const client = ObjectStore(bucket);
+  const params2 = {
+    Bucket: bucket,
+    Key: path3
+  };
   try {
-    context = Context.get();
+    return await client.headObject(params2).promise();
   } catch (err) {
-    context = {};
+    throw new Error("Unable to retrieve metadata from object");
   }
-  context = {
-    ...context,
-    ...updates
-  };
-  return context;
-}
-async function newContext(updates, task) {
-  guardMigration();
-  let context = updateContext(updates);
-  return Context.run(context, task);
-}
-async function doInAutomationContext(params2) {
-  await ensureSnippetContext();
-  return newContext(
-    {
-      tenantId: getTenantIDFromAppID(params2.appId),
-      appId: params2.appId,
-      automationId: params2.automationId
-    },
-    params2.task
-  );
 }
-async function doInContext(appId, task) {
-  const tenantId = getTenantIDFromAppID(appId);
-  return newContext(
-    {
-      tenantId,
-      appId
-    },
-    task
+function extractBucketAndPath(url) {
+  const baseUrl = url.split("?")[0];
+  const regex = new RegExp(
+    `^${SIGNED_FILE_PREFIX}/(?<bucket>[^/]+)/(?<path>.+)$`
   );
-}
-async function doInTenant(tenantId, task) {
-  if (!environment_default.MULTI_TENANCY) {
-    tenantId = tenantId || DEFAULT_TENANT_ID;
+  const match = baseUrl.match(regex);
+  if (match && match.groups) {
+    const { bucket, path: path3 } = match.groups;
+    return { bucket, path: path3 };
   }
-  const updates = tenantId ? { tenantId } : {};
-  return newContext(updates, task);
-}
-async function doInAppContext(appId, task) {
-  return _doInAppContext(appId, task);
+  return null;
 }
-async function _doInAppContext(appId, task, extraContextSettings) {
-  if (!appId) {
-    throw new Error("appId is required");
+
+// src/objectStore/cloudfront.ts
+var cfsign = __toESM(require("aws-cloudfront-sign"));
+var PRIVATE_KEY;
+function getPrivateKey() {
+  if (!environment_default.CLOUDFRONT_PRIVATE_KEY_64) {
+    throw new Error("CLOUDFRONT_PRIVATE_KEY_64 is not set");
   }
-  const tenantId = getTenantIDFromAppID(appId);
-  const updates = { appId, ...extraContextSettings };
-  if (tenantId) {
-    updates.tenantId = tenantId;
+  if (PRIVATE_KEY) {
+    return PRIVATE_KEY;
   }
-  return newContext(updates, task);
+  PRIVATE_KEY = Buffer.from(environment_default.CLOUDFRONT_PRIVATE_KEY_64, "base64").toString(
+    "utf-8"
+  );
+  return PRIVATE_KEY;
 }
-async function doInIdentityContext(identity, task) {
-  if (!identity) {
-    throw new Error("identity is required");
-  }
-  const context = {
-    identity
+var getCloudfrontSignParams = () => {
+  return {
+    keypairId: environment_default.CLOUDFRONT_PUBLIC_KEY_ID,
+    privateKeyString: getPrivateKey(),
+    expireTime: (/* @__PURE__ */ new Date()).getTime() + 1e3 * 60 * 60 * 24
+    // 1 day
   };
-  if (identity.tenantId) {
-    context.tenantId = identity.tenantId;
+};
+var getPresignedUrl2 = (s3Key) => {
+  const url = getUrl(s3Key);
+  return cfsign.getSignedUrl(url, getCloudfrontSignParams());
+};
+var getUrl = (s3Key) => {
+  let prefix = "/";
+  if (s3Key.startsWith("/")) {
+    prefix = "";
   }
-  return newContext(context, task);
+  return `${environment_default.CLOUDFRONT_CDN}${prefix}${s3Key}`;
+};
+
+// src/objectStore/buckets/app.ts
+var import_querystring = __toESM(require("querystring"));
+function clientLibraryPath(appId) {
+  return `${sanitizeKey(appId)}/budibase-client.js`;
 }
-function guardMigration() {
-  const context = Context.get();
-  if (context?.isMigrating) {
-    throw new Error(
-      "The context cannot be changed, a migration is currently running"
-    );
+function clientLibraryCDNUrl(appId, version) {
+  let file = clientLibraryPath(appId);
+  if (environment_default.CLOUDFRONT_CDN) {
+    if (version) {
+      file += `?v=${version}`;
+    }
+    return getUrl(file);
+  } else {
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
   }
 }
-async function doInAppMigrationContext(appId, task) {
-  return _doInAppContext(appId, task, {
-    isMigrating: true
-  });
-}
-function getIdentity() {
+function clientLibraryUrl(appId, version) {
+  let tenantId, qsParams;
   try {
-    const context = Context.get();
-    return context?.identity;
-  } catch (e) {
-  }
-}
-function getTenantId() {
-  if (!isMultiTenant()) {
-    return DEFAULT_TENANT_ID;
+    tenantId = getTenantId();
+  } finally {
+    qsParams = {
+      appId,
+      version
+    };
   }
-  const context = Context.get();
-  const tenantId = context?.tenantId;
-  if (!tenantId) {
-    throw new Error("Tenant id not found");
+  if (tenantId && tenantId !== DEFAULT_TENANT_ID) {
+    qsParams.tenantId = tenantId;
   }
-  return tenantId;
-}
-function getAutomationId() {
-  const context = Context.get();
-  return context?.automationId;
+  return `/api/assets/client?${import_querystring.default.encode(qsParams)}`;
 }
-function getAppId() {
-  const context = Context.get();
-  const foundId = context?.appId;
-  if (!foundId && environment_default.isTest() && TEST_APP_ID) {
-    return TEST_APP_ID;
+function getAppFileUrl(s3Key) {
+  if (environment_default.CLOUDFRONT_CDN) {
+    return getPresignedUrl2(s3Key);
   } else {
-    return foundId;
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
   }
 }
-var getProdAppId = () => {
-  const appId = getAppId();
-  if (!appId) {
-    throw new Error("Could not get appId");
-  }
-  return getProdAppID2(appId);
+
+// src/objectStore/buckets/global.ts
+var getGlobalFileUrl = (type, name, etag) => {
+  let file = getGlobalFileS3Key(type, name);
+  if (environment_default.CLOUDFRONT_CDN) {
+    if (etag) {
+      file = `${file}?etag=${etag}`;
+    }
+    return getPresignedUrl2(file);
+  } else {
+    return getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
+  }
 };
-function doInEnvironmentContext(values2, task) {
-  if (!values2) {
-    throw new Error("Must supply environment variables.");
+var getGlobalFileS3Key = (type, name) => {
+  let file = `${type}/${name}`;
+  if (environment_default.MULTI_TENANCY) {
+    const tenantId = getTenantId();
+    file = `${tenantId}/${file}`;
   }
-  const updates = {
-    environmentVariables: values2
-  };
-  return newContext(updates, task);
+  return file;
+};
+
+// src/objectStore/buckets/plugins.ts
+function enrichPluginURLs(plugins) {
+  if (!plugins || !plugins.length) {
+    return [];
+  }
+  return plugins.map((plugin) => {
+    const jsUrl = getPluginJSUrl(plugin);
+    const iconUrl = getPluginIconUrl(plugin);
+    return { ...plugin, jsUrl, iconUrl };
+  });
 }
-function doInScimContext(task) {
-  const updates = {
-    isScim: true
-  };
-  return newContext(updates, task);
+function getPluginJSUrl(plugin) {
+  const s3Key = getPluginJSKey(plugin);
+  return getPluginUrl(s3Key);
 }
-async function ensureSnippetContext(enabled2 = !environment_default.isTest()) {
-  const ctx = getCurrentContext();
-  if (!ctx || ctx.snippets) {
+function getPluginIconUrl(plugin) {
+  const s3Key = getPluginIconKey(plugin);
+  if (!s3Key) {
     return;
   }
-  let snippets;
-  const db = getAppDB();
-  if (db && enabled2) {
-    const app = await db.get("app_metadata" /* APP_METADATA */);
-    snippets = app.snippets;
-  }
-  ctx.snippets = snippets || [];
+  return getPluginUrl(s3Key);
 }
-function getEnvironmentVariables() {
-  const context = Context.get();
-  if (!context.environmentVariables) {
-    return null;
+function getPluginUrl(s3Key) {
+  if (environment_default.CLOUDFRONT_CDN) {
+    return getPresignedUrl2(s3Key);
   } else {
-    return context.environmentVariables;
+    return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
   }
 }
-function getGlobalDB() {
-  const context = Context.get();
-  if (!context || environment_default.MULTI_TENANCY && !context.tenantId) {
-    throw new Error("Global DB not found");
-  }
-  return getDB(baseGlobalDBName(context?.tenantId));
+function getPluginJSKey(plugin) {
+  return getPluginS3Key(plugin, "plugin.min.js");
 }
-function getAuditLogsDB() {
-  if (!getTenantId()) {
-    throw new Error("No tenant ID found - cannot open audit log DB");
+function getPluginIconKey(plugin) {
+  const iconFileName = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
+  if (!iconFileName) {
+    return;
   }
-  return getDB(getAuditLogDBName());
+  return getPluginS3Key(plugin, iconFileName);
 }
-function getAppDB(opts) {
-  const appId = getAppId();
-  if (!appId) {
-    throw new Error("Unable to retrieve app DB - no app ID.");
-  }
-  return getDB(appId, opts);
+function getPluginS3Key(plugin, fileName) {
+  const s3Key = getPluginS3Dir(plugin.name);
+  return `${s3Key}/${fileName}`;
 }
-function getProdAppDB(opts) {
-  const appId = getAppId();
-  if (!appId) {
-    throw new Error("Unable to retrieve prod DB - no app ID.");
+function getPluginS3Dir(pluginName) {
+  let s3Key = `${pluginName}`;
+  if (environment_default.MULTI_TENANCY) {
+    const tenantId = getTenantId();
+    s3Key = `${tenantId}/${s3Key}`;
   }
-  return getDB(getProdAppID2(appId), opts);
-}
-function getDevAppDB(opts) {
-  const appId = getAppId();
-  if (!appId) {
-    throw new Error("Unable to retrieve dev DB - no app ID.");
+  if (environment_default.CLOUDFRONT_CDN) {
+    s3Key = `plugins/${s3Key}`;
   }
-  return getDB(getDevelopmentAppID(appId), opts);
+  return s3Key;
 }
-function isScim() {
-  const context = Context.get();
-  const scimCall = context?.isScim;
-  return !!scimCall;
+
+// src/logging/system.ts
+var logsFileName = `budibase.log`;
+var budibaseLogsHistoryFileName = "budibase-logs-history.txt";
+var logsPath = import_path3.default.join(budibaseTempDir(), "systemlogs");
+function getFullPath(fileName) {
+  return import_path3.default.join(logsPath, fileName);
 }
-function getCurrentContext() {
-  try {
-    return Context.get();
-  } catch (e) {
+function getSingleFileMaxSizeInfo(totalMaxSize) {
+  const regex = /(\d+)([A-Za-z])/;
+  const match = totalMaxSize?.match(regex);
+  if (!match) {
+    console.warn(`totalMaxSize does not have a valid value`, {
+      totalMaxSize
+    });
     return void 0;
   }
-}
-
-// src/redis/init.ts
-var init_exports = {};
-__export(init_exports, {
-  getAppClient: () => getAppClient,
-  getCacheClient: () => getCacheClient,
-  getDocWritethroughClient: () => getDocWritethroughClient,
-  getInviteClient: () => getInviteClient,
-  getLockClient: () => getLockClient,
-  getPasswordResetClient: () => getPasswordResetClient,
-  getSessionClient: () => getSessionClient,
-  getSocketClient: () => getSocketClient,
-  getUserClient: () => getUserClient,
-  getWritethroughClient: () => getWritethroughClient,
-  init: () => init3,
-  shutdown: () => shutdown
-});
-
-// src/redis/redis.ts
-var import_ioredis = __toESM(require("ioredis"));
-
-// src/redis/utils.ts
-var utils_exports2 = {};
-__export(utils_exports2, {
-  Databases: () => Databases,
-  SEPARATOR: () => SEPARATOR2,
-  SelectableDatabase: () => SelectableDatabase,
-  addDbPrefix: () => addDbPrefix,
-  getRedisConnectionDetails: () => getRedisConnectionDetails,
-  getRedisOptions: () => getRedisOptions,
-  removeDbPrefix: () => removeDbPrefix
-});
-var SLOT_REFRESH_MS = 2e3;
-var CONNECT_TIMEOUT_MS = 1e4;
-var SEPARATOR2 = "-";
-var Databases = /* @__PURE__ */ ((Databases2) => {
-  Databases2["PW_RESETS"] = "pwReset";
-  Databases2["VERIFICATIONS"] = "verification";
-  Databases2["INVITATIONS"] = "invitation";
-  Databases2["DEV_LOCKS"] = "devLocks";
-  Databases2["DEBOUNCE"] = "debounce";
-  Databases2["SESSIONS"] = "session";
-  Databases2["USER_CACHE"] = "users";
-  Databases2["FLAGS"] = "flags";
-  Databases2["APP_METADATA"] = "appMetadata";
-  Databases2["QUERY_VARS"] = "queryVars";
-  Databases2["LICENSES"] = "license";
-  Databases2["GENERIC_CACHE"] = "data_cache";
-  Databases2["WRITE_THROUGH"] = "writeThrough";
-  Databases2["LOCKS"] = "locks";
-  Databases2["SOCKET_IO"] = "socket_io";
-  Databases2["BPM_EVENTS"] = "bpmEvents";
-  Databases2["DOC_WRITE_THROUGH"] = "docWriteThrough";
-  return Databases2;
-})(Databases || {});
-var SelectableDatabase = /* @__PURE__ */ ((SelectableDatabase2) => {
-  SelectableDatabase2[SelectableDatabase2["DEFAULT"] = 0] = "DEFAULT";
-  SelectableDatabase2[SelectableDatabase2["SOCKET_IO"] = 1] = "SOCKET_IO";
-  SelectableDatabase2[SelectableDatabase2["RATE_LIMITING"] = 2] = "RATE_LIMITING";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_2"] = 3] = "UNUSED_2";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_3"] = 4] = "UNUSED_3";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_4"] = 5] = "UNUSED_4";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_5"] = 6] = "UNUSED_5";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_6"] = 7] = "UNUSED_6";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_7"] = 8] = "UNUSED_7";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_8"] = 9] = "UNUSED_8";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_9"] = 10] = "UNUSED_9";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_10"] = 11] = "UNUSED_10";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_11"] = 12] = "UNUSED_11";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_12"] = 13] = "UNUSED_12";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_13"] = 14] = "UNUSED_13";
-  SelectableDatabase2[SelectableDatabase2["UNUSED_14"] = 15] = "UNUSED_14";
-  return SelectableDatabase2;
-})(SelectableDatabase || {});
-function getRedisConnectionDetails() {
-  let password = environment_default.REDIS_PASSWORD;
-  let url = environment_default.REDIS_URL.split("//");
-  url = url.length > 1 ? url[1] : url[0];
-  url = url.split("@");
-  if (url.length > 1) {
-    password = url[0].split(":")[1];
-    url = url[1];
-  } else {
-    url = url[0];
+  const size = +match[1];
+  const unit = match[2];
+  if (size === 1) {
+    switch (unit) {
+      case "B":
+        return { size: `${size}B`, totalHistoryFiles: 1 };
+      case "K":
+        return { size: `${size * 1e3 / 2}B`, totalHistoryFiles: 1 };
+      case "M":
+        return { size: `${size * 1e3 / 2}K`, totalHistoryFiles: 1 };
+      case "G":
+        return { size: `${size * 1e3 / 2}M`, totalHistoryFiles: 1 };
+      default:
+        return void 0;
+    }
   }
-  const [host, port] = url.split(":");
-  const portNumber = parseInt(port);
-  return {
-    host,
-    password,
-    // assume default port for redis if invalid found
-    port: isNaN(portNumber) ? 6379 : portNumber
-  };
+  if (size % 2 === 0) {
+    return { size: `${size / 2}${unit}`, totalHistoryFiles: 1 };
+  }
+  return { size: `1${unit}`, totalHistoryFiles: size - 1 };
 }
-function getRedisOptions() {
-  const { host, password, port } = getRedisConnectionDetails();
-  let redisOpts = {
-    connectTimeout: CONNECT_TIMEOUT_MS,
-    port,
-    host,
-    password
-  };
-  let opts = redisOpts;
-  if (environment_default.REDIS_CLUSTERED) {
-    opts = {
-      connectTimeout: CONNECT_TIMEOUT_MS,
-      redisOptions: {
-        ...redisOpts,
-        tls: {}
-      },
-      slotsRefreshTimeout: SLOT_REFRESH_MS,
-      dnsLookup: (address, callback) => callback(null, address)
-    };
-  }
-  return opts;
+function localFileDestination() {
+  const fileInfo = getSingleFileMaxSizeInfo(environment_default.ROLLING_LOG_MAX_SIZE);
+  const outFile = rfs.createStream(logsFileName, {
+    // As we have a rolling size, we want to half the max size
+    size: fileInfo?.size,
+    path: logsPath,
+    maxFiles: fileInfo?.totalHistoryFiles || 1,
+    immutable: true,
+    history: budibaseLogsHistoryFileName,
+    initialRotation: false
+  });
+  return outFile;
 }
-function addDbPrefix(db, key) {
-  if (key.includes(db)) {
-    return key;
+function getLogReadStream() {
+  const streams = [];
+  const historyFile = getFullPath(budibaseLogsHistoryFileName);
+  if (import_fs4.default.existsSync(historyFile)) {
+    const fileContent = import_fs4.default.readFileSync(historyFile, "utf-8");
+    const historyFiles = fileContent.split("\n");
+    for (const historyFile2 of historyFiles.filter((x) => x)) {
+      streams.push(import_fs4.default.readFileSync(historyFile2));
+    }
   }
-  return `${db}${SEPARATOR2}${key}`;
+  streams.push(import_fs4.default.readFileSync(getFullPath(logsFileName)));
+  const combinedContent = Buffer.concat(streams);
+  return combinedContent;
 }
-function removeDbPrefix(key) {
-  let parts = key.split(SEPARATOR2);
-  if (parts.length >= 2) {
-    parts.shift();
-    return parts.join(SEPARATOR2);
-  } else {
-    return parts[0];
+
+// src/logging/pino/logger.ts
+function isPlainObject(obj) {
+  return typeof obj === "object" && obj !== null && !(obj instanceof Error);
+}
+function isError(obj) {
+  return obj instanceof Error;
+}
+function isMessage(obj) {
+  return typeof obj === "string";
+}
+var pinoInstance;
+if (!environment_default.DISABLE_PINO_LOGGER) {
+  const level = environment_default.LOG_LEVEL;
+  const pinoOptions = {
+    level,
+    formatters: {
+      level: (level2) => {
+        return { level: level2.toUpperCase() };
+      },
+      bindings: () => {
+        if (environment_default.SELF_HOSTED) {
+          return {
+            service: environment_default.SERVICE_NAME
+          };
+        } else {
+          return {};
+        }
+      }
+    },
+    timestamp: () => `,"timestamp":"${new Date(Date.now()).toISOString()}"`
+  };
+  const destinations = [];
+  destinations.push(
+    environment_default.isDev() ? {
+      stream: (0, import_pino_pretty.default)({ singleLine: true }),
+      level
+    } : { stream: process.stdout, level }
+  );
+  if (environment_default.SELF_HOSTED) {
+    destinations.push({
+      stream: localFileDestination(),
+      level
+    });
   }
+  pinoInstance = destinations.length ? (0, import_pino.default)(pinoOptions, import_pino.default.multistream(destinations)) : (0, import_pino.default)(pinoOptions);
+  const getLogParams2 = (args) => {
+    let error = void 0;
+    let objects = [];
+    let message = "";
+    args.forEach((arg) => {
+      if (isMessage(arg)) {
+        message = `${message} ${arg}`.trimStart();
+      }
+      if (isPlainObject(arg)) {
+        objects.push(arg);
+      }
+      if (isError(arg)) {
+        error = arg;
+      }
+    });
+    const identity = getIdentity3();
+    let contextObject = {};
+    contextObject = {
+      tenantId: getTenantId2(),
+      appId: getAppId2(),
+      automationId: getAutomationId2(),
+      identityId: identity?._id,
+      identityType: identity?.type,
+      correlationId: getId()
+    };
+    const span = import_dd_trace2.default.scope().active();
+    if (span) {
+      import_dd_trace2.default.inject(span.context(), import_ext.formats.LOG, contextObject);
+    }
+    const mergingObject = {
+      err: error,
+      pid: process.pid,
+      ...contextObject
+    };
+    if (objects.length) {
+      const data = {};
+      let dataIndex = 0;
+      for (let i = 0; i < objects.length; i++) {
+        const object = objects[i];
+        const logKey = object._logKey;
+        if (logKey) {
+          delete object._logKey;
+          mergingObject[logKey] = object;
+        } else {
+          data[dataIndex] = object;
+          dataIndex++;
+        }
+      }
+      if (Object.keys(data).length) {
+        mergingObject.data = data;
+      }
+    }
+    return [mergingObject, message];
+  };
+  console.log = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    pinoInstance?.info(obj, msg);
+  };
+  console.info = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    pinoInstance?.info(obj, msg);
+  };
+  console.warn = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    pinoInstance?.warn(obj, msg);
+  };
+  console.error = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    pinoInstance?.error(obj, msg);
+  };
+  console.trace = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    if (!obj.err) {
+      obj.err = new Error();
+    }
+    pinoInstance?.trace(obj, msg);
+  };
+  console.debug = (...arg) => {
+    const [obj, msg] = getLogParams2(arg);
+    pinoInstance?.debug(obj, msg);
+  };
+  const getTenantId2 = () => {
+    let tenantId;
+    try {
+      tenantId = getTenantId();
+    } catch (e) {
+    }
+    return tenantId;
+  };
+  const getAppId2 = () => {
+    let appId;
+    try {
+      appId = getAppId();
+    } catch (e) {
+    }
+    return appId;
+  };
+  const getAutomationId2 = () => {
+    let appId;
+    try {
+      appId = getAutomationId();
+    } catch (e) {
+    }
+    return appId;
+  };
+  const getIdentity3 = () => {
+    let identity;
+    try {
+      identity = getIdentity();
+    } catch (e) {
+    }
+    return identity;
+  };
 }
+var logger = pinoInstance;
 
-// src/logging/index.ts
-var logging_exports = {};
-__export(logging_exports, {
-  correlation: () => correlation_exports,
-  logAlert: () => logAlert,
-  logAlertWithInfo: () => logAlertWithInfo,
-  logWarn: () => logWarn,
-  logger: () => logger,
-  system: () => system_exports
-});
-
-// src/logging/correlation/correlation.ts
-var correlation_exports = {};
-__export(correlation_exports, {
-  getId: () => getId,
-  setHeader: () => setHeader
-});
-var correlator = require("correlation-id");
-var setHeader = (headers) => {
-  const correlationId = correlator.getId();
-  if (!correlationId) {
+// src/logging/alerts.ts
+var NonErrors = ["AccountError"];
+function isSuppressed(e) {
+  return e && e["suppressAlert"];
+}
+function logAlert(message, e) {
+  if (e && NonErrors.includes(e.name) && isSuppressed(e)) {
     return;
   }
-  headers["x-budibase-correlation-id" /* CORRELATION_ID */] = correlationId;
-};
-function getId() {
-  return correlator.getId();
+  console.error(`bb-alert: ${message}`, e);
+}
+function logAlertWithInfo(message, db, id, error) {
+  message = `${message} - db: ${db} - doc: ${id} - error: `;
+  logAlert(message, error);
+}
+function logWarn(message, e) {
+  console.warn(`bb-warn: ${message}`, e);
 }
 
-// src/logging/pino/logger.ts
-var import_pino = __toESM(require("pino"));
-var import_pino_pretty = __toESM(require("pino-pretty"));
-var import_dd_trace2 = __toESM(require("dd-trace"));
-var import_ext = require("dd-trace/ext");
-
-// src/logging/system.ts
-var system_exports = {};
-__export(system_exports, {
-  getLogReadStream: () => getLogReadStream,
-  getSingleFileMaxSizeInfo: () => getSingleFileMaxSizeInfo,
-  localFileDestination: () => localFileDestination
+// src/timers/index.ts
+var timers_exports = {};
+__export(timers_exports, {
+  cleanup: () => cleanup,
+  clear: () => clear,
+  set: () => set
 });
-var import_fs4 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var rfs = __toESM(require("rotating-file-stream"));
 
-// src/objectStore/index.ts
-var objectStore_exports2 = {};
-__export(objectStore_exports2, {
-  ObjectStore: () => ObjectStore,
-  ObjectStoreBuckets: () => ObjectStoreBuckets,
-  SIGNED_FILE_PREFIX: () => SIGNED_FILE_PREFIX,
-  bucketTTLConfig: () => bucketTTLConfig,
-  budibaseTempDir: () => budibaseTempDir,
-  clientLibraryCDNUrl: () => clientLibraryCDNUrl,
-  clientLibraryPath: () => clientLibraryPath,
-  clientLibraryUrl: () => clientLibraryUrl,
-  createBucketIfNotExists: () => createBucketIfNotExists,
-  deleteFile: () => deleteFile,
-  deleteFiles: () => deleteFiles,
-  deleteFolder: () => deleteFolder,
-  downloadTarball: () => downloadTarball,
-  downloadTarballDirect: () => downloadTarballDirect,
-  enrichPluginURLs: () => enrichPluginURLs,
-  extractBucketAndPath: () => extractBucketAndPath,
-  getAppFileUrl: () => getAppFileUrl,
-  getGlobalFileS3Key: () => getGlobalFileS3Key,
-  getGlobalFileUrl: () => getGlobalFileUrl,
-  getObjectMetadata: () => getObjectMetadata,
-  getPluginIconKey: () => getPluginIconKey,
-  getPluginJSKey: () => getPluginJSKey,
-  getPluginS3Dir: () => getPluginS3Dir,
-  getPresignedUrl: () => getPresignedUrl,
-  getReadStream: () => getReadStream,
-  listAllObjects: () => listAllObjects,
-  processAutomationAttachment: () => processAutomationAttachment,
-  processObjectStoreAttachment: () => processObjectStoreAttachment,
-  retrieve: () => retrieve,
-  retrieveDirectory: () => retrieveDirectory,
-  retrieveToTmp: () => retrieveToTmp,
-  sanitizeBucket: () => sanitizeBucket,
-  sanitizeKey: () => sanitizeKey,
-  streamUpload: () => streamUpload,
-  upload: () => upload,
-  uploadDirectory: () => uploadDirectory
+// src/timers/timers.ts
+var intervals = [];
+function set(callback, period) {
+  const interval = setInterval(callback, period);
+  intervals.push(interval);
+  return interval;
+}
+function clear(interval) {
+  const idx = intervals.indexOf(interval);
+  if (idx !== -1) {
+    intervals.splice(idx, 1);
+  }
+  clearInterval(interval);
+}
+function cleanup() {
+  for (let interval of intervals) {
+    clearInterval(interval);
+  }
+  intervals = [];
+}
+
+// src/redis/redis.ts
+var MockRedis;
+if (environment_default.MOCK_REDIS) {
+  try {
+    MockRedis = require("ioredis-mock");
+  } catch (err) {
+    console.log("Mock redis unavailable");
+  }
+}
+var RETRY_PERIOD_MS = 2e3;
+var STARTUP_TIMEOUT_MS = 5e3;
+var CLUSTERED = environment_default.REDIS_CLUSTERED;
+var DEFAULT_SELECT_DB = 0 /* DEFAULT */;
+var CLOSED = false;
+var CLIENTS = {};
+var CONNECTED = false;
+if (environment_default.MOCK_REDIS) {
+  CONNECTED = true;
+}
+function pickClient(selectDb) {
+  return CLIENTS[selectDb];
+}
+function connectionError(timeout2, err) {
+  if (CLOSED) {
+    return;
+  }
+  CLOSED = true;
+  clearTimeout(timeout2);
+  CONNECTED = false;
+  logAlert("Redis connection failed", err);
+  setTimeout(() => {
+    init2();
+  }, RETRY_PERIOD_MS);
+}
+function init2(selectDb = DEFAULT_SELECT_DB) {
+  const RedisCore = environment_default.MOCK_REDIS && MockRedis ? MockRedis : import_ioredis.default;
+  let timeout2;
+  CLOSED = false;
+  let client = pickClient(selectDb);
+  if (client && CONNECTED) {
+    return;
+  }
+  if (environment_default.MOCK_REDIS) {
+    CLIENTS[selectDb] = new RedisCore(getRedisOptions());
+  }
+  timeout2 = setTimeout(() => {
+    if (!CONNECTED) {
+      connectionError(timeout2, "Did not successfully connect in timeout");
+    }
+  }, STARTUP_TIMEOUT_MS);
+  if (client) {
+    client.disconnect();
+  }
+  const { host, port } = getRedisConnectionDetails();
+  const opts = getRedisOptions();
+  if (CLUSTERED) {
+    client = new RedisCore.Cluster([{ host, port }], opts);
+  } else {
+    client = new RedisCore(opts);
+  }
+  client.on("end", (err) => {
+    if (environment_default.isTest()) {
+      return;
+    }
+    connectionError(timeout2, err);
+  });
+  client.on("error", (err) => {
+    connectionError(timeout2, err);
+  });
+  client.on("connect", () => {
+    console.log(`Connected to Redis DB: ${selectDb}`);
+    clearTimeout(timeout2);
+    CONNECTED = true;
+  });
+  CLIENTS[selectDb] = client;
+}
+function waitForConnection(selectDb = DEFAULT_SELECT_DB) {
+  return new Promise((resolve) => {
+    if (pickClient(selectDb) == null) {
+      init2();
+    } else if (CONNECTED) {
+      resolve("");
+      return;
+    }
+    const interval = set(() => {
+      if (CONNECTED) {
+        clear(interval);
+        resolve("");
+      }
+    }, 500);
+  });
+}
+function promisifyStream(stream3, client) {
+  return new Promise((resolve, reject) => {
+    const outputKeys = /* @__PURE__ */ new Set();
+    stream3.on("data", (keys2) => {
+      keys2.forEach((key) => {
+        outputKeys.add(key);
+      });
+    });
+    stream3.on("error", (err) => {
+      reject(err);
+    });
+    stream3.on("end", async () => {
+      const keysArray = Array.from(outputKeys);
+      try {
+        let getPromises = [];
+        for (let key of keysArray) {
+          getPromises.push(client.get(key));
+        }
+        const jsonArray = await Promise.all(getPromises);
+        resolve(
+          keysArray.map((key) => ({
+            key: removeDbPrefix(key),
+            value: JSON.parse(jsonArray.shift())
+          }))
+        );
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+var RedisWrapper = class {
+  constructor(db, selectDb = null) {
+    this._db = db;
+    this._select = selectDb || DEFAULT_SELECT_DB;
+  }
+  getClient() {
+    return pickClient(this._select);
+  }
+  async init() {
+    CLOSED = false;
+    init2(this._select);
+    await waitForConnection(this._select);
+    if (this._select && !environment_default.isTest()) {
+      this.getClient().select(this._select);
+    }
+    return this;
+  }
+  async finish() {
+    CLOSED = true;
+    this.getClient().disconnect();
+  }
+  async scan(key = "") {
+    const db = this._db;
+    key = `${db}${SEPARATOR2}${key}`;
+    let stream3;
+    if (CLUSTERED) {
+      let node = this.getClient().nodes("master");
+      stream3 = node[0].scanStream({ match: key + "*", count: 100 });
+    } else {
+      stream3 = this.getClient().scanStream({
+        match: key + "*",
+        count: 100
+      });
+    }
+    return promisifyStream(stream3, this.getClient());
+  }
+  async keys(pattern) {
+    const db = this._db;
+    return this.getClient().keys(addDbPrefix(db, pattern));
+  }
+  async exists(key) {
+    const db = this._db;
+    return await this.getClient().exists(addDbPrefix(db, key));
+  }
+  async get(key) {
+    const db = this._db;
+    const response = await this.getClient().get(addDbPrefix(db, key));
+    if (response != null && response.key) {
+      response.key = key;
+    }
+    try {
+      return JSON.parse(response);
+    } catch (err) {
+      return response;
+    }
+  }
+  async bulkGet(keys2) {
+    const db = 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)) {
+      let final = {};
+      let count = 0;
+      for (let result of response) {
+        if (result) {
+          let parsed;
+          try {
+            parsed = JSON.parse(result);
+          } catch (err) {
+            parsed = result;
+          }
+          final[keys2[count]] = parsed;
+        }
+        count++;
+      }
+      return final;
+    } else {
+      throw new Error(`Invalid response: ${response}`);
+    }
+  }
+  async store(key, value, expirySeconds = null) {
+    const db = this._db;
+    if (typeof value === "object") {
+      value = JSON.stringify(value);
+    }
+    const prefixedKey = addDbPrefix(db, key);
+    await this.getClient().set(prefixedKey, value);
+    if (expirySeconds) {
+      await this.getClient().expire(prefixedKey, expirySeconds);
+    }
+  }
+  async bulkStore(data, expirySeconds = null) {
+    const client = this.getClient();
+    const dataToStore = Object.entries(data).reduce((acc, [key, value]) => {
+      acc[addDbPrefix(this._db, key)] = typeof value === "object" ? JSON.stringify(value) : value;
+      return acc;
+    }, {});
+    const pipeline = client.pipeline();
+    pipeline.mset(dataToStore);
+    if (expirySeconds !== null) {
+      for (const key of Object.keys(dataToStore)) {
+        pipeline.expire(key, expirySeconds);
+      }
+    }
+    await pipeline.exec();
+  }
+  async getTTL(key) {
+    const db = this._db;
+    const prefixedKey = addDbPrefix(db, key);
+    return this.getClient().ttl(prefixedKey);
+  }
+  async setExpiry(key, expirySeconds) {
+    const db = this._db;
+    const prefixedKey = addDbPrefix(db, key);
+    await this.getClient().expire(prefixedKey, expirySeconds);
+  }
+  async delete(key) {
+    const db = this._db;
+    await this.getClient().del(addDbPrefix(db, key));
+  }
+  async bulkDelete(keys2) {
+    const db = this._db;
+    await this.getClient().del(keys2.map((key) => addDbPrefix(db, key)));
+  }
+  async clear() {
+    let items = await this.scan();
+    await Promise.all(items.map((obj) => this.delete(obj.key)));
+  }
+  async increment(key) {
+    const result = await this.getClient().incr(addDbPrefix(this._db, key));
+    if (isNaN(result)) {
+      throw new Error(`Redis ${key} does not contain a number`);
+    }
+    return result;
+  }
+  async deleteIfValue(key, value) {
+    const client = this.getClient();
+    const luaScript = `
+      if redis.call('GET', KEYS[1]) == ARGV[1] then
+        redis.call('DEL', KEYS[1])
+      end
+      `;
+    await client.eval(luaScript, 1, addDbPrefix(this._db, key), value);
+  }
+};
+var redis_default = RedisWrapper;
+
+// src/redis/init.ts
+var userClient;
+var sessionClient;
+var appClient;
+var cacheClient;
+var writethroughClient;
+var lockClient;
+var socketClient;
+var inviteClient;
+var passwordResetClient;
+var docWritethroughClient;
+async function init3() {
+  userClient = await new redis_default("users" /* USER_CACHE */).init();
+  sessionClient = await new redis_default("session" /* SESSIONS */).init();
+  appClient = await new redis_default("appMetadata" /* APP_METADATA */).init();
+  cacheClient = await new redis_default("data_cache" /* GENERIC_CACHE */).init();
+  lockClient = await new redis_default("locks" /* LOCKS */).init();
+  writethroughClient = await new redis_default("writeThrough" /* WRITE_THROUGH */).init();
+  inviteClient = await new redis_default("invitation" /* INVITATIONS */).init();
+  passwordResetClient = await new redis_default("pwReset" /* PW_RESETS */).init();
+  socketClient = await new redis_default(
+    "socket_io" /* SOCKET_IO */,
+    1 /* SOCKET_IO */
+  ).init();
+  docWritethroughClient = await new redis_default(
+    "docWriteThrough" /* DOC_WRITE_THROUGH */
+  ).init();
+}
+async function shutdown() {
+  if (userClient)
+    await userClient.finish();
+  if (sessionClient)
+    await sessionClient.finish();
+  if (appClient)
+    await appClient.finish();
+  if (cacheClient)
+    await cacheClient.finish();
+  if (writethroughClient)
+    await writethroughClient.finish();
+  if (lockClient)
+    await lockClient.finish();
+  if (inviteClient)
+    await inviteClient.finish();
+  if (passwordResetClient)
+    await passwordResetClient.finish();
+  if (socketClient)
+    await socketClient.finish();
+  if (docWritethroughClient)
+    await docWritethroughClient.finish();
+}
+process.on("exit", async () => {
+  await shutdown();
 });
-
-// src/objectStore/objectStore.ts
-var import_aws_sdk = __toESM(require("aws-sdk"));
-var import_stream2 = __toESM(require("stream"));
-var import_node_fetch3 = __toESM(require("node-fetch"));
-var import_tar_fs = __toESM(require("tar-fs"));
-var import_zlib = __toESM(require("zlib"));
-var import_util = require("util");
-var import_path2 = require("path");
-var import_fs3 = __toESM(require("fs"));
-
-// src/objectStore/utils.ts
-var import_path = __toESM(require("path"));
-var import_os = require("os");
-var import_fs2 = __toESM(require("fs"));
-var import_stream = __toESM(require("stream"));
-var ObjectStoreBuckets = {
-  BACKUPS: environment_default.BACKUPS_BUCKET_NAME,
-  APPS: environment_default.APPS_BUCKET_NAME,
-  TEMPLATES: environment_default.TEMPLATES_BUCKET_NAME,
-  GLOBAL: environment_default.GLOBAL_BUCKET_NAME,
-  PLUGINS: environment_default.PLUGIN_BUCKET_NAME,
-  TEMP: environment_default.TEMP_BUCKET_NAME
-};
-var bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
-try {
-  import_fs2.default.mkdirSync(bbTmp);
-} catch (e) {
-  if (e.code !== "EEXIST") {
-    throw e;
+async function getUserClient() {
+  if (!userClient) {
+    await init3();
   }
+  return userClient;
 }
-function budibaseTempDir() {
-  return bbTmp;
+async function getSessionClient() {
+  if (!sessionClient) {
+    await init3();
+  }
+  return sessionClient;
 }
-var bucketTTLConfig = (bucketName, days) => {
-  const lifecycleRule = {
-    ID: `${bucketName}-ExpireAfter${days}days`,
-    Prefix: "",
-    Status: "Enabled",
-    Expiration: {
-      Days: days
-    }
-  };
-  const lifecycleConfiguration = {
-    Rules: [lifecycleRule]
-  };
-  return {
-    Bucket: bucketName,
-    LifecycleConfiguration: lifecycleConfiguration
-  };
-};
-async function processUrlAttachment(attachment) {
-  const response = await fetch(attachment.url);
-  if (!response.ok || !response.body) {
-    throw new Error(`Unexpected response ${response.statusText}`);
+async function getAppClient() {
+  if (!appClient) {
+    await init3();
   }
-  const fallbackFilename = import_path.default.basename(new URL(attachment.url).pathname);
-  if (!response.body) {
-    throw new Error("No response received for attachment");
+  return appClient;
+}
+async function getCacheClient() {
+  if (!cacheClient) {
+    await init3();
   }
-  return {
-    filename: attachment.filename || fallbackFilename,
-    content: import_stream.default.Readable.fromWeb(response.body)
-  };
+  return cacheClient;
 }
-async function processObjectStoreAttachment(attachment) {
-  const result = extractBucketAndPath(attachment.url);
-  if (result === null) {
-    throw new Error("Invalid signed URL");
+async function getWritethroughClient() {
+  if (!writethroughClient) {
+    await init3();
   }
-  const { bucket, path: objectPath } = result;
-  const readStream = await getReadStream(bucket, objectPath);
-  const fallbackFilename = import_path.default.basename(objectPath);
-  return {
-    bucket,
-    path: objectPath,
-    filename: attachment.filename || fallbackFilename,
-    content: readStream
-  };
+  return writethroughClient;
 }
-async function processAutomationAttachment(attachment) {
-  const isFullyFormedUrl = attachment.url?.startsWith("http://") || attachment.url?.startsWith("https://");
-  if (isFullyFormedUrl) {
-    return await processUrlAttachment(attachment);
-  } else {
-    return await processObjectStoreAttachment(attachment);
+async function getLockClient() {
+  if (!lockClient) {
+    await init3();
+  }
+  return lockClient;
+}
+async function getSocketClient() {
+  if (!socketClient) {
+    await init3();
   }
+  return socketClient;
+}
+async function getInviteClient() {
+  if (!inviteClient) {
+    await init3();
+  }
+  return inviteClient;
+}
+async function getPasswordResetClient() {
+  if (!passwordResetClient) {
+    await init3();
+  }
+  return passwordResetClient;
+}
+async function getDocWritethroughClient() {
+  if (!writethroughClient) {
+    await init3();
+  }
+  return writethroughClient;
 }
-
-// src/objectStore/objectStore.ts
-var import_uuid2 = require("uuid");
-
-// src/db/index.ts
-var db_exports = {};
-__export(db_exports, {
-  APP_DEV: () => APP_DEV,
-  APP_DEV_PREFIX: () => APP_DEV_PREFIX2,
-  APP_PREFIX: () => APP_PREFIX2,
-  AutomationViewMode: () => AutomationViewMode,
-  BUDIBASE_DATASOURCE_TYPE: () => BUDIBASE_DATASOURCE_TYPE,
-  CONSTANT_EXTERNAL_ROW_COLS: () => CONSTANT_EXTERNAL_ROW_COLS,
-  CONSTANT_INTERNAL_ROW_COLS: () => CONSTANT_INTERNAL_ROW_COLS,
-  DEFAULT_BB_DATASOURCE_ID: () => DEFAULT_BB_DATASOURCE_ID,
-  DEFAULT_EMPLOYEE_TABLE_ID: () => DEFAULT_EMPLOYEE_TABLE_ID,
-  DEFAULT_EXPENSES_TABLE_ID: () => DEFAULT_EXPENSES_TABLE_ID,
-  DEFAULT_INVENTORY_TABLE_ID: () => DEFAULT_INVENTORY_TABLE_ID,
-  DEFAULT_JOBS_TABLE_ID: () => DEFAULT_JOBS_TABLE_ID,
-  DatabaseImpl: () => DatabaseImpl,
-  DatabaseWithConnection: () => DatabaseWithConnection,
-  DeprecatedViews: () => DeprecatedViews,
-  DocumentType: () => DocumentType,
-  InternalTable: () => InternalTable,
-  QueryBuilder: () => QueryBuilder,
-  Replication: () => Replication_default,
-  SEPARATOR: () => SEPARATOR,
-  SQLITE_DESIGN_DOC_ID: () => SQLITE_DESIGN_DOC_ID,
-  SQS_DATASOURCE_INTERNAL: () => SQS_DATASOURCE_INTERNAL,
-  StaticDatabases: () => StaticDatabases,
-  UNICODE_MAX: () => UNICODE_MAX,
-  ViewName: () => ViewName,
-  baseGlobalDBName: () => baseGlobalDBName,
-  checkErrorCode: () => checkErrorCode,
-  closePouchDB: () => closePouchDB,
-  createApiKeyView: () => createApiKeyView,
-  createNewUserEmailView: () => createNewUserEmailView,
-  createPlatformAccountEmailView: () => createPlatformAccountEmailView,
-  createPlatformUserView: () => createPlatformUserView,
-  createUserAppView: () => createUserAppView,
-  createView: () => createView,
-  dbExists: () => dbExists,
-  directCouchAllDbs: () => directCouchAllDbs,
-  directCouchCall: () => directCouchCall,
-  directCouchFind: () => directCouchFind,
-  directCouchQuery: () => directCouchQuery,
-  directCouchUrlCall: () => directCouchUrlCall,
-  doWithDB: () => doWithDB,
-  extractAppUUID: () => extractAppUUID,
-  fullSearch: () => fullSearch,
-  generateAppID: () => generateAppID,
-  generateAppUserID: () => generateAppUserID,
-  generateDevInfoID: () => generateDevInfoID,
-  generateGlobalUserID: () => generateGlobalUserID,
-  generatePluginID: () => generatePluginID,
-  generateRoleID: () => generateRoleID,
-  generateRowID: () => generateRowID,
-  generateTableID: () => generateTableID,
-  generateTemplateID: () => generateTemplateID,
-  generateUserMetadataID: () => generateUserMetadataID,
-  generateWorkspaceID: () => generateWorkspaceID,
-  getAllApps: () => getAllApps,
-  getAllDbs: () => getAllDbs,
-  getAppsByIDs: () => getAppsByIDs,
-  getCouchInfo: () => getCouchInfo,
-  getDB: () => getDB,
-  getDevAppID: () => getDevAppID2,
-  getDevAppIDs: () => getDevAppIDs,
-  getDevelopmentAppID: () => getDevelopmentAppID,
-  getDocParams: () => getDocParams,
-  getGlobalDBName: () => getGlobalDBName,
-  getGlobalIDFromUserMetadataID: () => getGlobalIDFromUserMetadataID,
-  getGlobalUserParams: () => getGlobalUserParams,
-  getPluginParams: () => getPluginParams,
-  getPouch: () => getPouch,
-  getPouchDB: () => getPouchDB,
-  getProdAppID: () => getProdAppID2,
-  getProdAppIDs: () => getProdAppIDs,
-  getQueryIndex: () => getQueryIndex,
-  getRoleParams: () => getRoleParams,
-  getRowParams: () => getRowParams,
-  getStartEndKeyURL: () => getStartEndKeyURL,
-  getTemplateParams: () => getTemplateParams,
-  getUrlInfo: () => getUrlInfo,
-  getUserMetadataParams: () => getUserMetadataParams,
-  getUsersByAppParams: () => getUsersByAppParams,
-  getWorkspaceParams: () => getWorkspaceParams,
-  init: () => init,
-  isDatasourceId: () => isDatasourceId,
-  isDevApp: () => isDevApp,
-  isDevAppID: () => isDevAppID,
-  isDocumentConflictError: () => isDocumentConflictError,
-  isGlobalUserID: () => isGlobalUserID,
-  isInternalColumnName: () => isInternalColumnName,
-  isProdAppID: () => isProdAppID,
-  isSameAppID: () => isSameAppID,
-  isTableId: () => isTableId,
-  paginatedSearch: () => paginatedSearch,
-  pagination: () => pagination,
-  prefixRoleID: () => prefixRoleID,
-  queryGlobalView: () => queryGlobalView,
-  queryGlobalViewRaw: () => queryGlobalViewRaw,
-  queryPlatformView: () => queryPlatformView,
-  queryView: () => queryView,
-  queryViewRaw: () => queryViewRaw,
-  removeKeyNumbering: () => removeKeyNumbering2,
-  searchIndexes: () => searchIndexes_exports
-});
 
 // src/cache/appMetadata.ts
-var appMetadata_exports = {};
-__export(appMetadata_exports, {
-  AppState: () => AppState,
-  getAppMetadata: () => getAppMetadata,
-  invalidateAppMetadata: () => invalidateAppMetadata
-});
 var AppState = /* @__PURE__ */ ((AppState2) => {
   AppState2["INVALID"] = "invalid";
   return AppState2;
@@ -58098,7 +58748,7 @@ var Replication = class {
 var Replication_default = Replication;
 
 // src/db/lucene.ts
-var import_node_fetch2 = __toESM(require("node-fetch"));
+var import_node_fetch3 = __toESM(require("node-fetch"));
 var removeKeyNumbering2 = filters_exports.removeKeyNumbering;
 function isEmpty(value) {
   return value == null || value === "";
@@ -58553,7 +59203,7 @@ var QueryBuilder = class _QueryBuilder {
   }
 };
 async function runQuery2(url, body2, cookie) {
-  const response = await (0, import_node_fetch2.default)(url, {
+  const response = await (0, import_node_fetch3.default)(url, {
     body: JSON.stringify(body2),
     method: "POST",
     headers: {
@@ -58598,1338 +59248,848 @@ async function recursiveSearch(dbName, index2, query, params2) {
   if (!page.rows.length) {
     return rows;
   }
-  if (page.rows.length < QueryBuilder.maxLimit) {
-    return [...rows, ...page.rows];
-  }
-  const newParams = {
-    ...params2,
-    bookmark: page.bookmark,
-    rows: [...rows, ...page.rows]
-  };
-  return await recursiveSearch(dbName, index2, query, newParams);
-}
-async function paginatedSearch(dbName, index2, query, params2) {
-  let limit2 = params2.limit;
-  if (limit2 == null || isNaN(limit2) || limit2 < 0) {
-    limit2 = 50;
-  }
-  limit2 = Math.min(limit2, QueryBuilder.maxLimit);
-  const search2 = new QueryBuilder(dbName, index2, query);
-  if (params2.version) {
-    search2.setVersion(params2.version);
-  }
-  if (params2.tableId) {
-    search2.setTable(params2.tableId);
-  }
-  if (params2.sort) {
-    search2.setSort(params2.sort).setSortOrder(params2.sortOrder).setSortType(params2.sortType);
-  }
-  if (params2.indexer) {
-    search2.setIndexBuilder(params2.indexer);
-  }
-  if (params2.disableEscaping) {
-    search2.disableEscaping();
-  }
-  const searchResults = await search2.setBookmark(params2.bookmark).setLimit(limit2).run();
-  search2.setBookmark(searchResults.bookmark).setLimit(1);
-  if (params2.tableId) {
-    search2.setTable(params2.tableId);
-  }
-  const nextResults = await search2.run();
-  return {
-    ...searchResults,
-    hasNextPage: nextResults.rows && nextResults.rows.length > 0
-  };
-}
-async function fullSearch(dbName, index2, query, params2) {
-  let limit2 = params2.limit;
-  if (limit2 == null || isNaN(limit2) || limit2 < 0) {
-    limit2 = 1e3;
-  }
-  params2.limit = Math.min(limit2, 1e3);
-  const rows = await recursiveSearch(dbName, index2, query, params2);
-  return { rows };
-}
-
-// src/db/searchIndexes/index.ts
-var searchIndexes_exports = {};
-__export(searchIndexes_exports, {
-  createUserIndex: () => createUserIndex
-});
-
-// src/db/searchIndexes/searchIndexes.ts
-async function createUserIndex() {
-  const db = getGlobalDB();
-  let designDoc;
-  try {
-    designDoc = await db.get("_design/database");
-  } catch (err) {
-    if (err.status === 404) {
-      designDoc = { _id: "_design/database" };
-    }
-  }
-  const fn = function(user) {
-    if (user._id && !user._id.startsWith("us_")) {
-      return;
-    }
-    const ignoredFields = [
-      "_id",
-      "_rev",
-      "password",
-      "account",
-      "license",
-      "budibaseAccess",
-      "accountPortalAccess",
-      "csrfToken"
-    ];
-    function idx(input, prev) {
-      for (let key of Object.keys(input)) {
-        if (ignoredFields.includes(key)) {
-          continue;
-        }
-        let idxKey = prev != null ? `${prev}.${key}` : key;
-        if (typeof input[key] === "string") {
-          index(idxKey, input[key].toLowerCase(), { facet: true });
-        } else if (typeof input[key] !== "object") {
-          index(idxKey, input[key], { facet: true });
-        } else {
-          idx(input[key], idxKey);
-        }
-      }
-    }
-    idx(user);
-  };
-  designDoc.indexes = {
-    ["user" /* USER */]: {
-      index: fn.toString(),
-      analyzer: {
-        default: "keyword",
-        name: "perfield"
-      }
-    }
-  };
-  await db.put(designDoc);
-}
-
-// src/db/errors.ts
-function checkErrorCode(error, code) {
-  const stringCode = code.toString();
-  if (typeof error === "object") {
-    return error.status === code || error.message?.includes(stringCode);
-  } else if (typeof error === "number") {
-    return error === code;
-  } else if (typeof error === "string") {
-    return error.includes(stringCode);
-  }
-}
-function isDocumentConflictError(error) {
-  return checkErrorCode(error, 409);
-}
-
-// src/objectStore/objectStore.ts
-var import_promises = __toESM(require("fs/promises"));
-var sanitize = require("sanitize-s3-objectkey");
-var streamPipeline = (0, import_util.promisify)(import_stream2.default.pipeline);
-var STATE = {
-  bucketCreationPromises: {}
-};
-var SIGNED_FILE_PREFIX = "/files/signed";
-var CONTENT_TYPE_MAP = {
-  txt: "text/plain",
-  html: "text/html",
-  css: "text/css",
-  js: "application/javascript",
-  json: "application/json",
-  gz: "application/gzip",
-  svg: "image/svg+xml",
-  form: "multipart/form-data"
-};
-var STRING_CONTENT_TYPES = [
-  CONTENT_TYPE_MAP.html,
-  CONTENT_TYPE_MAP.css,
-  CONTENT_TYPE_MAP.js,
-  CONTENT_TYPE_MAP.json
-];
-function sanitizeKey(input) {
-  return sanitize(sanitizeBucket(input)).replace(/\\/g, "/");
-}
-function sanitizeBucket(input) {
-  return input.replace(new RegExp(APP_DEV_PREFIX2, "g"), APP_PREFIX2);
-}
-function ObjectStore(bucket, opts = { presigning: false }) {
-  const config = {
-    s3ForcePathStyle: true,
-    signatureVersion: "v4",
-    apiVersion: "2006-03-01",
-    accessKeyId: environment_default.MINIO_ACCESS_KEY,
-    secretAccessKey: environment_default.MINIO_SECRET_KEY,
-    region: environment_default.AWS_REGION
-  };
-  if (bucket) {
-    config.params = {
-      Bucket: sanitizeBucket(bucket)
-    };
-  }
-  if (!environment_default.MINIO_ENABLED && environment_default.AWS_SESSION_TOKEN) {
-    config.sessionToken = environment_default.AWS_SESSION_TOKEN;
-  }
-  if (environment_default.MINIO_URL) {
-    if (opts.presigning && environment_default.MINIO_ENABLED) {
-      config.endpoint = "minio-service";
-    } else {
-      config.endpoint = environment_default.MINIO_URL;
-    }
-  }
-  return new import_aws_sdk.default.S3(config);
-}
-async function createBucketIfNotExists(client, bucketName) {
-  bucketName = sanitizeBucket(bucketName);
-  try {
-    await client.headBucket({
-      Bucket: bucketName
-    }).promise();
-    return { created: false, exists: true };
-  } catch (err) {
-    const promises = STATE.bucketCreationPromises;
-    const doesntExist = err.statusCode === 404, noAccess = err.statusCode === 403;
-    if (promises[bucketName]) {
-      await promises[bucketName];
-      return { created: false, exists: true };
-    } else if (doesntExist || noAccess) {
-      if (doesntExist) {
-        promises[bucketName] = client.createBucket({
-          Bucket: bucketName
-        }).promise();
-        await promises[bucketName];
-        delete promises[bucketName];
-        return { created: true, exists: false };
-      } else {
-        throw new Error("Access denied to object store bucket." + err);
-      }
-    } else {
-      throw new Error("Unable to write to object store bucket.");
-    }
-  }
-}
-async function upload({
-  bucket: bucketName,
-  filename,
-  path: path3,
-  type,
-  metadata,
-  body: body2,
-  ttl
-}) {
-  const extension = filename.split(".").pop();
-  const fileBytes = path3 ? (await import_promises.default.open(path3)).createReadStream() : body2;
-  const objectStore = ObjectStore(bucketName);
-  const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
-  if (ttl && bucketCreated.created) {
-    let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
-  }
-  let contentType = type;
-  if (!contentType) {
-    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
-  }
-  const config = {
-    // windows file paths need to be converted to forward slashes for s3
-    Key: sanitizeKey(filename),
-    Body: fileBytes,
-    ContentType: contentType
-  };
-  if (metadata && typeof metadata === "object") {
-    for (let key of Object.keys(metadata)) {
-      if (!metadata[key] || typeof metadata[key] !== "string") {
-        delete metadata[key];
-      }
-    }
-    config.Metadata = metadata;
+  if (page.rows.length < QueryBuilder.maxLimit) {
+    return [...rows, ...page.rows];
   }
-  return objectStore.upload(config).promise();
+  const newParams = {
+    ...params2,
+    bookmark: page.bookmark,
+    rows: [...rows, ...page.rows]
+  };
+  return await recursiveSearch(dbName, index2, query, newParams);
 }
-async function streamUpload({
-  bucket: bucketName,
-  stream: stream3,
-  filename,
-  type,
-  extra,
-  ttl
-}) {
-  if (!stream3) {
-    throw new Error("Stream to upload is invalid/undefined");
+async function paginatedSearch(dbName, index2, query, params2) {
+  let limit2 = params2.limit;
+  if (limit2 == null || isNaN(limit2) || limit2 < 0) {
+    limit2 = 50;
   }
-  const extension = filename.split(".").pop();
-  const objectStore = ObjectStore(bucketName);
-  const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
-  if (ttl && bucketCreated.created) {
-    let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
+  limit2 = Math.min(limit2, QueryBuilder.maxLimit);
+  const search2 = new QueryBuilder(dbName, index2, query);
+  if (params2.version) {
+    search2.setVersion(params2.version);
   }
-  if (filename?.endsWith(".js")) {
-    extra = {
-      ...extra,
-      ContentType: "application/javascript"
-    };
-  } else if (filename?.endsWith(".svg")) {
-    extra = {
-      ...extra,
-      ContentType: "image"
-    };
+  if (params2.tableId) {
+    search2.setTable(params2.tableId);
   }
-  let contentType = type;
-  if (!contentType) {
-    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
+  if (params2.sort) {
+    search2.setSort(params2.sort).setSortOrder(params2.sortOrder).setSortType(params2.sortType);
   }
-  const bucket = sanitizeBucket(bucketName), objKey = sanitizeKey(filename);
-  const params2 = {
-    Bucket: bucket,
-    Key: objKey,
-    Body: stream3,
-    ContentType: contentType,
-    ...extra
-  };
-  const details = await objectStore.upload(params2).promise();
-  const headDetails = await objectStore.headObject({
-    Bucket: bucket,
-    Key: objKey
-  }).promise();
+  if (params2.indexer) {
+    search2.setIndexBuilder(params2.indexer);
+  }
+  if (params2.disableEscaping) {
+    search2.disableEscaping();
+  }
+  const searchResults = await search2.setBookmark(params2.bookmark).setLimit(limit2).run();
+  search2.setBookmark(searchResults.bookmark).setLimit(1);
+  if (params2.tableId) {
+    search2.setTable(params2.tableId);
+  }
+  const nextResults = await search2.run();
   return {
-    ...details,
-    ContentLength: headDetails.ContentLength
+    ...searchResults,
+    hasNextPage: nextResults.rows && nextResults.rows.length > 0
   };
 }
-async function retrieve(bucketName, filepath) {
-  const objectStore = ObjectStore(bucketName);
-  const params2 = {
-    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");
-  } else {
-    return response.Body;
+async function fullSearch(dbName, index2, query, params2) {
+  let limit2 = params2.limit;
+  if (limit2 == null || isNaN(limit2) || limit2 < 0) {
+    limit2 = 1e3;
   }
+  params2.limit = Math.min(limit2, 1e3);
+  const rows = await recursiveSearch(dbName, index2, query, params2);
+  return { rows };
 }
-async function listAllObjects(bucketName, path3) {
-  const objectStore = ObjectStore(bucketName);
-  const list = (params2 = {}) => {
-    return objectStore.listObjectsV2({
-      ...params2,
-      Bucket: sanitizeBucket(bucketName),
-      Prefix: sanitizeKey(path3)
-    }).promise();
-  };
-  let isTruncated = false, token, objects = [];
-  do {
-    let params2 = {};
-    if (token) {
-      params2.ContinuationToken = token;
-    }
-    const response = await list(params2);
-    if (response.Contents) {
-      objects = objects.concat(response.Contents);
+
+// src/db/searchIndexes/index.ts
+var searchIndexes_exports = {};
+__export(searchIndexes_exports, {
+  createUserIndex: () => createUserIndex
+});
+
+// src/db/searchIndexes/searchIndexes.ts
+async function createUserIndex() {
+  const db = getGlobalDB();
+  let designDoc;
+  try {
+    designDoc = await db.get("_design/database");
+  } catch (err) {
+    if (err.status === 404) {
+      designDoc = { _id: "_design/database" };
     }
-    isTruncated = !!response.IsTruncated;
-    token = response.NextContinuationToken;
-  } while (isTruncated && token);
-  return objects;
-}
-function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
-  const objectStore = ObjectStore(bucketName, { presigning: true });
-  const params2 = {
-    Bucket: sanitizeBucket(bucketName),
-    Key: sanitizeKey(key),
-    Expires: durationSeconds
-  };
-  const url = objectStore.getSignedUrl("getObject", params2);
-  if (!environment_default.MINIO_ENABLED) {
-    return url;
-  } else {
-    const signedUrl = new URL(url);
-    const path3 = signedUrl.pathname;
-    const query = signedUrl.search;
-    return `${SIGNED_FILE_PREFIX}${path3}${query}`;
   }
-}
-async function retrieveToTmp(bucketName, filepath) {
-  bucketName = sanitizeBucket(bucketName);
-  filepath = sanitizeKey(filepath);
-  const data = await retrieve(bucketName, filepath);
-  const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
-  import_fs3.default.writeFileSync(outputPath, data);
-  return outputPath;
-}
-async function retrieveDirectory(bucketName, path3) {
-  let writePath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
-  import_fs3.default.mkdirSync(writePath);
-  const objects = await listAllObjects(bucketName, path3);
-  let streams = await Promise.all(
-    objects.map((obj) => getReadStream(bucketName, obj.Key))
-  );
-  let count = 0;
-  const writePromises = [];
-  for (let obj of objects) {
-    const filename = obj.Key;
-    const stream3 = streams[count++];
-    const possiblePath = filename.split("/");
-    const dirs = possiblePath.slice(0, possiblePath.length - 1);
-    const possibleDir = (0, import_path2.join)(writePath, ...dirs);
-    if (possiblePath.length > 1 && !import_fs3.default.existsSync(possibleDir)) {
-      import_fs3.default.mkdirSync(possibleDir, { recursive: true });
+  const fn = function(user) {
+    if (user._id && !user._id.startsWith("us_")) {
+      return;
     }
-    const writeStream = import_fs3.default.createWriteStream((0, import_path2.join)(writePath, ...possiblePath), {
-      mode: 420
-    });
-    stream3.pipe(writeStream);
-    writePromises.push(
-      new Promise((resolve, reject) => {
-        stream3.on("finish", resolve);
-        stream3.on("error", reject);
-        writeStream.on("error", reject);
-      })
-    );
-  }
-  await Promise.all(writePromises);
-  return writePath;
-}
-async function deleteFile(bucketName, filepath) {
-  const objectStore = ObjectStore(bucketName);
-  await createBucketIfNotExists(objectStore, bucketName);
-  const params2 = {
-    Bucket: bucketName,
-    Key: sanitizeKey(filepath)
-  };
-  return objectStore.deleteObject(params2).promise();
-}
-async function deleteFiles(bucketName, filepaths) {
-  const objectStore = ObjectStore(bucketName);
-  await createBucketIfNotExists(objectStore, bucketName);
-  const params2 = {
-    Bucket: bucketName,
-    Delete: {
-      Objects: filepaths.map((path3) => ({ Key: sanitizeKey(path3) }))
+    const ignoredFields = [
+      "_id",
+      "_rev",
+      "password",
+      "account",
+      "license",
+      "budibaseAccess",
+      "accountPortalAccess",
+      "csrfToken"
+    ];
+    function idx(input, prev) {
+      for (let key of Object.keys(input)) {
+        if (ignoredFields.includes(key)) {
+          continue;
+        }
+        let idxKey = prev != null ? `${prev}.${key}` : key;
+        if (typeof input[key] === "string") {
+          index(idxKey, input[key].toLowerCase(), { facet: true });
+        } else if (typeof input[key] !== "object") {
+          index(idxKey, input[key], { facet: true });
+        } else {
+          idx(input[key], idxKey);
+        }
+      }
     }
+    idx(user);
   };
-  return objectStore.deleteObjects(params2).promise();
-}
-async function deleteFolder(bucketName, folder) {
-  bucketName = sanitizeBucket(bucketName);
-  folder = sanitizeKey(folder);
-  const client = ObjectStore(bucketName);
-  const listParams = {
-    Bucket: bucketName,
-    Prefix: folder
-  };
-  const existingObjectsResponse = await client.listObjects(listParams).promise();
-  if (existingObjectsResponse.Contents?.length === 0) {
-    return;
-  }
-  const deleteParams = {
-    Bucket: bucketName,
-    Delete: {
-      Objects: []
+  designDoc.indexes = {
+    ["user" /* USER */]: {
+      index: fn.toString(),
+      analyzer: {
+        default: "keyword",
+        name: "perfield"
+      }
     }
   };
-  existingObjectsResponse.Contents?.forEach((content) => {
-    deleteParams.Delete.Objects.push({ Key: content.Key });
-  });
-  const deleteResponse = await client.deleteObjects(deleteParams).promise();
-  if (deleteResponse.Deleted?.length === 1e3) {
-    return deleteFolder(bucketName, folder);
-  }
+  await db.put(designDoc);
 }
-async function uploadDirectory(bucketName, localPath, bucketPath) {
-  bucketName = sanitizeBucket(bucketName);
-  let uploads = [];
-  const files = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
-  for (let file of files) {
-    const path3 = sanitizeKey((0, import_path2.join)(bucketPath, file.name));
-    const local = (0, import_path2.join)(localPath, file.name);
-    if (file.isDirectory()) {
-      uploads.push(uploadDirectory(bucketName, local, path3));
-    } else {
-      uploads.push(
-        streamUpload({
-          bucket: bucketName,
-          filename: path3,
-          stream: import_fs3.default.createReadStream(local)
-        })
-      );
-    }
+
+// src/db/errors.ts
+function checkErrorCode(error, code) {
+  const stringCode = code.toString();
+  if (typeof error === "object") {
+    return error.status === code || error.message?.includes(stringCode);
+  } else if (typeof error === "number") {
+    return error === code;
+  } else if (typeof error === "string") {
+    return error.includes(stringCode);
   }
-  await Promise.all(uploads);
-  return files;
 }
-async function downloadTarballDirect(url, path3, headers = {}) {
-  path3 = sanitizeKey(path3);
-  const response = await (0, import_node_fetch3.default)(url, { headers });
-  if (!response.ok) {
-    throw new Error(`unexpected response ${response.statusText}`);
-  }
-  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path3));
+function isDocumentConflictError(error) {
+  return checkErrorCode(error, 409);
 }
-async function downloadTarball(url, bucketName, path3) {
-  bucketName = sanitizeBucket(bucketName);
-  path3 = sanitizeKey(path3);
-  const response = await (0, import_node_fetch3.default)(url);
-  if (!response.ok) {
-    throw new Error(`unexpected response ${response.statusText}`);
+
+// src/sql/utils.ts
+var DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
+var ROW_ID_REGEX = /^\[.*]$/g;
+var ENCODED_SPACE = encodeURIComponent(" ");
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+function isExternalTableID(tableId) {
+  return tableId.startsWith("datasource" /* DATASOURCE */ + SEPARATOR);
+}
+function isInternalTableID(tableId) {
+  return !isExternalTableID(tableId);
+}
+function getNativeSql(query) {
+  let sql = query.toSQL();
+  if (Array.isArray(sql)) {
+    return sql;
   }
-  const tmpPath = (0, import_path2.join)(budibaseTempDir(), path3);
-  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
-  if (!environment_default.isTest() && environment_default.SELF_HOSTED) {
-    await uploadDirectory(bucketName, tmpPath, path3);
+  let native;
+  if (sql.toNative) {
+    native = sql.toNative();
   }
-  return tmpPath;
-}
-async function getReadStream(bucketName, path3) {
-  bucketName = sanitizeBucket(bucketName);
-  path3 = sanitizeKey(path3);
-  const client = ObjectStore(bucketName);
-  const params2 = {
-    Bucket: bucketName,
-    Key: path3
+  return {
+    sql: native?.sql || sql.sql,
+    bindings: native?.bindings || sql.bindings
   };
-  return client.getObject(params2).createReadStream();
 }
-async function getObjectMetadata(bucket, path3) {
-  bucket = sanitizeBucket(bucket);
-  path3 = sanitizeKey(path3);
-  const client = ObjectStore(bucket);
-  const params2 = {
-    Bucket: bucket,
-    Key: path3
-  };
-  try {
-    return await client.headObject(params2).promise();
-  } catch (err) {
-    throw new Error("Unable to retrieve metadata from object");
+function isExternalTable(table) {
+  if (table?.sourceId && table.sourceId.includes("datasource" /* DATASOURCE */ + SEPARATOR) && table?.sourceId !== DEFAULT_BB_DATASOURCE_ID) {
+    return true;
+  } else if (table?.sourceType === "external" /* EXTERNAL */) {
+    return true;
+  } else if (table?._id && isExternalTableID(table._id)) {
+    return true;
   }
+  return false;
 }
-function extractBucketAndPath(url) {
-  const baseUrl = url.split("?")[0];
-  const regex = new RegExp(
-    `^${SIGNED_FILE_PREFIX}/(?<bucket>[^/]+)/(?<path>.+)$`
-  );
-  const match = baseUrl.match(regex);
-  if (match && match.groups) {
-    const { bucket, path: path3 } = match.groups;
-    return { bucket, path: path3 };
+function buildExternalTableId(datasourceId, tableName) {
+  if (tableName.includes(" ")) {
+    tableName = encodeURIComponent(tableName);
   }
-  return null;
+  return `${datasourceId}${DOUBLE_SEPARATOR}${tableName}`;
 }
-
-// src/objectStore/cloudfront.ts
-var cfsign = __toESM(require("aws-cloudfront-sign"));
-var PRIVATE_KEY;
-function getPrivateKey() {
-  if (!environment_default.CLOUDFRONT_PRIVATE_KEY_64) {
-    throw new Error("CLOUDFRONT_PRIVATE_KEY_64 is not set");
+function breakExternalTableId(tableId) {
+  const parts = tableId.split(DOUBLE_SEPARATOR);
+  let datasourceId = parts.shift();
+  let tableName = parts.join(DOUBLE_SEPARATOR);
+  if (tableName.includes(ENCODED_SPACE)) {
+    tableName = decodeURIComponent(tableName);
   }
-  if (PRIVATE_KEY) {
-    return PRIVATE_KEY;
+  if (!datasourceId || !tableName) {
+    throw new Error("Unable to get datasource/table name from table ID");
   }
-  PRIVATE_KEY = Buffer.from(environment_default.CLOUDFRONT_PRIVATE_KEY_64, "base64").toString(
-    "utf-8"
-  );
-  return PRIVATE_KEY;
+  return { datasourceId, tableName };
 }
-var getCloudfrontSignParams = () => {
-  return {
-    keypairId: environment_default.CLOUDFRONT_PUBLIC_KEY_ID,
-    privateKeyString: getPrivateKey(),
-    expireTime: (/* @__PURE__ */ new Date()).getTime() + 1e3 * 60 * 60 * 24
-    // 1 day
-  };
-};
-var getPresignedUrl2 = (s3Key) => {
-  const url = getUrl(s3Key);
-  return cfsign.getSignedUrl(url, getCloudfrontSignParams());
-};
-var getUrl = (s3Key) => {
-  let prefix = "/";
-  if (s3Key.startsWith("/")) {
-    prefix = "";
+function generateRowIdField(keyProps = []) {
+  if (!Array.isArray(keyProps)) {
+    keyProps = [keyProps];
   }
-  return `${environment_default.CLOUDFRONT_CDN}${prefix}${s3Key}`;
-};
-
-// src/objectStore/buckets/app.ts
-var import_querystring = __toESM(require("querystring"));
-function clientLibraryPath(appId) {
-  return `${sanitizeKey(appId)}/budibase-client.js`;
-}
-function clientLibraryCDNUrl(appId, version) {
-  let file = clientLibraryPath(appId);
-  if (environment_default.CLOUDFRONT_CDN) {
-    if (version) {
-      file += `?v=${version}`;
+  for (let index2 in keyProps) {
+    if (keyProps[index2] instanceof Buffer) {
+      keyProps[index2] = keyProps[index2].toString();
     }
-    return getUrl(file);
-  } else {
-    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
-  }
-}
-function clientLibraryUrl(appId, version) {
-  let tenantId, qsParams;
-  try {
-    tenantId = getTenantId();
-  } finally {
-    qsParams = {
-      appId,
-      version
-    };
   }
-  if (tenantId && tenantId !== DEFAULT_TENANT_ID) {
-    qsParams.tenantId = tenantId;
-  }
-  return `/api/assets/client?${import_querystring.default.encode(qsParams)}`;
+  return encodeURIComponent(JSON.stringify(keyProps).replace(/"/g, "'"));
 }
-function getAppFileUrl(s3Key) {
-  if (environment_default.CLOUDFRONT_CDN) {
-    return getPresignedUrl2(s3Key);
-  } else {
-    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
-  }
+function isRowId(field) {
+  return Array.isArray(field) || typeof field === "string" && field.match(ROW_ID_REGEX) != null;
 }
-
-// src/objectStore/buckets/global.ts
-var getGlobalFileUrl = (type, name, etag) => {
-  let file = getGlobalFileS3Key(type, name);
-  if (environment_default.CLOUDFRONT_CDN) {
-    if (etag) {
-      file = `${file}?etag=${etag}`;
-    }
-    return getPresignedUrl2(file);
-  } else {
-    return getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
+function convertRowId(field) {
+  if (Array.isArray(field)) {
+    return field[0];
   }
-};
-var getGlobalFileS3Key = (type, name) => {
-  let file = `${type}/${name}`;
-  if (environment_default.MULTI_TENANCY) {
-    const tenantId = getTenantId();
-    file = `${tenantId}/${file}`;
+  if (typeof field === "string" && field.match(ROW_ID_REGEX) != null) {
+    return field.substring(1, field.length - 1);
   }
-  return file;
-};
-
-// src/objectStore/buckets/plugins.ts
-function enrichPluginURLs(plugins) {
-  if (!plugins || !plugins.length) {
+  return field;
+}
+function breakRowIdField(_id) {
+  if (!_id) {
     return [];
   }
-  return plugins.map((plugin) => {
-    const jsUrl = getPluginJSUrl(plugin);
-    const iconUrl = getPluginIconUrl(plugin);
-    return { ...plugin, jsUrl, iconUrl };
-  });
-}
-function getPluginJSUrl(plugin) {
-  const s3Key = getPluginJSKey(plugin);
-  return getPluginUrl(s3Key);
+  const id = typeof _id === "string" ? _id : _id._id;
+  const decoded = decodeURIComponent(id).replace(/'/g, '"');
+  try {
+    const parsed = JSON.parse(decoded);
+    return Array.isArray(parsed) ? parsed : [parsed];
+  } catch (err) {
+    return [_id];
+  }
 }
-function getPluginIconUrl(plugin) {
-  const s3Key = getPluginIconKey(plugin);
-  if (!s3Key) {
-    return;
+function isInvalidISODateString(str) {
+  const trimmedValue = str.trim();
+  if (!ISO_DATE_REGEX.test(trimmedValue)) {
+    return false;
   }
-  return getPluginUrl(s3Key);
+  let d = new Date(trimmedValue);
+  return isNaN(d.getTime());
 }
-function getPluginUrl(s3Key) {
-  if (environment_default.CLOUDFRONT_CDN) {
-    return getPresignedUrl2(s3Key);
-  } else {
-    return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
+function isValidISODateString(str) {
+  const trimmedValue = str.trim();
+  if (!ISO_DATE_REGEX.test(trimmedValue)) {
+    return false;
+  }
+  let d = new Date(trimmedValue);
+  if (isNaN(d.getTime())) {
+    return false;
   }
+  return d.toISOString() === trimmedValue;
 }
-function getPluginJSKey(plugin) {
-  return getPluginS3Key(plugin, "plugin.min.js");
+function isValidFilter(value) {
+  return value != null && value !== "";
 }
-function getPluginIconKey(plugin) {
-  const iconFileName = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
-  if (!iconFileName) {
+function sqlLog(client, query, values2) {
+  if (!environment_default.SQL_LOGGING_ENABLE) {
     return;
   }
-  return getPluginS3Key(plugin, iconFileName);
+  let string = `[SQL] [${client.toUpperCase()}] query="${query}"`;
+  if (values2) {
+    string += ` values="${values2.join(", ")}"`;
+  }
+  console.log(string);
 }
-function getPluginS3Key(plugin, fileName) {
-  const s3Key = getPluginS3Dir(plugin.name);
-  return `${s3Key}/${fileName}`;
+
+// src/db/couch/DatabaseImpl.ts
+var DATABASE_NOT_FOUND = "Database does not exist.";
+function buildNano(couchInfo) {
+  return (0, import_nano.default)({
+    url: couchInfo.url,
+    requestDefaults: {
+      headers: {
+        Authorization: couchInfo.cookie
+      }
+    },
+    parseUrl: false
+  });
 }
-function getPluginS3Dir(pluginName) {
-  let s3Key = `${pluginName}`;
-  if (environment_default.MULTI_TENANCY) {
-    const tenantId = getTenantId();
-    s3Key = `${tenantId}/${s3Key}`;
+var CouchDBError = class extends Error {
+  constructor(message, info) {
+    super(message);
+    const statusCode = info.status || info.statusCode || 500;
+    this.status = statusCode;
+    this.statusCode = statusCode;
+    this.reason = info.reason;
+    this.name = info.name;
+    this.errid = info.errid;
+    this.description = info.description;
+    this.error = info.error;
   }
-  if (environment_default.CLOUDFRONT_CDN) {
-    s3Key = `plugins/${s3Key}`;
+};
+function DatabaseWithConnection(dbName, connection, opts) {
+  if (!dbName || !connection) {
+    throw new Error(
+      "Unable to create database without database name or connection"
+    );
   }
-  return s3Key;
-}
-
-// src/logging/system.ts
-var logsFileName = `budibase.log`;
-var budibaseLogsHistoryFileName = "budibase-logs-history.txt";
-var logsPath = import_path3.default.join(budibaseTempDir(), "systemlogs");
-function getFullPath(fileName) {
-  return import_path3.default.join(logsPath, fileName);
+  const db = new DatabaseImpl(dbName, opts, connection);
+  return new DDInstrumentedDatabase(db);
 }
-function getSingleFileMaxSizeInfo(totalMaxSize) {
-  const regex = /(\d+)([A-Za-z])/;
-  const match = totalMaxSize?.match(regex);
-  if (!match) {
-    console.warn(`totalMaxSize does not have a valid value`, {
-      totalMaxSize
-    });
-    return void 0;
+var DatabaseImpl = class _DatabaseImpl {
+  constructor(dbName, opts, connection) {
+    this.couchInfo = getCouchInfo();
+    this.name = dbName;
+    this.pouchOpts = opts || {};
+    if (connection) {
+      this.couchInfo = getCouchInfo(connection);
+      this.instanceNano = buildNano(this.couchInfo);
+    }
+    if (!_DatabaseImpl.nano) {
+      _DatabaseImpl.init();
+    }
   }
-  const size = +match[1];
-  const unit = match[2];
-  if (size === 1) {
-    switch (unit) {
-      case "B":
-        return { size: `${size}B`, totalHistoryFiles: 1 };
-      case "K":
-        return { size: `${size * 1e3 / 2}B`, totalHistoryFiles: 1 };
-      case "M":
-        return { size: `${size * 1e3 / 2}K`, totalHistoryFiles: 1 };
-      case "G":
-        return { size: `${size * 1e3 / 2}M`, totalHistoryFiles: 1 };
-      default:
-        return void 0;
+  static init() {
+    const couchInfo = getCouchInfo();
+    _DatabaseImpl.nano = buildNano(couchInfo);
+  }
+  exists(docId) {
+    if (docId === void 0) {
+      return this.dbExists();
     }
+    return this.docExists(docId);
   }
-  if (size % 2 === 0) {
-    return { size: `${size / 2}${unit}`, totalHistoryFiles: 1 };
+  async dbExists() {
+    const response = await directCouchUrlCall({
+      url: `${this.couchInfo.url}/${this.name}`,
+      method: "HEAD",
+      cookie: this.couchInfo.cookie
+    });
+    return response.status === 200;
   }
-  return { size: `1${unit}`, totalHistoryFiles: size - 1 };
-}
-function localFileDestination() {
-  const fileInfo = getSingleFileMaxSizeInfo(environment_default.ROLLING_LOG_MAX_SIZE);
-  const outFile = rfs.createStream(logsFileName, {
-    // As we have a rolling size, we want to half the max size
-    size: fileInfo?.size,
-    path: logsPath,
-    maxFiles: fileInfo?.totalHistoryFiles || 1,
-    immutable: true,
-    history: budibaseLogsHistoryFileName,
-    initialRotation: false
-  });
-  return outFile;
-}
-function getLogReadStream() {
-  const streams = [];
-  const historyFile = getFullPath(budibaseLogsHistoryFileName);
-  if (import_fs4.default.existsSync(historyFile)) {
-    const fileContent = import_fs4.default.readFileSync(historyFile, "utf-8");
-    const historyFiles = fileContent.split("\n");
-    for (const historyFile2 of historyFiles.filter((x) => x)) {
-      streams.push(import_fs4.default.readFileSync(historyFile2));
+  async docExists(id) {
+    try {
+      await this.performCall((db) => () => db.head(id));
+      return true;
+    } catch {
+      return false;
     }
   }
-  streams.push(import_fs4.default.readFileSync(getFullPath(logsFileName)));
-  const combinedContent = Buffer.concat(streams);
-  return combinedContent;
-}
-
-// src/logging/pino/logger.ts
-function isPlainObject(obj) {
-  return typeof obj === "object" && obj !== null && !(obj instanceof Error);
-}
-function isError(obj) {
-  return obj instanceof Error;
-}
-function isMessage(obj) {
-  return typeof obj === "string";
-}
-var pinoInstance;
-if (!environment_default.DISABLE_PINO_LOGGER) {
-  const level = environment_default.LOG_LEVEL;
-  const pinoOptions = {
-    level,
-    formatters: {
-      level: (level2) => {
-        return { level: level2.toUpperCase() };
-      },
-      bindings: () => {
-        if (environment_default.SELF_HOSTED) {
-          return {
-            service: environment_default.SERVICE_NAME
-          };
-        } else {
-          return {};
+  nano() {
+    return this.instanceNano || _DatabaseImpl.nano;
+  }
+  getDb() {
+    return this.nano().db.use(this.name);
+  }
+  async checkAndCreateDb() {
+    let shouldCreate = !this.pouchOpts?.skip_setup;
+    let exists2 = await this.exists();
+    if (!shouldCreate && !exists2) {
+      throw new Error("DB does not exist");
+    }
+    if (!exists2) {
+      try {
+        await this.nano().db.create(this.name);
+      } catch (err) {
+        if (err.statusCode !== 412) {
+          throw new CouchDBError(err.message, err);
         }
       }
-    },
-    timestamp: () => `,"timestamp":"${new Date(Date.now()).toISOString()}"`
-  };
-  const destinations = [];
-  destinations.push(
-    environment_default.isDev() ? {
-      stream: (0, import_pino_pretty.default)({ singleLine: true }),
-      level
-    } : { stream: process.stdout, level }
-  );
-  if (environment_default.SELF_HOSTED) {
-    destinations.push({
-      stream: localFileDestination(),
-      level
+    }
+    return this.getDb();
+  }
+  // this function fetches the DB and handles if DB creation is needed
+  async performCall(call) {
+    const db = this.getDb();
+    const fnc = await call(db);
+    try {
+      return await fnc();
+    } catch (err) {
+      if (err.statusCode === 404 && err.reason === DATABASE_NOT_FOUND) {
+        await this.checkAndCreateDb();
+        return await this.performCall(call);
+      }
+      throw new CouchDBError(`CouchDB error: ${err.message}`, err);
+    }
+  }
+  async get(id) {
+    return this.performCall((db) => {
+      if (!id) {
+        throw new Error("Unable to get doc without a valid _id.");
+      }
+      return () => db.get(id);
+    });
+  }
+  async getMultiple(ids, opts) {
+    ids = [...new Set(ids)];
+    const response = await this.allDocs({
+      keys: ids,
+      include_docs: true
+    });
+    const rowUnavailable = (row) => {
+      if (row.doc == null || "deleted" in row.value && row.value.deleted) {
+        return true;
+      }
+      return row.error === "not_found";
+    };
+    const rows = response.rows.filter((row) => !rowUnavailable(row));
+    const someMissing = rows.length !== response.rows.length;
+    if (!opts?.allowMissing && someMissing) {
+      const missing = response.rows.filter((row) => rowUnavailable(row));
+      const missingIds = missing.map((row) => row.key).join(", ");
+      throw new Error(`Unable to get documents: ${missingIds}`);
+    }
+    return rows.map((row) => row.doc);
+  }
+  async remove(idOrDoc, rev) {
+    return this.performCall((db) => {
+      let _id;
+      let _rev;
+      if (isDocument(idOrDoc)) {
+        _id = idOrDoc._id;
+        _rev = idOrDoc._rev;
+      } else {
+        _id = idOrDoc;
+        _rev = rev;
+      }
+      if (!_id || !_rev) {
+        throw new Error("Unable to remove doc without a valid _id and _rev.");
+      }
+      return () => db.destroy(_id, _rev);
     });
   }
-  pinoInstance = destinations.length ? (0, import_pino.default)(pinoOptions, import_pino.default.multistream(destinations)) : (0, import_pino.default)(pinoOptions);
-  const getLogParams2 = (args) => {
-    let error = void 0;
-    let objects = [];
-    let message = "";
-    args.forEach((arg) => {
-      if (isMessage(arg)) {
-        message = `${message} ${arg}`.trimStart();
-      }
-      if (isPlainObject(arg)) {
-        objects.push(arg);
+  async post(document, opts) {
+    if (!document._id) {
+      document._id = newid();
+    }
+    return this.put(document, opts);
+  }
+  async put(document, opts) {
+    if (!document._id) {
+      throw new Error("Cannot store document without _id field.");
+    }
+    return this.performCall(async (db) => {
+      if (!document.createdAt) {
+        document.createdAt = (/* @__PURE__ */ new Date()).toISOString();
       }
-      if (isError(arg)) {
-        error = arg;
+      document.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (opts?.force && document._id) {
+        try {
+          const existing = await this.get(document._id);
+          if (existing) {
+            document._rev = existing._rev;
+          }
+        } catch (err) {
+          if (err.status !== 404) {
+            throw err;
+          }
+        }
       }
+      return () => db.insert(document);
     });
-    const identity = getIdentity3();
-    let contextObject = {};
-    contextObject = {
-      tenantId: getTenantId2(),
-      appId: getAppId2(),
-      automationId: getAutomationId2(),
-      identityId: identity?._id,
-      identityType: identity?.type,
-      correlationId: getId()
+  }
+  async bulkDocs(documents) {
+    return this.performCall((db) => {
+      return () => db.bulk({ docs: documents });
+    });
+  }
+  async allDocs(params2) {
+    return this.performCall((db) => {
+      return () => db.list(params2);
+    });
+  }
+  async _sqlQuery(url, method, body2) {
+    url = checkSlashesInUrl(`${this.couchInfo.sqlUrl}/${url}`);
+    const args = {
+      url,
+      method,
+      cookie: this.couchInfo.cookie
     };
-    const span = import_dd_trace2.default.scope().active();
-    if (span) {
-      import_dd_trace2.default.inject(span.context(), import_ext.formats.LOG, contextObject);
+    if (body2) {
+      args.body = body2;
     }
-    const mergingObject = {
-      err: error,
-      pid: process.pid,
-      ...contextObject
-    };
-    if (objects.length) {
-      const data = {};
-      let dataIndex = 0;
-      for (let i = 0; i < objects.length; i++) {
-        const object = objects[i];
-        const logKey = object._logKey;
-        if (logKey) {
-          delete object._logKey;
-          mergingObject[logKey] = object;
-        } else {
-          data[dataIndex] = object;
-          dataIndex++;
+    return this.performCall(() => {
+      return async () => {
+        const response = await directCouchUrlCall(args);
+        const json = await response.json();
+        if (response.status > 300) {
+          throw json;
         }
-      }
-      if (Object.keys(data).length) {
-        mergingObject.data = data;
-      }
-    }
-    return [mergingObject, message];
-  };
-  console.log = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    pinoInstance?.info(obj, msg);
-  };
-  console.info = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    pinoInstance?.info(obj, msg);
-  };
-  console.warn = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    pinoInstance?.warn(obj, msg);
-  };
-  console.error = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    pinoInstance?.error(obj, msg);
-  };
-  console.trace = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    if (!obj.err) {
-      obj.err = new Error();
-    }
-    pinoInstance?.trace(obj, msg);
-  };
-  console.debug = (...arg) => {
-    const [obj, msg] = getLogParams2(arg);
-    pinoInstance?.debug(obj, msg);
-  };
-  const getTenantId2 = () => {
-    let tenantId;
+        return json;
+      };
+    });
+  }
+  async sql(sql, parameters) {
+    const dbName = this.name;
+    const url = `/${dbName}/${SQLITE_DESIGN_DOC_ID}`;
+    sqlLog("sqlite3" /* SQL_LITE */, sql, parameters);
+    return await this._sqlQuery(url, "POST", {
+      query: sql,
+      args: parameters
+    });
+  }
+  // checks design document is accurate (cleans up tables)
+  // this will check the design document and remove anything from
+  // disk which is not supposed to be there
+  async sqlDiskCleanup() {
+    const dbName = this.name;
+    const url = `/${dbName}/_cleanup`;
     try {
-      tenantId = getTenantId();
-    } catch (e) {
+      await this._sqlQuery(url, "POST");
+    } catch (err) {
+      if (err.status !== 500) {
+        throw err;
+      }
     }
-    return tenantId;
-  };
-  const getAppId2 = () => {
-    let appId;
-    try {
-      appId = getAppId();
-    } catch (e) {
+  }
+  // removes a document from sqlite
+  async sqlPurgeDocument(docIds) {
+    if (!Array.isArray(docIds)) {
+      docIds = [docIds];
     }
-    return appId;
-  };
-  const getAutomationId2 = () => {
-    let appId;
-    try {
-      appId = getAutomationId();
-    } catch (e) {
+    const dbName = this.name;
+    const url = `/${dbName}/_purge`;
+    return await this._sqlQuery(url, "POST", { docs: docIds });
+  }
+  async query(viewName, params2) {
+    return this.performCall((db) => {
+      const [database, view] = viewName.split("/");
+      return () => db.view(database, view, params2);
+    });
+  }
+  async destroy() {
+    if (environment_default.SQS_SEARCH_ENABLE && await this.exists(SQLITE_DESIGN_DOC_ID)) {
+      const definition = await this.get(SQLITE_DESIGN_DOC_ID);
+      definition.sql.tables = {};
+      await this.put(definition);
+      await this.sqlDiskCleanup();
     }
-    return appId;
-  };
-  const getIdentity3 = () => {
-    let identity;
     try {
-      identity = getIdentity();
-    } catch (e) {
+      return await this.nano().db.destroy(this.name);
+    } catch (err) {
+      if (err.statusCode === 404) {
+        return;
+      } else {
+        throw new CouchDBError(err.message, err);
+      }
     }
-    return identity;
-  };
-}
-var logger = pinoInstance;
-
-// src/logging/alerts.ts
-var NonErrors = ["AccountError"];
-function isSuppressed(e) {
-  return e && e["suppressAlert"];
-}
-function logAlert(message, e) {
-  if (e && NonErrors.includes(e.name) && isSuppressed(e)) {
-    return;
   }
-  console.error(`bb-alert: ${message}`, e);
-}
-function logAlertWithInfo(message, db, id, error) {
-  message = `${message} - db: ${db} - doc: ${id} - error: `;
-  logAlert(message, error);
-}
-function logWarn(message, e) {
-  console.warn(`bb-warn: ${message}`, e);
-}
-
-// src/timers/index.ts
-var timers_exports = {};
-__export(timers_exports, {
-  cleanup: () => cleanup,
-  clear: () => clear,
-  set: () => set
-});
+  async compact() {
+    return this.performCall((db) => {
+      return () => db.compact();
+    });
+  }
+  // All below functions are in-frequently called, just utilise PouchDB
+  // for them as it implements them better than we can
+  async dump(stream3, opts) {
+    const pouch = getPouchDB(this.name);
+    return pouch.dump(stream3, opts);
+  }
+  async load(stream3) {
+    const pouch = getPouchDB(this.name);
+    return pouch.load(stream3);
+  }
+  async createIndex(opts) {
+    const pouch = getPouchDB(this.name);
+    return pouch.createIndex(opts);
+  }
+  async deleteIndex(opts) {
+    const pouch = getPouchDB(this.name);
+    return pouch.deleteIndex(opts);
+  }
+  async getIndexes() {
+    const pouch = getPouchDB(this.name);
+    return pouch.getIndexes();
+  }
+};
 
-// src/timers/timers.ts
-var intervals = [];
-function set(callback, period) {
-  const interval = setInterval(callback, period);
-  intervals.push(interval);
-  return interval;
+// src/db/db.ts
+function getDB(dbName, opts) {
+  return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts));
 }
-function clear(interval) {
-  const idx = intervals.indexOf(interval);
-  if (idx !== -1) {
-    intervals.splice(idx, 1);
-  }
-  clearInterval(interval);
+async function doWithDB(dbName, cb, opts) {
+  const db = getDB(dbName, opts);
+  return await cb(db);
 }
-function cleanup() {
-  for (let interval of intervals) {
-    clearInterval(interval);
+async function directCouchAllDbs(queryString) {
+  let couchPath = "/_all_dbs";
+  if (queryString) {
+    couchPath += `?${queryString}`;
   }
-  intervals = [];
+  return await directCouchQuery(couchPath);
+}
+async function directCouchFind(dbName, opts) {
+  const json = await directCouchQuery(`${dbName}/_find`, "POST", opts);
+  return { rows: json.docs, bookmark: json.bookmark };
 }
 
-// src/redis/redis.ts
-var MockRedis;
-if (environment_default.MOCK_REDIS) {
-  try {
-    MockRedis = require("ioredis-mock");
-  } catch (err) {
-    console.log("Mock redis unavailable");
+// src/context/mainContext.ts
+var TEST_APP_ID = null;
+function getGlobalDBName(tenantId) {
+  if (!tenantId) {
+    tenantId = getTenantId();
   }
+  return baseGlobalDBName(tenantId);
 }
-var RETRY_PERIOD_MS = 2e3;
-var STARTUP_TIMEOUT_MS = 5e3;
-var CLUSTERED = environment_default.REDIS_CLUSTERED;
-var DEFAULT_SELECT_DB = 0 /* DEFAULT */;
-var CLOSED = false;
-var CLIENTS = {};
-var CONNECTED = false;
-if (environment_default.MOCK_REDIS) {
-  CONNECTED = true;
-}
-function pickClient(selectDb) {
-  return CLIENTS[selectDb];
-}
-function connectionError(timeout2, err) {
-  if (CLOSED) {
-    return;
+function getAuditLogDBName(tenantId) {
+  if (!tenantId) {
+    tenantId = getTenantId();
   }
-  CLOSED = true;
-  clearTimeout(timeout2);
-  CONNECTED = false;
-  logAlert("Redis connection failed", err);
-  setTimeout(() => {
-    init2();
-  }, RETRY_PERIOD_MS);
-}
-function init2(selectDb = DEFAULT_SELECT_DB) {
-  const RedisCore = environment_default.MOCK_REDIS && MockRedis ? MockRedis : import_ioredis.default;
-  let timeout2;
-  CLOSED = false;
-  let client = pickClient(selectDb);
-  if (client && CONNECTED) {
-    return;
+  if (tenantId === DEFAULT_TENANT_ID) {
+    return StaticDatabases.AUDIT_LOGS.name;
+  } else {
+    return `${tenantId}${SEPARATOR}${StaticDatabases.AUDIT_LOGS.name}`;
   }
-  if (environment_default.MOCK_REDIS) {
-    CLIENTS[selectDb] = new RedisCore(getRedisOptions());
+}
+function getScimDBName(tenantId) {
+  if (!tenantId) {
+    tenantId = getTenantId();
   }
-  timeout2 = setTimeout(() => {
-    if (!CONNECTED) {
-      connectionError(timeout2, "Did not successfully connect in timeout");
-    }
-  }, STARTUP_TIMEOUT_MS);
-  if (client) {
-    client.disconnect();
+  if (tenantId === DEFAULT_TENANT_ID) {
+    return StaticDatabases.SCIM_LOGS.name;
+  } else {
+    return `${tenantId}${SEPARATOR}${StaticDatabases.SCIM_LOGS.name}`;
   }
-  const { host, port } = getRedisConnectionDetails();
-  const opts = getRedisOptions();
-  if (CLUSTERED) {
-    client = new RedisCore.Cluster([{ host, port }], opts);
+}
+function baseGlobalDBName(tenantId) {
+  if (!tenantId || tenantId === DEFAULT_TENANT_ID) {
+    return StaticDatabases.GLOBAL.name;
   } else {
-    client = new RedisCore(opts);
+    return `${tenantId}${SEPARATOR}${StaticDatabases.GLOBAL.name}`;
   }
-  client.on("end", (err) => {
-    if (environment_default.isTest()) {
-      return;
-    }
-    connectionError(timeout2, err);
-  });
-  client.on("error", (err) => {
-    connectionError(timeout2, err);
-  });
-  client.on("connect", () => {
-    console.log(`Connected to Redis DB: ${selectDb}`);
-    clearTimeout(timeout2);
-    CONNECTED = true;
-  });
-  CLIENTS[selectDb] = client;
 }
-function waitForConnection(selectDb = DEFAULT_SELECT_DB) {
-  return new Promise((resolve) => {
-    if (pickClient(selectDb) == null) {
-      init2();
-    } else if (CONNECTED) {
-      resolve("");
-      return;
-    }
-    const interval = set(() => {
-      if (CONNECTED) {
-        clear(interval);
-        resolve("");
-      }
-    }, 500);
-  });
+function getPlatformURL() {
+  return environment_default.PLATFORM_URL;
 }
-function promisifyStream(stream3, client) {
-  return new Promise((resolve, reject) => {
-    const outputKeys = /* @__PURE__ */ new Set();
-    stream3.on("data", (keys2) => {
-      keys2.forEach((key) => {
-        outputKeys.add(key);
-      });
-    });
-    stream3.on("error", (err) => {
-      reject(err);
-    });
-    stream3.on("end", async () => {
-      const keysArray = Array.from(outputKeys);
-      try {
-        let getPromises = [];
-        for (let key of keysArray) {
-          getPromises.push(client.get(key));
-        }
-        const jsonArray = await Promise.all(getPromises);
-        resolve(
-          keysArray.map((key) => ({
-            key: removeDbPrefix(key),
-            value: JSON.parse(jsonArray.shift())
-          }))
-        );
-      } catch (err) {
-        reject(err);
-      }
-    });
-  });
+function isMultiTenant() {
+  return !!environment_default.MULTI_TENANCY;
 }
-var RedisWrapper = class {
-  constructor(db, selectDb = null) {
-    this._db = db;
-    this._select = selectDb || DEFAULT_SELECT_DB;
-  }
-  getClient() {
-    return pickClient(this._select);
-  }
-  async init() {
-    CLOSED = false;
-    init2(this._select);
-    await waitForConnection(this._select);
-    if (this._select && !environment_default.isTest()) {
-      this.getClient().select(this._select);
-    }
-    return this;
-  }
-  async finish() {
-    CLOSED = true;
-    this.getClient().disconnect();
-  }
-  async scan(key = "") {
-    const db = this._db;
-    key = `${db}${SEPARATOR2}${key}`;
-    let stream3;
-    if (CLUSTERED) {
-      let node = this.getClient().nodes("master");
-      stream3 = node[0].scanStream({ match: key + "*", count: 100 });
-    } else {
-      stream3 = this.getClient().scanStream({
-        match: key + "*",
-        count: 100
-      });
-    }
-    return promisifyStream(stream3, this.getClient());
-  }
-  async keys(pattern) {
-    const db = this._db;
-    return this.getClient().keys(addDbPrefix(db, pattern));
-  }
-  async exists(key) {
-    const db = this._db;
-    return await this.getClient().exists(addDbPrefix(db, key));
+function isTenantIdSet() {
+  const context = Context.get();
+  return !!context?.tenantId;
+}
+function isTenancyEnabled() {
+  return environment_default.MULTI_TENANCY;
+}
+function getTenantIDFromAppID(appId) {
+  if (!appId) {
+    return void 0;
   }
-  async get(key) {
-    const db = this._db;
-    const response = await this.getClient().get(addDbPrefix(db, key));
-    if (response != null && response.key) {
-      response.key = key;
-    }
-    try {
-      return JSON.parse(response);
-    } catch (err) {
-      return response;
-    }
+  if (!isMultiTenant()) {
+    return DEFAULT_TENANT_ID;
   }
-  async bulkGet(keys2) {
-    const db = 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)) {
-      let final = {};
-      let count = 0;
-      for (let result of response) {
-        if (result) {
-          let parsed;
-          try {
-            parsed = JSON.parse(result);
-          } catch (err) {
-            parsed = result;
-          }
-          final[keys2[count]] = parsed;
-        }
-        count++;
-      }
-      return final;
-    } else {
-      throw new Error(`Invalid response: ${response}`);
-    }
+  const split = appId.split(SEPARATOR);
+  const hasDev = split[1] === "dev" /* DEV */;
+  if (hasDev && split.length === 3 || !hasDev && split.length === 2) {
+    return void 0;
   }
-  async store(key, value, expirySeconds = null) {
-    const db = this._db;
-    if (typeof value === "object") {
-      value = JSON.stringify(value);
-    }
-    const prefixedKey = addDbPrefix(db, key);
-    await this.getClient().set(prefixedKey, value);
-    if (expirySeconds) {
-      await this.getClient().expire(prefixedKey, expirySeconds);
-    }
+  if (hasDev) {
+    return split[2];
+  } else {
+    return split[1];
   }
-  async bulkStore(data, expirySeconds = null) {
-    const client = this.getClient();
-    const dataToStore = Object.entries(data).reduce((acc, [key, value]) => {
-      acc[addDbPrefix(this._db, key)] = typeof value === "object" ? JSON.stringify(value) : value;
-      return acc;
-    }, {});
-    const pipeline = client.pipeline();
-    pipeline.mset(dataToStore);
-    if (expirySeconds !== null) {
-      for (const key of Object.keys(dataToStore)) {
-        pipeline.expire(key, expirySeconds);
-      }
-    }
-    await pipeline.exec();
+}
+function updateContext(updates) {
+  let context;
+  try {
+    context = Context.get();
+  } catch (err) {
+    context = {};
   }
-  async getTTL(key) {
-    const db = this._db;
-    const prefixedKey = addDbPrefix(db, key);
-    return this.getClient().ttl(prefixedKey);
+  context = {
+    ...context,
+    ...updates
+  };
+  return context;
+}
+async function newContext(updates, task) {
+  guardMigration();
+  let context = updateContext(updates);
+  return Context.run(context, task);
+}
+async function doInAutomationContext(params2) {
+  await ensureSnippetContext();
+  return newContext(
+    {
+      tenantId: getTenantIDFromAppID(params2.appId),
+      appId: params2.appId,
+      automationId: params2.automationId
+    },
+    params2.task
+  );
+}
+async function doInContext(appId, task) {
+  const tenantId = getTenantIDFromAppID(appId);
+  return newContext(
+    {
+      tenantId,
+      appId
+    },
+    task
+  );
+}
+async function doInTenant(tenantId, task) {
+  if (!environment_default.MULTI_TENANCY) {
+    tenantId = tenantId || DEFAULT_TENANT_ID;
   }
-  async setExpiry(key, expirySeconds) {
-    const db = this._db;
-    const prefixedKey = addDbPrefix(db, key);
-    await this.getClient().expire(prefixedKey, expirySeconds);
+  const updates = tenantId ? { tenantId } : {};
+  return newContext(updates, task);
+}
+async function doInAppContext(appId, task) {
+  return _doInAppContext(appId, task);
+}
+async function _doInAppContext(appId, task, extraContextSettings) {
+  if (!appId) {
+    throw new Error("appId is required");
   }
-  async delete(key) {
-    const db = this._db;
-    await this.getClient().del(addDbPrefix(db, key));
+  const tenantId = getTenantIDFromAppID(appId);
+  const updates = { appId, ...extraContextSettings };
+  if (tenantId) {
+    updates.tenantId = tenantId;
   }
-  async bulkDelete(keys2) {
-    const db = this._db;
-    await this.getClient().del(keys2.map((key) => addDbPrefix(db, key)));
+  return newContext(updates, task);
+}
+async function doInIdentityContext(identity, task) {
+  if (!identity) {
+    throw new Error("identity is required");
   }
-  async clear() {
-    let items = await this.scan();
-    await Promise.all(items.map((obj) => this.delete(obj.key)));
+  const context = {
+    identity
+  };
+  if (identity.tenantId) {
+    context.tenantId = identity.tenantId;
   }
-  async increment(key) {
-    const result = await this.getClient().incr(addDbPrefix(this._db, key));
-    if (isNaN(result)) {
-      throw new Error(`Redis ${key} does not contain a number`);
-    }
-    return result;
+  return newContext(context, task);
+}
+function guardMigration() {
+  const context = Context.get();
+  if (context?.isMigrating) {
+    throw new Error(
+      "The context cannot be changed, a migration is currently running"
+    );
   }
-  async deleteIfValue(key, value) {
-    const client = this.getClient();
-    const luaScript = `
-      if redis.call('GET', KEYS[1]) == ARGV[1] then
-        redis.call('DEL', KEYS[1])
-      end
-      `;
-    await client.eval(luaScript, 1, addDbPrefix(this._db, key), value);
+}
+async function doInAppMigrationContext(appId, task) {
+  return _doInAppContext(appId, task, {
+    isMigrating: true
+  });
+}
+function getIdentity() {
+  try {
+    const context = Context.get();
+    return context?.identity;
+  } catch (e) {
   }
-};
-var redis_default = RedisWrapper;
-
-// src/redis/init.ts
-var userClient;
-var sessionClient;
-var appClient;
-var cacheClient;
-var writethroughClient;
-var lockClient;
-var socketClient;
-var inviteClient;
-var passwordResetClient;
-var docWritethroughClient;
-async function init3() {
-  userClient = await new redis_default("users" /* USER_CACHE */).init();
-  sessionClient = await new redis_default("session" /* SESSIONS */).init();
-  appClient = await new redis_default("appMetadata" /* APP_METADATA */).init();
-  cacheClient = await new redis_default("data_cache" /* GENERIC_CACHE */).init();
-  lockClient = await new redis_default("locks" /* LOCKS */).init();
-  writethroughClient = await new redis_default("writeThrough" /* WRITE_THROUGH */).init();
-  inviteClient = await new redis_default("invitation" /* INVITATIONS */).init();
-  passwordResetClient = await new redis_default("pwReset" /* PW_RESETS */).init();
-  socketClient = await new redis_default(
-    "socket_io" /* SOCKET_IO */,
-    1 /* SOCKET_IO */
-  ).init();
-  docWritethroughClient = await new redis_default(
-    "docWriteThrough" /* DOC_WRITE_THROUGH */
-  ).init();
 }
-async function shutdown() {
-  if (userClient)
-    await userClient.finish();
-  if (sessionClient)
-    await sessionClient.finish();
-  if (appClient)
-    await appClient.finish();
-  if (cacheClient)
-    await cacheClient.finish();
-  if (writethroughClient)
-    await writethroughClient.finish();
-  if (lockClient)
-    await lockClient.finish();
-  if (inviteClient)
-    await inviteClient.finish();
-  if (passwordResetClient)
-    await passwordResetClient.finish();
-  if (socketClient)
-    await socketClient.finish();
-  if (docWritethroughClient)
-    await docWritethroughClient.finish();
+function getTenantId() {
+  if (!isMultiTenant()) {
+    return DEFAULT_TENANT_ID;
+  }
+  const context = Context.get();
+  const tenantId = context?.tenantId;
+  if (!tenantId) {
+    throw new Error("Tenant id not found");
+  }
+  return tenantId;
 }
-process.on("exit", async () => {
-  await shutdown();
-});
-async function getUserClient() {
-  if (!userClient) {
-    await init3();
+function getAutomationId() {
+  const context = Context.get();
+  return context?.automationId;
+}
+function getAppId() {
+  const context = Context.get();
+  const foundId = context?.appId;
+  if (!foundId && environment_default.isTest() && TEST_APP_ID) {
+    return TEST_APP_ID;
+  } else {
+    return foundId;
   }
-  return userClient;
 }
-async function getSessionClient() {
-  if (!sessionClient) {
-    await init3();
+var getProdAppId = () => {
+  const appId = getAppId();
+  if (!appId) {
+    throw new Error("Could not get appId");
   }
-  return sessionClient;
+  return getProdAppID2(appId);
+};
+function doInEnvironmentContext(values2, task) {
+  if (!values2) {
+    throw new Error("Must supply environment variables.");
+  }
+  const updates = {
+    environmentVariables: values2
+  };
+  return newContext(updates, task);
 }
-async function getAppClient() {
-  if (!appClient) {
-    await init3();
+function doInScimContext(task) {
+  const updates = {
+    isScim: true
+  };
+  return newContext(updates, task);
+}
+async function ensureSnippetContext(enabled2 = !environment_default.isTest()) {
+  const ctx = getCurrentContext();
+  if (!ctx || ctx.snippets) {
+    return;
   }
-  return appClient;
+  let snippets;
+  const db = getAppDB();
+  if (db && enabled2) {
+    const app = await db.get("app_metadata" /* APP_METADATA */);
+    snippets = app.snippets;
+  }
+  ctx.snippets = snippets || [];
 }
-async function getCacheClient() {
-  if (!cacheClient) {
-    await init3();
+function getEnvironmentVariables() {
+  const context = Context.get();
+  if (!context.environmentVariables) {
+    return null;
+  } else {
+    return context.environmentVariables;
   }
-  return cacheClient;
 }
-async function getWritethroughClient() {
-  if (!writethroughClient) {
-    await init3();
+function getGlobalDB() {
+  const context = Context.get();
+  if (!context || environment_default.MULTI_TENANCY && !context.tenantId) {
+    throw new Error("Global DB not found");
   }
-  return writethroughClient;
+  return getDB(baseGlobalDBName(context?.tenantId));
 }
-async function getLockClient() {
-  if (!lockClient) {
-    await init3();
+function getAuditLogsDB() {
+  if (!getTenantId()) {
+    throw new Error("No tenant ID found - cannot open audit log DB");
   }
-  return lockClient;
+  return getDB(getAuditLogDBName());
 }
-async function getSocketClient() {
-  if (!socketClient) {
-    await init3();
+function getAppDB(opts) {
+  const appId = getAppId();
+  if (!appId) {
+    throw new Error("Unable to retrieve app DB - no app ID.");
   }
-  return socketClient;
+  return getDB(appId, opts);
 }
-async function getInviteClient() {
-  if (!inviteClient) {
-    await init3();
+function getProdAppDB(opts) {
+  const appId = getAppId();
+  if (!appId) {
+    throw new Error("Unable to retrieve prod DB - no app ID.");
   }
-  return inviteClient;
+  return getDB(getProdAppID2(appId), opts);
 }
-async function getPasswordResetClient() {
-  if (!passwordResetClient) {
-    await init3();
+function getDevAppDB(opts) {
+  const appId = getAppId();
+  if (!appId) {
+    throw new Error("Unable to retrieve dev DB - no app ID.");
   }
-  return passwordResetClient;
+  return getDB(getDevelopmentAppID(appId), opts);
 }
-async function getDocWritethroughClient() {
-  if (!writethroughClient) {
-    await init3();
+function isScim() {
+  const context = Context.get();
+  const scimCall = context?.isScim;
+  return !!scimCall;
+}
+function getCurrentContext() {
+  try {
+    return Context.get();
+  } catch (e) {
+    return void 0;
   }
-  return writethroughClient;
 }
 
 // src/cache/base/index.ts
@@ -60332,8 +60492,8 @@ __export(redlockImpl_exports, {
 var import_redlock = __toESM(require("redlock"));
 
 // src/utils/index.ts
-var utils_exports3 = {};
-__export(utils_exports3, {
+var utils_exports4 = {};
+__export(utils_exports4, {
   Duration: () => Duration,
   DurationType: () => DurationType,
   clearCookie: () => clearCookie,
@@ -60906,8 +61066,8 @@ __export(users_exports3, {
 });
 
 // src/users/utils.ts
-var utils_exports4 = {};
-__export(utils_exports4, {
+var utils_exports5 = {};
+__export(utils_exports5, {
   getAccountHolderFromUserIds: () => getAccountHolderFromUserIds,
   hasAdminPermissions: () => hasAdminPermissions2,
   hasAppBuilderPermissions: () => hasAppBuilderPermissions2,
@@ -64440,18 +64600,17 @@ var UserDB = class _UserDB {
     }
     const tenantId = getTenantId();
     const db = getGlobalDB();
-    let { email, _id, userGroups = [], roles } = user;
+    const { email, _id, userGroups = [], roles } = user;
     if (!email && !_id) {
       throw new Error("_id or email is required");
     }
     let dbUser;
     if (_id) {
       try {
-        dbUser = await db.get(_id);
-        if (email && dbUser.email !== email) {
-          throw "Email address cannot be changed";
+        dbUser = await getById(_id);
+        if (email && dbUser.email !== email && !opts.allowChangingEmail) {
+          throw new Error("Email address cannot be changed");
         }
-        email = dbUser.email;
       } catch (e) {
         if (e.status === 404) {
         } else {
@@ -64476,12 +64635,13 @@ var UserDB = class _UserDB {
       if (!dbUser && roles?.length) {
         builtUser.roles = { ...roles };
       }
-      let groupPromises = [];
+      const groupPromises = [];
       if (!_id) {
-        _id = builtUser._id;
         if (userGroups.length > 0) {
           for (let groupId of userGroups) {
-            groupPromises.push(_UserDB.groups.addUsers(groupId, [_id]));
+            groupPromises.push(
+              _UserDB.groups.addUsers(groupId, [builtUser._id])
+            );
           }
         }
       }
@@ -64489,6 +64649,9 @@ var UserDB = class _UserDB {
         let response = await db.put(builtUser);
         builtUser._rev = response.rev;
         await handleSaveEvents(builtUser, dbUser);
+        if (dbUser && builtUser.email !== dbUser.email) {
+          await users_exports2.removeUser({ email: dbUser.email });
+        }
         await users_exports2.addUser(
           tenantId,
           builtUser._id,
@@ -66594,6 +66757,23 @@ var correlation = (ctx, next) => {
 };
 var middleware_default2 = correlation;
 
+// src/security/secrets.ts
+function stringContainsSecret(str) {
+  if (str.includes("-----BEGIN PRIVATE KEY-----")) {
+    return true;
+  }
+  for (const key of SECRETS) {
+    const value = environment_default[key];
+    if (typeof value !== "string" || value === "") {
+      continue;
+    }
+    if (str.includes(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/middleware/errorHandling.ts
 async function errorHandling(ctx, next) {
   try {
@@ -66612,6 +66792,13 @@ async function errorHandling(ctx, next) {
       validationErrors: err.validation,
       error: getPublicError(err)
     };
+    if (stringContainsSecret(JSON.stringify(error))) {
+      error = {
+        message: "Unexpected error",
+        status,
+        error: "Unexpected error"
+      };
+    }
     if (environment_default.isTest() && ctx.headers["x-budibase-include-stacktrace"]) {
       error.stack = err.stack;
     }
@@ -67099,123 +67286,8 @@ __export(sql_exports, {
   Sql: () => sql_default,
   SqlTable: () => sqlTable_default,
   designDoc: () => designDoc_exports,
-  utils: () => utils_exports5
-});
-
-// src/sql/utils.ts
-var utils_exports5 = {};
-__export(utils_exports5, {
-  breakExternalTableId: () => breakExternalTableId,
-  breakRowIdField: () => breakRowIdField,
-  buildExternalTableId: () => buildExternalTableId,
-  convertRowId: () => convertRowId,
-  generateRowIdField: () => generateRowIdField,
-  getNativeSql: () => getNativeSql,
-  isExternalTable: () => isExternalTable,
-  isExternalTableID: () => isExternalTableID,
-  isInternalTableID: () => isInternalTableID,
-  isIsoDateString: () => isIsoDateString,
-  isRowId: () => isRowId,
-  isValidFilter: () => isValidFilter
+  utils: () => utils_exports3
 });
-var DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
-var ROW_ID_REGEX = /^\[.*]$/g;
-var ENCODED_SPACE = encodeURIComponent(" ");
-function isExternalTableID(tableId) {
-  return tableId.startsWith("datasource" /* DATASOURCE */ + SEPARATOR);
-}
-function isInternalTableID(tableId) {
-  return !isExternalTableID(tableId);
-}
-function getNativeSql(query) {
-  let sql = query.toSQL();
-  if (Array.isArray(sql)) {
-    return sql;
-  }
-  let native;
-  if (sql.toNative) {
-    native = sql.toNative();
-  }
-  return {
-    sql: native?.sql || sql.sql,
-    bindings: native?.bindings || sql.bindings
-  };
-}
-function isExternalTable(table) {
-  if (table?.sourceId && table.sourceId.includes("datasource" /* DATASOURCE */ + SEPARATOR) && table?.sourceId !== DEFAULT_BB_DATASOURCE_ID) {
-    return true;
-  } else if (table?.sourceType === "external" /* EXTERNAL */) {
-    return true;
-  } else if (table?._id && isExternalTableID(table._id)) {
-    return true;
-  }
-  return false;
-}
-function buildExternalTableId(datasourceId, tableName) {
-  if (tableName.includes(" ")) {
-    tableName = encodeURIComponent(tableName);
-  }
-  return `${datasourceId}${DOUBLE_SEPARATOR}${tableName}`;
-}
-function breakExternalTableId(tableId) {
-  const parts = tableId.split(DOUBLE_SEPARATOR);
-  let datasourceId = parts.shift();
-  let tableName = parts.join(DOUBLE_SEPARATOR);
-  if (tableName.includes(ENCODED_SPACE)) {
-    tableName = decodeURIComponent(tableName);
-  }
-  if (!datasourceId || !tableName) {
-    throw new Error("Unable to get datasource/table name from table ID");
-  }
-  return { datasourceId, tableName };
-}
-function generateRowIdField(keyProps = []) {
-  if (!Array.isArray(keyProps)) {
-    keyProps = [keyProps];
-  }
-  for (let index2 in keyProps) {
-    if (keyProps[index2] instanceof Buffer) {
-      keyProps[index2] = keyProps[index2].toString();
-    }
-  }
-  return encodeURIComponent(JSON.stringify(keyProps).replace(/"/g, "'"));
-}
-function isRowId(field) {
-  return Array.isArray(field) || typeof field === "string" && field.match(ROW_ID_REGEX) != null;
-}
-function convertRowId(field) {
-  if (Array.isArray(field)) {
-    return field[0];
-  }
-  if (typeof field === "string" && field.match(ROW_ID_REGEX) != null) {
-    return field.substring(1, field.length - 1);
-  }
-  return field;
-}
-function breakRowIdField(_id) {
-  if (!_id) {
-    return [];
-  }
-  const id = typeof _id === "string" ? _id : _id._id;
-  const decoded = decodeURIComponent(id).replace(/'/g, '"');
-  try {
-    const parsed = JSON.parse(decoded);
-    return Array.isArray(parsed) ? parsed : [parsed];
-  } catch (err) {
-    return [_id];
-  }
-}
-function isIsoDateString(str) {
-  const trimmedValue = str.trim();
-  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(trimmedValue)) {
-    return false;
-  }
-  let d = new Date(trimmedValue);
-  return d.toISOString() === trimmedValue;
-}
-function isValidFilter(value) {
-  return value != null && value !== "";
-}
 
 // src/sql/sql.ts
 var import_knex2 = require("knex");
@@ -67490,8 +67562,6 @@ var sqlTable_default = SqlTableQueryBuilder;
 // src/sql/sql.ts
 var envLimit = environment_default.SQL_MAX_ROWS ? parseInt(environment_default.SQL_MAX_ROWS) : null;
 var BASE_LIMIT = envLimit || 5e3;
-var MIN_ISO_DATE = "0000-00-00T00:00:00.000Z";
-var MAX_ISO_DATE = "9999-00-00T00:00:00.000Z";
 function likeKey(client, key) {
   let start2, end2;
   switch (client) {
@@ -67524,10 +67594,10 @@ function parse(input) {
   if (typeof input !== "string") {
     return input;
   }
-  if (input === MAX_ISO_DATE || input === MIN_ISO_DATE) {
+  if (isInvalidISODateString(input)) {
     return null;
   }
-  if (isIsoDateString(input)) {
+  if (isValidISODateString(input)) {
     return new Date(input.trim());
   }
   return input;
@@ -68215,15 +68285,7 @@ var SqlQueryBuilder = class extends sqlTable_default {
     return JsonTypes.includes(field.type) && !helpers_exports.schema.isDeprecatedSingleUserColumn(field);
   }
   log(query, values2) {
-    if (!environment_default.SQL_LOGGING_ENABLE) {
-      return;
-    }
-    const sqlClient = this.getSqlClient();
-    let string = `[SQL] [${sqlClient.toUpperCase()}] query="${query}"`;
-    if (values2) {
-      string += ` values="${values2.join(", ")}"`;
-    }
-    console.log(string);
+    sqlLog(this.getSqlClient(), query, values2);
   }
 };
 var sql_default = SqlQueryBuilder;