@budibase/backend-core 2.13.50 → 2.13.52

package/dist/index.js

@@ -2905,6 +2905,123 @@ var init_newid = __esm({
   }
 });
 
+// src/db/instrumentation.ts
+var import_dd_trace, DDInstrumentedDatabase;
+var init_instrumentation = __esm({
+  "src/db/instrumentation.ts"() {
+    "use strict";
+    import_dd_trace = __toESM(require("dd-trace"));
+    DDInstrumentedDatabase = class {
+      constructor(db) {
+        this.db = db;
+      }
+      get name() {
+        return this.db.name;
+      }
+      exists() {
+        return import_dd_trace.default.trace("db.exists", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.exists();
+        });
+      }
+      checkSetup() {
+        return import_dd_trace.default.trace("db.checkSetup", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.checkSetup();
+        });
+      }
+      get(id) {
+        return import_dd_trace.default.trace("db.get", (span) => {
+          span?.addTags({ db_name: this.name, doc_id: id });
+          return this.db.get(id);
+        });
+      }
+      getMultiple(ids, opts) {
+        return import_dd_trace.default.trace("db.getMultiple", (span) => {
+          span?.addTags({
+            db_name: this.name,
+            num_docs: ids.length,
+            allow_missing: opts?.allowMissing
+          });
+          return this.db.getMultiple(ids, opts);
+        });
+      }
+      remove(id, rev) {
+        return import_dd_trace.default.trace("db.remove", (span) => {
+          span?.addTags({ db_name: this.name, doc_id: id });
+          return this.db.remove(id, rev);
+        });
+      }
+      put(document, opts) {
+        return import_dd_trace.default.trace("db.put", (span) => {
+          span?.addTags({ db_name: this.name, doc_id: document._id });
+          return this.db.put(document, opts);
+        });
+      }
+      bulkDocs(documents) {
+        return import_dd_trace.default.trace("db.bulkDocs", (span) => {
+          span?.addTags({ db_name: this.name, num_docs: documents.length });
+          return this.db.bulkDocs(documents);
+        });
+      }
+      allDocs(params2) {
+        return import_dd_trace.default.trace("db.allDocs", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.allDocs(params2);
+        });
+      }
+      query(viewName, params2) {
+        return import_dd_trace.default.trace("db.query", (span) => {
+          span?.addTags({ db_name: this.name, view_name: viewName });
+          return this.db.query(viewName, params2);
+        });
+      }
+      destroy() {
+        return import_dd_trace.default.trace("db.destroy", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.destroy();
+        });
+      }
+      compact() {
+        return import_dd_trace.default.trace("db.compact", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.compact();
+        });
+      }
+      dump(stream2, opts) {
+        return import_dd_trace.default.trace("db.dump", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.dump(stream2, opts);
+        });
+      }
+      load(...args) {
+        return import_dd_trace.default.trace("db.load", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.load(...args);
+        });
+      }
+      createIndex(...args) {
+        return import_dd_trace.default.trace("db.createIndex", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.createIndex(...args);
+        });
+      }
+      deleteIndex(...args) {
+        return import_dd_trace.default.trace("db.deleteIndex", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.deleteIndex(...args);
+        });
+      }
+      getIndexes(...args) {
+        return import_dd_trace.default.trace("db.getIndexes", (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.getIndexes(...args);
+        });
+      }
+    };
+  }
+});
+
 // src/db/couch/DatabaseImpl.ts
 function buildNano(couchInfo) {
   return (0, import_nano.default)({
@@ -2918,7 +3035,8 @@ function buildNano(couchInfo) {
   });
 }
 function DatabaseWithConnection(dbName, connection, opts) {
-  return new DatabaseImpl(dbName, opts, connection);
+  const db = new DatabaseImpl(dbName, opts, connection);
+  return new DDInstrumentedDatabase(db);
 }
 var import_nano, DatabaseImpl;
 var init_DatabaseImpl = __esm({
@@ -2930,6 +3048,7 @@ var init_DatabaseImpl = __esm({
     init_utils2();
     init_pouchDB();
     init_newid();
+    init_instrumentation();
     DatabaseImpl = class _DatabaseImpl {
       constructor(dbName, opts, connection) {
         this.couchInfo = getCouchInfo();
@@ -3146,7 +3265,7 @@ var init_couch = __esm({
 
 // src/db/db.ts
 function getDB(dbName, opts) {
-  return new DatabaseImpl(dbName, opts);
+  return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts));
 }
 async function doWithDB(dbName, cb, opts) {
   const db = getDB(dbName, opts);
@@ -3167,6 +3286,7 @@ var init_db3 = __esm({
   "src/db/db.ts"() {
     "use strict";
     init_couch();
+    init_instrumentation();
   }
 });
 
@@ -3590,529 +3710,149 @@ var init_utils3 = __esm({
   }
 });
 
-// src/timers/timers.ts
-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/logging/correlation/correlation.ts
+var correlation_exports = {};
+__export(correlation_exports, {
+  getId: () => getId,
+  setHeader: () => setHeader
+});
+function getId() {
+  return correlator.getId();
 }
-var intervals, ExecutionTimeoutError, ExecutionTimeTracker;
-var init_timers = __esm({
-  "src/timers/timers.ts"() {
+var correlator, setHeader;
+var init_correlation = __esm({
+  "src/logging/correlation/correlation.ts"() {
     "use strict";
-    intervals = [];
-    ExecutionTimeoutError = class extends Error {
-      constructor() {
-        super(...arguments);
-        this.name = "ExecutionTimeoutError";
-      }
-    };
-    ExecutionTimeTracker = class _ExecutionTimeTracker {
-      constructor(limitMs) {
-        this.limitMs = limitMs;
-        this.totalTimeMs = 0;
-      }
-      static withLimit(limitMs) {
-        return new _ExecutionTimeTracker(limitMs);
-      }
-      track(f) {
-        this.checkLimit();
-        const start2 = process.hrtime.bigint();
-        try {
-          return f();
-        } finally {
-          const end2 = process.hrtime.bigint();
-          this.totalTimeMs += Number(end2 - start2) / 1e6;
-          this.checkLimit();
-        }
-      }
-      get elapsedMS() {
-        return this.totalTimeMs;
-      }
-      checkLimit() {
-        if (this.totalTimeMs > this.limitMs) {
-          throw new ExecutionTimeoutError(
-            `Execution time limit of ${this.limitMs}ms exceeded: ${this.totalTimeMs}ms`
-          );
-        }
+    init_constants4();
+    correlator = require("correlation-id");
+    setHeader = (headers) => {
+      const correlationId = correlator.getId();
+      if (correlationId) {
+        headers["x-budibase-correlation-id" /* CORRELATION_ID */] = correlationId;
       }
     };
   }
 });
 
-// src/timers/index.ts
-var timers_exports = {};
-__export(timers_exports, {
-  ExecutionTimeTracker: () => ExecutionTimeTracker,
-  ExecutionTimeoutError: () => ExecutionTimeoutError,
-  cleanup: () => cleanup,
-  clear: () => clear,
-  set: () => set
-});
-var init_timers2 = __esm({
-  "src/timers/index.ts"() {
+// src/logging/correlation/index.ts
+var init_correlation2 = __esm({
+  "src/logging/correlation/index.ts"() {
     "use strict";
-    init_timers();
+    init_correlation();
   }
 });
 
-// src/redis/redis.ts
-function pickClient(selectDb) {
-  return CLIENTS[selectDb];
-}
-function connectionError(selectDb, timeout2, err) {
-  if (CLOSED) {
-    return;
-  }
-  pickClient(selectDb).disconnect();
-  CLOSED = true;
-  clearTimeout(timeout2);
-  CONNECTED = false;
-  console.error("Redis connection failed - " + err);
-  setTimeout(() => {
-    init2();
-  }, RETRY_PERIOD_MS);
+// src/objectStore/utils.ts
+function budibaseTempDir() {
+  return bbTmp;
 }
-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(
-        selectDb,
-        timeout2,
-        "Did not successfully connect in timeout"
-      );
+var import_path, import_os, import_fs2, ObjectStoreBuckets, bbTmp;
+var init_utils4 = __esm({
+  "src/objectStore/utils.ts"() {
+    "use strict";
+    import_path = require("path");
+    import_os = require("os");
+    import_fs2 = __toESM(require("fs"));
+    init_environment2();
+    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
+    };
+    bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
+    try {
+      import_fs2.default.mkdirSync(bbTmp);
+    } catch (e) {
+      if (e.code !== "EEXIST") {
+        throw e;
+      }
     }
-  }, 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(selectDb, timeout2, err);
-  });
-  client.on("error", (err) => {
-    connectionError(selectDb, timeout2, err);
-  });
-  client.on("connect", () => {
-    clearTimeout(timeout2);
-    CONNECTED = true;
-  });
-  CLIENTS[selectDb] = client;
+});
+
+// src/cache/appMetadata.ts
+var appMetadata_exports = {};
+__export(appMetadata_exports, {
+  AppState: () => AppState,
+  getAppMetadata: () => getAppMetadata,
+  invalidateAppMetadata: () => invalidateAppMetadata
+});
+async function populateFromDB(appId) {
+  return doWithDB(
+    appId,
+    (db) => {
+      return db.get("app_metadata" /* APP_METADATA */);
+    },
+    { skip_setup: true }
+  );
 }
-function waitForConnection(selectDb = DEFAULT_SELECT_DB) {
-  return new Promise((resolve) => {
-    if (pickClient(selectDb) == null) {
-      init2();
-    } else if (CONNECTED) {
-      resolve("");
-      return;
+function isInvalid(metadata) {
+  return !metadata || metadata.state === "invalid" /* INVALID */;
+}
+async function getAppMetadata(appId) {
+  const client = await getAppClient();
+  let metadata = await client.get(appId);
+  if (!metadata) {
+    let expiry = EXPIRY_SECONDS;
+    try {
+      metadata = await populateFromDB(appId);
+    } catch (err) {
+      if (err && err.status === 404) {
+        metadata = { state: "invalid" /* INVALID */ };
+        expiry = void 0;
+      } else {
+        throw err;
+      }
     }
-    const interval = set(() => {
-      if (CONNECTED) {
-        clear(interval);
-        resolve("");
+    if (isInvalid(metadata)) {
+      const temp = await client.get(appId);
+      if (temp) {
+        metadata = temp;
       }
-    }, 500);
-  });
+    }
+    await client.store(appId, metadata, expiry);
+  }
+  return metadata;
 }
-function promisifyStream(stream2, client) {
-  return new Promise((resolve, reject) => {
-    const outputKeys = /* @__PURE__ */ new Set();
-    stream2.on("data", (keys2) => {
-      keys2.forEach((key) => {
-        outputKeys.add(key);
-      });
-    });
-    stream2.on("error", (err) => {
-      reject(err);
-    });
-    stream2.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);
-      }
-    });
-  });
+async function invalidateAppMetadata(appId, newMetadata) {
+  if (!appId) {
+    throw "Cannot invalidate if no app ID provided.";
+  }
+  const client = await getAppClient();
+  await client.delete(appId);
+  if (newMetadata) {
+    await client.store(appId, newMetadata, EXPIRY_SECONDS);
+  }
 }
-var import_ioredis, MockRedis, RETRY_PERIOD_MS, STARTUP_TIMEOUT_MS, CLUSTERED, DEFAULT_SELECT_DB, CLOSED, CLIENTS, CONNECTED, RedisWrapper, redis_default;
-var init_redis = __esm({
-  "src/redis/redis.ts"() {
+var AppState, EXPIRY_SECONDS;
+var init_appMetadata = __esm({
+  "src/cache/appMetadata.ts"() {
     "use strict";
-    init_environment2();
-    import_ioredis = __toESM(require("ioredis"));
-    init_utils3();
-    init_timers2();
-    if (environment_default.MOCK_REDIS) {
-      try {
-        MockRedis = require("ioredis-mock");
-      } catch (err) {
-        console.log("Mock redis unavailable");
-      }
-    }
-    RETRY_PERIOD_MS = 2e3;
-    STARTUP_TIMEOUT_MS = 5e3;
-    CLUSTERED = environment_default.REDIS_CLUSTERED;
-    DEFAULT_SELECT_DB = 0 /* DEFAULT */;
-    CLOSED = false;
-    CLIENTS = {};
-    CONNECTED = false;
-    if (environment_default.MOCK_REDIS) {
-      CONNECTED = true;
-    }
-    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 stream2;
-        if (CLUSTERED) {
-          let node = this.getClient().nodes("master");
-          stream2 = node[0].scanStream({ match: key + "*", count: 100 });
-        } else {
-          stream2 = this.getClient().scanStream({ match: key + "*", count: 100 });
-        }
-        return promisifyStream(stream2, 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;
-        let 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 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 clear() {
-        let items = await this.scan();
-        await Promise.all(items.map((obj) => this.delete(obj.key)));
-      }
-    };
-    redis_default = RedisWrapper;
+    init_init();
+    init_db4();
+    AppState = /* @__PURE__ */ ((AppState2) => {
+      AppState2["INVALID"] = "invalid";
+      return AppState2;
+    })(AppState || {});
+    EXPIRY_SECONDS = 3600;
   }
 });
 
-// src/redis/init.ts
-var init_exports = {};
-__export(init_exports, {
-  getAppClient: () => getAppClient,
-  getCacheClient: () => getCacheClient,
-  getInviteClient: () => getInviteClient,
-  getLockClient: () => getLockClient,
-  getPasswordResetClient: () => getPasswordResetClient,
-  getSessionClient: () => getSessionClient,
-  getSocketClient: () => getSocketClient,
-  getUserClient: () => getUserClient,
-  getWritethroughClient: () => getWritethroughClient,
-  init: () => init3,
-  shutdown: () => shutdown
-});
-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();
-}
-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();
+// src/docIds/ids.ts
+function generateRowID(tableId, id) {
+  id = id || newid();
+  return `${"ro" /* ROW */}${SEPARATOR}${tableId}${SEPARATOR}${id}`;
 }
-async function getUserClient() {
-  if (!userClient) {
-    await init3();
-  }
-  return userClient;
+function generateWorkspaceID() {
+  return `${"workspace" /* WORKSPACE */}${SEPARATOR}${newid()}`;
 }
-async function getSessionClient() {
-  if (!sessionClient) {
-    await init3();
-  }
-  return sessionClient;
+function generateGlobalUserID(id) {
+  return `${"us" /* USER */}${SEPARATOR}${id || newid()}`;
 }
-async function getAppClient() {
-  if (!appClient) {
-    await init3();
-  }
-  return appClient;
-}
-async function getCacheClient() {
-  if (!cacheClient) {
-    await init3();
-  }
-  return cacheClient;
-}
-async function getWritethroughClient() {
-  if (!writethroughClient) {
-    await init3();
-  }
-  return writethroughClient;
-}
-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;
-}
-var userClient, sessionClient, appClient, cacheClient, writethroughClient, lockClient, socketClient, inviteClient, passwordResetClient;
-var init_init = __esm({
-  "src/redis/init.ts"() {
-    "use strict";
-    init_redis();
-    init_utils3();
-    process.on("exit", async () => {
-      await shutdown();
-    });
-  }
-});
-
-// src/cache/appMetadata.ts
-var appMetadata_exports = {};
-__export(appMetadata_exports, {
-  AppState: () => AppState,
-  getAppMetadata: () => getAppMetadata,
-  invalidateAppMetadata: () => invalidateAppMetadata
-});
-async function populateFromDB(appId) {
-  return doWithDB(
-    appId,
-    (db) => {
-      return db.get("app_metadata" /* APP_METADATA */);
-    },
-    { skip_setup: true }
-  );
-}
-function isInvalid(metadata) {
-  return !metadata || metadata.state === "invalid" /* INVALID */;
-}
-async function getAppMetadata(appId) {
-  const client = await getAppClient();
-  let metadata = await client.get(appId);
-  if (!metadata) {
-    let expiry = EXPIRY_SECONDS;
-    try {
-      metadata = await populateFromDB(appId);
-    } catch (err) {
-      if (err && err.status === 404) {
-        metadata = { state: "invalid" /* INVALID */ };
-        expiry = void 0;
-      } else {
-        throw err;
-      }
-    }
-    if (isInvalid(metadata)) {
-      const temp = await client.get(appId);
-      if (temp) {
-        metadata = temp;
-      }
-    }
-    await client.store(appId, metadata, expiry);
-  }
-  return metadata;
-}
-async function invalidateAppMetadata(appId, newMetadata) {
-  if (!appId) {
-    throw "Cannot invalidate if no app ID provided.";
-  }
-  const client = await getAppClient();
-  await client.delete(appId);
-  if (newMetadata) {
-    await client.store(appId, newMetadata, EXPIRY_SECONDS);
-  }
-}
-var AppState, EXPIRY_SECONDS;
-var init_appMetadata = __esm({
-  "src/cache/appMetadata.ts"() {
-    "use strict";
-    init_init();
-    init_db4();
-    AppState = /* @__PURE__ */ ((AppState2) => {
-      AppState2["INVALID"] = "invalid";
-      return AppState2;
-    })(AppState || {});
-    EXPIRY_SECONDS = 3600;
-  }
-});
-
-// src/docIds/ids.ts
-function generateRowID(tableId, id) {
-  id = id || newid();
-  return `${"ro" /* ROW */}${SEPARATOR}${tableId}${SEPARATOR}${id}`;
-}
-function generateWorkspaceID() {
-  return `${"workspace" /* WORKSPACE */}${SEPARATOR}${newid()}`;
-}
-function generateGlobalUserID(id) {
-  return `${"us" /* USER */}${SEPARATOR}${id || newid()}`;
-}
-function isGlobalUserID(id) {
-  return isGlobalUserIDRegex.test(id);
+function isGlobalUserID(id) {
+  return isGlobalUserIDRegex.test(id);
 }
 function generateUserMetadataID(globalId) {
   return generateRowID("ta_users" /* USER_METADATA */, globalId);
@@ -4430,7 +4170,7 @@ function pagination(data, pageSize, {
     nextPage
   };
 }
-var init_utils4 = __esm({
+var init_utils5 = __esm({
   "src/db/utils.ts"() {
     "use strict";
     init_environment2();
@@ -5445,7 +5185,7 @@ var init_db4 = __esm({
     "use strict";
     init_couch();
     init_db3();
-    init_utils4();
+    init_utils5();
     init_views();
     init_conversions();
     init_Replication();
@@ -5457,68 +5197,6 @@ var init_db4 = __esm({
   }
 });
 
-// src/logging/correlation/correlation.ts
-var correlation_exports = {};
-__export(correlation_exports, {
-  getId: () => getId,
-  setHeader: () => setHeader
-});
-function getId() {
-  return correlator.getId();
-}
-var correlator, setHeader;
-var init_correlation = __esm({
-  "src/logging/correlation/correlation.ts"() {
-    "use strict";
-    init_constants4();
-    correlator = require("correlation-id");
-    setHeader = (headers) => {
-      const correlationId = correlator.getId();
-      if (correlationId) {
-        headers["x-budibase-correlation-id" /* CORRELATION_ID */] = correlationId;
-      }
-    };
-  }
-});
-
-// src/logging/correlation/index.ts
-var init_correlation2 = __esm({
-  "src/logging/correlation/index.ts"() {
-    "use strict";
-    init_correlation();
-  }
-});
-
-// src/objectStore/utils.ts
-function budibaseTempDir() {
-  return bbTmp;
-}
-var import_path, import_os, import_fs2, ObjectStoreBuckets, bbTmp;
-var init_utils5 = __esm({
-  "src/objectStore/utils.ts"() {
-    "use strict";
-    import_path = require("path");
-    import_os = require("os");
-    import_fs2 = __toESM(require("fs"));
-    init_environment2();
-    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
-    };
-    bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
-    try {
-      import_fs2.default.mkdirSync(bbTmp);
-    } catch (e) {
-      if (e.code !== "EEXIST") {
-        throw e;
-      }
-    }
-  }
-});
-
 // src/objectStore/objectStore.ts
 function sanitizeKey(input) {
   return sanitize(sanitizeBucket(input)).replace(/\\/g, "/");
@@ -5827,7 +5505,7 @@ var init_objectStore = __esm({
     import_path2 = require("path");
     import_fs3 = __toESM(require("fs"));
     init_environment2();
-    init_utils5();
+    init_utils4();
     import_uuid2 = require("uuid");
     init_db4();
     sanitize = require("sanitize-s3-objectkey");
@@ -6085,7 +5763,7 @@ var init_objectStore2 = __esm({
   "src/objectStore/index.ts"() {
     "use strict";
     init_objectStore();
-    init_utils5();
+    init_utils4();
     init_buckets();
   }
 });
@@ -6173,7 +5851,7 @@ var init_system2 = __esm({
 });
 
 // src/logging/pino/logger.ts
-var import_pino, import_pino_pretty, pinoInstance, isPlainObject2, isError2, isMessage2, getLogParams3, logger;
+var import_pino, import_pino_pretty, import_dd_trace2, import_ext, pinoInstance, isPlainObject2, isError2, isMessage2, getLogParams3, logger;
 var init_logger = __esm({
   "src/logging/pino/logger.ts"() {
     "use strict";
@@ -6182,6 +5860,8 @@ var init_logger = __esm({
     init_environment2();
     init_context2();
     init_correlation2();
+    import_dd_trace2 = __toESM(require("dd-trace"));
+    import_ext = require("dd-trace/ext");
     init_system2();
     if (!environment_default.DISABLE_PINO_LOGGER) {
       let isPlainObject = function(obj) {
@@ -6215,6 +5895,10 @@ var init_logger = __esm({
           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,
@@ -6295,91 +5979,530 @@ var init_logger = __esm({
         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) {
+        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;
+      };
+    }
+    logger = pinoInstance;
+  }
+});
+
+// src/logging/alerts.ts
+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);
+}
+var NonErrors;
+var init_alerts = __esm({
+  "src/logging/alerts.ts"() {
+    "use strict";
+    NonErrors = ["AccountError"];
+  }
+});
+
+// src/logging/index.ts
+var logging_exports = {};
+__export(logging_exports, {
+  correlation: () => correlation_exports,
+  logAlert: () => logAlert,
+  logAlertWithInfo: () => logAlertWithInfo,
+  logWarn: () => logWarn,
+  logger: () => logger,
+  system: () => system_exports
+});
+var init_logging = __esm({
+  "src/logging/index.ts"() {
+    "use strict";
+    init_correlation();
+    init_logger();
+    init_alerts();
+    init_system2();
+  }
+});
+
+// src/timers/timers.ts
+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 = [];
+}
+var intervals, ExecutionTimeoutError, ExecutionTimeTracker;
+var init_timers = __esm({
+  "src/timers/timers.ts"() {
+    "use strict";
+    intervals = [];
+    ExecutionTimeoutError = class extends Error {
+      constructor() {
+        super(...arguments);
+        this.name = "ExecutionTimeoutError";
+      }
+    };
+    ExecutionTimeTracker = class _ExecutionTimeTracker {
+      constructor(limitMs) {
+        this.limitMs = limitMs;
+        this.totalTimeMs = 0;
+      }
+      static withLimit(limitMs) {
+        return new _ExecutionTimeTracker(limitMs);
+      }
+      track(f) {
+        this.checkLimit();
+        const start2 = process.hrtime.bigint();
+        try {
+          return f();
+        } finally {
+          const end2 = process.hrtime.bigint();
+          this.totalTimeMs += Number(end2 - start2) / 1e6;
+          this.checkLimit();
+        }
+      }
+      get elapsedMS() {
+        return this.totalTimeMs;
+      }
+      checkLimit() {
+        if (this.totalTimeMs > this.limitMs) {
+          throw new ExecutionTimeoutError(
+            `Execution time limit of ${this.limitMs}ms exceeded: ${this.totalTimeMs}ms`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/timers/index.ts
+var timers_exports = {};
+__export(timers_exports, {
+  ExecutionTimeTracker: () => ExecutionTimeTracker,
+  ExecutionTimeoutError: () => ExecutionTimeoutError,
+  cleanup: () => cleanup,
+  clear: () => clear,
+  set: () => set
+});
+var init_timers2 = __esm({
+  "src/timers/index.ts"() {
+    "use strict";
+    init_timers();
+  }
+});
+
+// src/redis/redis.ts
+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(stream2, client) {
+  return new Promise((resolve, reject) => {
+    const outputKeys = /* @__PURE__ */ new Set();
+    stream2.on("data", (keys2) => {
+      keys2.forEach((key) => {
+        outputKeys.add(key);
+      });
+    });
+    stream2.on("error", (err) => {
+      reject(err);
+    });
+    stream2.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 import_ioredis, MockRedis, RETRY_PERIOD_MS, STARTUP_TIMEOUT_MS, CLUSTERED, DEFAULT_SELECT_DB, CLOSED, CLIENTS, CONNECTED, RedisWrapper, redis_default;
+var init_redis = __esm({
+  "src/redis/redis.ts"() {
+    "use strict";
+    init_environment2();
+    import_ioredis = __toESM(require("ioredis"));
+    init_utils3();
+    init_logging();
+    init_timers2();
+    if (environment_default.MOCK_REDIS) {
+      try {
+        MockRedis = require("ioredis-mock");
+      } catch (err) {
+        console.log("Mock redis unavailable");
+      }
+    }
+    RETRY_PERIOD_MS = 2e3;
+    STARTUP_TIMEOUT_MS = 5e3;
+    CLUSTERED = environment_default.REDIS_CLUSTERED;
+    DEFAULT_SELECT_DB = 0 /* DEFAULT */;
+    CLOSED = false;
+    CLIENTS = {};
+    CONNECTED = false;
+    if (environment_default.MOCK_REDIS) {
+      CONNECTED = true;
+    }
+    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 stream2;
+        if (CLUSTERED) {
+          let node = this.getClient().nodes("master");
+          stream2 = node[0].scanStream({ match: key + "*", count: 100 });
+        } else {
+          stream2 = this.getClient().scanStream({ match: key + "*", count: 100 });
+        }
+        return promisifyStream(stream2, 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;
+        let response = await this.getClient().get(addDbPrefix(db, key));
+        if (response != null && response.key) {
+          response.key = key;
         }
-        return tenantId;
-      };
-      const getAppId2 = () => {
-        let appId;
         try {
-          appId = getAppId();
-        } catch (e) {
+          return JSON.parse(response);
+        } catch (err) {
+          return response;
         }
-        return appId;
-      };
-      const getAutomationId2 = () => {
-        let appId;
-        try {
-          appId = getAutomationId();
-        } catch (e) {
+      }
+      async bulkGet(keys2) {
+        const db = this._db;
+        if (keys2.length === 0) {
+          return {};
         }
-        return appId;
-      };
-      const getIdentity3 = () => {
-        let identity;
-        try {
-          identity = getIdentity();
-        } catch (e) {
+        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}`);
         }
-        return identity;
-      };
-    }
-    logger = pinoInstance;
+      }
+      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 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 clear() {
+        let items = await this.scan();
+        await Promise.all(items.map((obj) => this.delete(obj.key)));
+      }
+    };
+    redis_default = RedisWrapper;
   }
 });
 
-// src/logging/alerts.ts
-function isSuppressed(e) {
-  return e && e["suppressAlert"];
+// src/redis/init.ts
+var init_exports = {};
+__export(init_exports, {
+  getAppClient: () => getAppClient,
+  getCacheClient: () => getCacheClient,
+  getInviteClient: () => getInviteClient,
+  getLockClient: () => getLockClient,
+  getPasswordResetClient: () => getPasswordResetClient,
+  getSessionClient: () => getSessionClient,
+  getSocketClient: () => getSocketClient,
+  getUserClient: () => getUserClient,
+  getWritethroughClient: () => getWritethroughClient,
+  init: () => init3,
+  shutdown: () => shutdown
+});
+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();
 }
-function logAlert(message, e) {
-  if (e && NonErrors.includes(e.name) && isSuppressed(e)) {
-    return;
+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();
+}
+async function getUserClient() {
+  if (!userClient) {
+    await init3();
   }
-  console.error(`bb-alert: ${message}`, e);
+  return userClient;
 }
-function logAlertWithInfo(message, db, id, error) {
-  message = `${message} - db: ${db} - doc: ${id} - error: `;
-  logAlert(message, error);
+async function getSessionClient() {
+  if (!sessionClient) {
+    await init3();
+  }
+  return sessionClient;
 }
-function logWarn(message, e) {
-  console.warn(`bb-warn: ${message}`, e);
+async function getAppClient() {
+  if (!appClient) {
+    await init3();
+  }
+  return appClient;
 }
-var NonErrors;
-var init_alerts = __esm({
-  "src/logging/alerts.ts"() {
-    "use strict";
-    NonErrors = ["AccountError"];
+async function getCacheClient() {
+  if (!cacheClient) {
+    await init3();
   }
-});
-
-// src/logging/index.ts
-var logging_exports = {};
-__export(logging_exports, {
-  correlation: () => correlation_exports,
-  logAlert: () => logAlert,
-  logAlertWithInfo: () => logAlertWithInfo,
-  logWarn: () => logWarn,
-  logger: () => logger,
-  system: () => system_exports
-});
-var init_logging = __esm({
-  "src/logging/index.ts"() {
+  return cacheClient;
+}
+async function getWritethroughClient() {
+  if (!writethroughClient) {
+    await init3();
+  }
+  return writethroughClient;
+}
+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;
+}
+var userClient, sessionClient, appClient, cacheClient, writethroughClient, lockClient, socketClient, inviteClient, passwordResetClient;
+var init_init = __esm({
+  "src/redis/init.ts"() {
     "use strict";
-    init_correlation();
-    init_logger();
-    init_alerts();
-    init_system2();
+    init_redis();
+    init_utils3();
+    process.on("exit", async () => {
+      await shutdown();
+    });
   }
 });
 
@@ -6601,15 +6724,12 @@ var TTL = /* @__PURE__ */ ((TTL2) => {
   TTL2[TTL2["ONE_DAY"] = 86400] = "ONE_DAY";
   return TTL2;
 })(TTL || {});
-function performExport(funcName) {
-  return (...args) => GENERIC[funcName](...args);
-}
-var keys = performExport("keys");
-var get2 = performExport("get");
-var store = performExport("store");
-var destroy = performExport("delete");
-var withCache = performExport("withCache");
-var bustCache = performExport("bustCache");
+var keys = (...args) => GENERIC.keys(...args);
+var get2 = (...args) => GENERIC.get(...args);
+var store = (...args) => GENERIC.store(...args);
+var destroy = (...args) => GENERIC.delete(...args);
+var withCache = (...args) => GENERIC.withCache(...args);
+var bustCache = (...args) => GENERIC.bustCache(...args);
 
 // src/cache/user.ts
 var user_exports = {};
@@ -7068,13 +7188,13 @@ function validEmail(value) {
 }
 
 // src/utils/Duration.ts
-var DurationType = /* @__PURE__ */ ((DurationType4) => {
-  DurationType4["MILLISECONDS"] = "milliseconds";
-  DurationType4["SECONDS"] = "seconds";
-  DurationType4["MINUTES"] = "minutes";
-  DurationType4["HOURS"] = "hours";
-  DurationType4["DAYS"] = "days";
-  return DurationType4;
+var DurationType = /* @__PURE__ */ ((DurationType3) => {
+  DurationType3["MILLISECONDS"] = "milliseconds";
+  DurationType3["SECONDS"] = "seconds";
+  DurationType3["MINUTES"] = "minutes";
+  DurationType3["HOURS"] = "hours";
+  DurationType3["DAYS"] = "days";
+  return DurationType3;
 })(DurationType || {});
 var conversion = {
   milliseconds: 1,
@@ -8309,7 +8429,7 @@ function createQueue(jobQueue, opts = {}) {
   if (!cleanupInterval && !environment_default.isTest()) {
     cleanupInterval = set(cleanup2, CLEANUP_PERIOD_MS);
     cleanup2().catch((err) => {
-      console.error(`Unable to cleanup automation queue initially - ${err}`);
+      console.error(`Unable to cleanup ${jobQueue} initially - ${err}`);
     });
   }
   return queue;
@@ -11213,7 +11333,8 @@ var Writethrough = class {
 var passwordReset_exports = {};
 __export(passwordReset_exports, {
   createCode: () => createCode2,
-  getCode: () => getCode2
+  getCode: () => getCode2,
+  invalidateCode: () => invalidateCode
 });
 init_init();
 var TTL_SECONDS2 = Duration.fromHours(1).toSeconds();
@@ -11227,10 +11348,16 @@ async function getCode2(code) {
   const client = await getPasswordResetClient();
   const value = await client.get(code);
   if (!value) {
-    throw "Provided information is not valid, cannot reset password - please try again.";
+    throw new Error(
+      "Provided information is not valid, cannot reset password - please try again."
+    );
   }
   return value;
 }
+async function invalidateCode(code) {
+  const client = await getPasswordResetClient();
+  await client.delete(code);
+}
 
 // src/configs/configs.ts
 init_context2();