@budibase/backend-core 2.9.39-alpha.0 → 2.9.39-alpha.2

package/dist/src/cache/tests/writethrough.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_extra = require("../../../tests/extra");
+var import_tests = require("../../../tests");
+var import_writethrough = require("../writethrough");
+var import_db = require("../../db");
+var import_timekeeper = __toESM(require("timekeeper"));
+import_timekeeper.default.freeze(Date.now());
+const DELAY = 5e3;
+describe("writethrough", () => {
+  const config = new import_extra.DBTestConfiguration();
+  const db = (0, import_db.getDB)(import_tests.structures.db.id());
+  const db2 = (0, import_db.getDB)(import_tests.structures.db.id());
+  const writethrough = new import_writethrough.Writethrough(db, DELAY);
+  const writethrough2 = new import_writethrough.Writethrough(db2, DELAY);
+  const docId = import_tests.structures.uuid();
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe("put", () => {
+    let current;
+    it("should be able to store, will go to DB", async () => {
+      await config.doInTenant(async () => {
+        const response = await writethrough.put({
+          _id: docId,
+          value: 1
+        });
+        const output = await db.get(response.id);
+        current = output;
+        expect(output.value).toBe(1);
+      });
+    });
+    it("second put shouldn't update DB", async () => {
+      await config.doInTenant(async () => {
+        const response = await writethrough.put({ ...current, value: 2 });
+        const output = await db.get(response.id);
+        expect(current._rev).toBe(output._rev);
+        expect(output.value).toBe(1);
+      });
+    });
+    it("should put it again after delay period", async () => {
+      await config.doInTenant(async () => {
+        import_timekeeper.default.freeze(Date.now() + DELAY + 1);
+        const response = await writethrough.put({ ...current, value: 3 });
+        const output = await db.get(response.id);
+        expect(response.rev).not.toBe(current._rev);
+        expect(output.value).toBe(3);
+        current = output;
+      });
+    });
+    it("should handle parallel DB updates ignoring conflicts", async () => {
+      await config.doInTenant(async () => {
+        import_timekeeper.default.freeze(Date.now() + DELAY + 1);
+        const responses = await Promise.all([
+          writethrough.put({ ...current, value: 4 }),
+          writethrough.put({ ...current, value: 4 }),
+          writethrough.put({ ...current, value: 4 })
+        ]);
+        const newRev = responses.map((x) => x.rev).find((x) => x !== current._rev);
+        expect(newRev).toBeDefined();
+        expect(responses.map((x) => x.rev)).toEqual(
+          expect.arrayContaining([current._rev, current._rev, newRev])
+        );
+        const output = await db.get(current._id);
+        expect(output.value).toBe(4);
+        expect(output._rev).toBe(newRev);
+        current = output;
+      });
+    });
+    it("should handle updates with documents falling behind", async () => {
+      await config.doInTenant(async () => {
+        import_timekeeper.default.freeze(Date.now() + DELAY + 1);
+        const id = import_tests.structures.uuid();
+        await writethrough.put({ _id: id, value: 1 });
+        const doc = await writethrough.get(id);
+        import_timekeeper.default.freeze(Date.now() + DELAY + 1);
+        await writethrough.put({ ...doc, value: 2 });
+        import_timekeeper.default.freeze(Date.now() + DELAY + 1);
+        const res = await writethrough.put({
+          ...doc,
+          value: 3
+        });
+        expect(res.ok).toBe(true);
+        const output = await db.get(id);
+        expect(output.value).toBe(3);
+        expect(output._rev).toBe(res.rev);
+      });
+    });
+  });
+  describe("get", () => {
+    it("should be able to retrieve", async () => {
+      await config.doInTenant(async () => {
+        const response = await writethrough.get(docId);
+        expect(response.value).toBe(4);
+      });
+    });
+  });
+  describe("same doc, different databases (tenancy)", () => {
+    it("should be able to two different databases", async () => {
+      await config.doInTenant(async () => {
+        const resp1 = await writethrough.put({ _id: "db1", value: "first" });
+        const resp2 = await writethrough2.put({ _id: "db1", value: "second" });
+        expect(resp1.rev).toBeDefined();
+        expect(resp2.rev).toBeDefined();
+        expect((await db.get("db1")).value).toBe("first");
+        expect((await db2.get("db1")).value).toBe("second");
+      });
+    });
+  });
+});
+//# sourceMappingURL=writethrough.spec.js.map

package/dist/src/cache/tests/writethrough.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cache/tests/writethrough.spec.ts"],
+  "sourcesContent": ["import { DBTestConfiguration } from \"../../../tests/extra\"\nimport {\n  structures,\n  expectFunctionWasCalledTimesWith,\n  mocks,\n} from \"../../../tests\"\nimport { Writethrough } from \"../writethrough\"\nimport { getDB } from \"../../db\"\nimport tk from \"timekeeper\"\n\ntk.freeze(Date.now())\n\nconst DELAY = 5000\n\ndescribe(\"writethrough\", () => {\n  const config = new DBTestConfiguration()\n\n  const db = getDB(structures.db.id())\n  const db2 = getDB(structures.db.id())\n\n  const writethrough = new Writethrough(db, DELAY)\n  const writethrough2 = new Writethrough(db2, DELAY)\n\n  const docId = structures.uuid()\n\n  beforeEach(() => {\n    jest.clearAllMocks()\n  })\n\n  describe(\"put\", () => {\n    let current: any\n\n    it(\"should be able to store, will go to DB\", async () => {\n      await config.doInTenant(async () => {\n        const response = await writethrough.put({\n          _id: docId,\n          value: 1,\n        })\n        const output = await db.get<any>(response.id)\n        current = output\n        expect(output.value).toBe(1)\n      })\n    })\n\n    it(\"second put shouldn't update DB\", async () => {\n      await config.doInTenant(async () => {\n        const response = await writethrough.put({ ...current, value: 2 })\n        const output = await db.get<any>(response.id)\n        expect(current._rev).toBe(output._rev)\n        expect(output.value).toBe(1)\n      })\n    })\n\n    it(\"should put it again after delay period\", async () => {\n      await config.doInTenant(async () => {\n        tk.freeze(Date.now() + DELAY + 1)\n        const response = await writethrough.put({ ...current, value: 3 })\n        const output = await db.get<any>(response.id)\n        expect(response.rev).not.toBe(current._rev)\n        expect(output.value).toBe(3)\n\n        current = output\n      })\n    })\n\n    it(\"should handle parallel DB updates ignoring conflicts\", async () => {\n      await config.doInTenant(async () => {\n        tk.freeze(Date.now() + DELAY + 1)\n        const responses = await Promise.all([\n          writethrough.put({ ...current, value: 4 }),\n          writethrough.put({ ...current, value: 4 }),\n          writethrough.put({ ...current, value: 4 }),\n        ])\n\n        // with a lock, this will work\n        const newRev = responses.map(x => x.rev).find(x => x !== current._rev)\n        expect(newRev).toBeDefined()\n        expect(responses.map(x => x.rev)).toEqual(\n          expect.arrayContaining([current._rev, current._rev, newRev])\n        )\n\n        const output = await db.get<any>(current._id)\n        expect(output.value).toBe(4)\n        expect(output._rev).toBe(newRev)\n\n        current = output\n      })\n    })\n\n    it(\"should handle updates with documents falling behind\", async () => {\n      await config.doInTenant(async () => {\n        tk.freeze(Date.now() + DELAY + 1)\n\n        const id = structures.uuid()\n        await writethrough.put({ _id: id, value: 1 })\n        const doc = await writethrough.get(id)\n\n        // Updating document\n        tk.freeze(Date.now() + DELAY + 1)\n        await writethrough.put({ ...doc, value: 2 })\n\n        // Update with the old rev value\n        tk.freeze(Date.now() + DELAY + 1)\n        const res = await writethrough.put({\n          ...doc,\n          value: 3,\n        })\n        expect(res.ok).toBe(true)\n\n        const output = await db.get<any>(id)\n        expect(output.value).toBe(3)\n        expect(output._rev).toBe(res.rev)\n      })\n    })\n  })\n\n  describe(\"get\", () => {\n    it(\"should be able to retrieve\", async () => {\n      await config.doInTenant(async () => {\n        const response = await writethrough.get(docId)\n        expect(response.value).toBe(4)\n      })\n    })\n  })\n\n  describe(\"same doc, different databases (tenancy)\", () => {\n    it(\"should be able to two different databases\", async () => {\n      await config.doInTenant(async () => {\n        const resp1 = await writethrough.put({ _id: \"db1\", value: \"first\" })\n        const resp2 = await writethrough2.put({ _id: \"db1\", value: \"second\" })\n        expect(resp1.rev).toBeDefined()\n        expect(resp2.rev).toBeDefined()\n        expect((await db.get<any>(\"db1\")).value).toBe(\"first\")\n        expect((await db2.get<any>(\"db1\")).value).toBe(\"second\")\n      })\n    })\n  })\n})\n"],
+  "mappings": "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",
+  "names": ["tk"]
+}

package/dist/src/cache/user.js

@@ -0,0 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var user_exports = {};
+__export(user_exports, {
+  getUser: () => getUser,
+  invalidateUser: () => invalidateUser
+});
+module.exports = __toCommonJS(user_exports);
+var redis = __toESM(require("../redis/init"));
+var tenancy = __toESM(require("../tenancy"));
+var context = __toESM(require("../context"));
+var platform = __toESM(require("../platform"));
+var import_environment = __toESM(require("../environment"));
+var accounts = __toESM(require("../accounts"));
+var import_users = require("../users");
+var import_shared_core = require("@budibase/shared-core");
+const EXPIRY_SECONDS = 3600;
+async function populateFromDB(userId, tenantId) {
+  const db = tenancy.getTenantDB(tenantId);
+  const user = await db.get(userId);
+  user.budibaseAccess = true;
+  if (!import_environment.default.SELF_HOSTED && !import_environment.default.DISABLE_ACCOUNT_PORTAL) {
+    const account = await accounts.getAccount(user.email);
+    if (account) {
+      user.account = account;
+      user.accountPortalAccess = true;
+    }
+  }
+  return user;
+}
+async function getUser(userId, tenantId, populateUser) {
+  if (!populateUser) {
+    populateUser = populateFromDB;
+  }
+  if (!tenantId) {
+    try {
+      tenantId = context.getTenantId();
+    } catch (err) {
+      tenantId = await platform.users.lookupTenantId(userId);
+    }
+  }
+  const client = await redis.getUserClient();
+  let user = await client.get(userId);
+  if (!user) {
+    user = await populateUser(userId, tenantId);
+    await client.store(userId, user, EXPIRY_SECONDS);
+  }
+  if (user && !user.tenantId && tenantId) {
+    user.tenantId = tenantId;
+  }
+  if (user.userGroups && !import_shared_core.sdk.users.isGlobalBuilder(user)) {
+    await context.doInTenant(tenantId, async () => {
+      const appIds = await import_users.UserDB.getGroupBuilderAppIds(user);
+      if (appIds.length) {
+        const existing = user.builder?.apps || [];
+        user.builder = {
+          apps: [...new Set(existing.concat(appIds))]
+        };
+      }
+    });
+  }
+  return user;
+}
+async function invalidateUser(userId) {
+  const client = await redis.getUserClient();
+  await client.delete(userId);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUser,
+  invalidateUser
+});
+//# sourceMappingURL=user.js.map

package/dist/src/cache/user.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cache/user.ts"],
+  "sourcesContent": ["import * as redis from \"../redis/init\"\nimport * as tenancy from \"../tenancy\"\nimport * as context from \"../context\"\nimport * as platform from \"../platform\"\nimport env from \"../environment\"\nimport * as accounts from \"../accounts\"\nimport { UserDB } from \"../users\"\nimport { sdk } from \"@budibase/shared-core\"\n\nconst EXPIRY_SECONDS = 3600\n\n/**\n * The default populate user function\n */\nasync function populateFromDB(userId: string, tenantId: string) {\n  const db = tenancy.getTenantDB(tenantId)\n  const user = await db.get<any>(userId)\n  user.budibaseAccess = true\n  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {\n    const account = await accounts.getAccount(user.email)\n    if (account) {\n      user.account = account\n      user.accountPortalAccess = true\n    }\n  }\n\n  return user\n}\n\n/**\n * Get the requested user by id.\n * Use redis cache to first read the user.\n * If not present fallback to loading the user directly and re-caching.\n * @param {*} userId the id of the user to get\n * @param {*} tenantId the tenant of the user to get\n * @param {*} populateUser function to provide the user for re-caching. default to couch db\n * @returns\n */\nexport async function getUser(\n  userId: string,\n  tenantId?: string,\n  populateUser?: any\n) {\n  if (!populateUser) {\n    populateUser = populateFromDB\n  }\n  if (!tenantId) {\n    try {\n      tenantId = context.getTenantId()\n    } catch (err) {\n      tenantId = await platform.users.lookupTenantId(userId)\n    }\n  }\n  const client = await redis.getUserClient()\n  // try cache\n  let user = await client.get(userId)\n  if (!user) {\n    user = await populateUser(userId, tenantId)\n    await client.store(userId, user, EXPIRY_SECONDS)\n  }\n  if (user && !user.tenantId && tenantId) {\n    // make sure the tenant ID is always correct/set\n    user.tenantId = tenantId\n  }\n  // if has groups, could have builder permissions granted by a group\n  if (user.userGroups && !sdk.users.isGlobalBuilder(user)) {\n    await context.doInTenant(tenantId, async () => {\n      const appIds = await UserDB.getGroupBuilderAppIds(user)\n      if (appIds.length) {\n        const existing = user.builder?.apps || []\n        user.builder = {\n          apps: [...new Set(existing.concat(appIds))],\n        }\n      }\n    })\n  }\n  return user\n}\n\nexport async function invalidateUser(userId: string) {\n  const client = await redis.getUserClient()\n  await client.delete(userId)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAuB;AACvB,cAAyB;AACzB,cAAyB;AACzB,eAA0B;AAC1B,yBAAgB;AAChB,eAA0B;AAC1B,mBAAuB;AACvB,yBAAoB;AAEpB,MAAM,iBAAiB;AAKvB,eAAe,eAAe,QAAgB,UAAkB;AAC9D,QAAM,KAAK,QAAQ,YAAY,QAAQ;AACvC,QAAM,OAAO,MAAM,GAAG,IAAS,MAAM;AACrC,OAAK,iBAAiB;AACtB,MAAI,CAAC,mBAAAA,QAAI,eAAe,CAAC,mBAAAA,QAAI,wBAAwB;AACnD,UAAM,UAAU,MAAM,SAAS,WAAW,KAAK,KAAK;AACpD,QAAI,SAAS;AACX,WAAK,UAAU;AACf,WAAK,sBAAsB;AAAA,IAC7B;AAAA,EACF;AAEA,SAAO;AACT;AAWA,eAAsB,QACpB,QACA,UACA,cACA;AACA,MAAI,CAAC,cAAc;AACjB,mBAAe;AAAA,EACjB;AACA,MAAI,CAAC,UAAU;AACb,QAAI;AACF,iBAAW,QAAQ,YAAY;AAAA,IACjC,SAAS,KAAK;AACZ,iBAAW,MAAM,SAAS,MAAM,eAAe,MAAM;AAAA,IACvD;AAAA,EACF;AACA,QAAM,SAAS,MAAM,MAAM,cAAc;AAEzC,MAAI,OAAO,MAAM,OAAO,IAAI,MAAM;AAClC,MAAI,CAAC,MAAM;AACT,WAAO,MAAM,aAAa,QAAQ,QAAQ;AAC1C,UAAM,OAAO,MAAM,QAAQ,MAAM,cAAc;AAAA,EACjD;AACA,MAAI,QAAQ,CAAC,KAAK,YAAY,UAAU;AAEtC,SAAK,WAAW;AAAA,EAClB;AAEA,MAAI,KAAK,cAAc,CAAC,uBAAI,MAAM,gBAAgB,IAAI,GAAG;AACvD,UAAM,QAAQ,WAAW,UAAU,YAAY;AAC7C,YAAM,SAAS,MAAM,oBAAO,sBAAsB,IAAI;AACtD,UAAI,OAAO,QAAQ;AACjB,cAAM,WAAW,KAAK,SAAS,QAAQ,CAAC;AACxC,aAAK,UAAU;AAAA,UACb,MAAM,CAAC,GAAG,IAAI,IAAI,SAAS,OAAO,MAAM,CAAC,CAAC;AAAA,QAC5C;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAEA,eAAsB,eAAe,QAAgB;AACnD,QAAM,SAAS,MAAM,MAAM,cAAc;AACzC,QAAM,OAAO,OAAO,MAAM;AAC5B;",
+  "names": ["env"]
+}

package/dist/src/cache/writethrough.js

@@ -0,0 +1,144 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var writethrough_exports = {};
+__export(writethrough_exports, {
+  Writethrough: () => Writethrough
+});
+module.exports = __toCommonJS(writethrough_exports);
+var import_base = __toESM(require("./base"));
+var import_init = require("../redis/init");
+var import_logging = require("../logging");
+var import_types = require("@budibase/types");
+var locks = __toESM(require("../redis/redlockImpl"));
+const DEFAULT_WRITE_RATE_MS = 1e4;
+let CACHE = null;
+async function getCache() {
+  if (!CACHE) {
+    const client = await (0, import_init.getWritethroughClient)();
+    CACHE = new import_base.default(client);
+  }
+  return CACHE;
+}
+function makeCacheKey(db, key) {
+  return db.name + key;
+}
+function makeCacheItem(doc, lastWrite = null) {
+  return { doc, lastWrite: lastWrite || Date.now() };
+}
+async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
+  const cache = await getCache();
+  const key = doc._id;
+  let cacheItem;
+  if (key) {
+    cacheItem = await cache.get(makeCacheKey(db, key));
+  }
+  const updateDb = !cacheItem || cacheItem.lastWrite < Date.now() - writeRateMs;
+  let output = doc;
+  if (updateDb) {
+    const lockResponse = await locks.doWithLock(
+      {
+        type: import_types.LockType.TRY_ONCE,
+        name: import_types.LockName.PERSIST_WRITETHROUGH,
+        resource: key,
+        ttl: 15e3
+      },
+      async () => {
+        const writeDb = async (toWrite) => {
+          const response = await db.put(toWrite, { force: true });
+          output = {
+            ...doc,
+            _id: response.id,
+            _rev: response.rev
+          };
+        };
+        try {
+          await writeDb(doc);
+        } catch (err) {
+          if (err.status !== 409) {
+            throw err;
+          } else {
+            (0, import_logging.logWarn)(`Ignoring conflict in write-through cache`);
+          }
+        }
+      }
+    );
+    if (!lockResponse.executed) {
+      (0, import_logging.logWarn)(`Ignoring redlock conflict in write-through cache`);
+    }
+  }
+  cacheItem = makeCacheItem(output, updateDb ? null : cacheItem?.lastWrite);
+  if (output._id) {
+    await cache.store(makeCacheKey(db, output._id), cacheItem);
+  }
+  return { ok: true, id: output._id, rev: output._rev };
+}
+async function get(db, id) {
+  const cache = await getCache();
+  const cacheKey = makeCacheKey(db, id);
+  let cacheItem = await cache.get(cacheKey);
+  if (!cacheItem) {
+    const doc = await db.get(id);
+    cacheItem = makeCacheItem(doc);
+    await cache.store(cacheKey, cacheItem);
+  }
+  return cacheItem.doc;
+}
+async function remove(db, docOrId, rev) {
+  const cache = await getCache();
+  if (!docOrId) {
+    throw new Error("No ID/Rev provided.");
+  }
+  const id = typeof docOrId === "string" ? docOrId : docOrId._id;
+  rev = typeof docOrId === "string" ? rev : docOrId._rev;
+  try {
+    await cache.delete(makeCacheKey(db, id));
+  } finally {
+    await db.remove(id, rev);
+  }
+}
+class Writethrough {
+  constructor(db, writeRateMs = DEFAULT_WRITE_RATE_MS) {
+    this.db = db;
+    this.writeRateMs = writeRateMs;
+  }
+  async put(doc) {
+    return put(this.db, doc, this.writeRateMs);
+  }
+  async get(id) {
+    return get(this.db, id);
+  }
+  async remove(docOrId, rev) {
+    return remove(this.db, docOrId, rev);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Writethrough
+});
+//# sourceMappingURL=writethrough.js.map

package/dist/src/cache/writethrough.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cache/writethrough.ts"],
+  "sourcesContent": ["import BaseCache from \"./base\"\nimport { getWritethroughClient } from \"../redis/init\"\nimport { logWarn } from \"../logging\"\nimport { Database, Document, LockName, LockType } from \"@budibase/types\"\nimport * as locks from \"../redis/redlockImpl\"\n\nconst DEFAULT_WRITE_RATE_MS = 10000\nlet CACHE: BaseCache | null = null\n\ninterface CacheItem {\n  doc: any\n  lastWrite: number\n}\n\nasync function getCache() {\n  if (!CACHE) {\n    const client = await getWritethroughClient()\n    CACHE = new BaseCache(client)\n  }\n  return CACHE\n}\n\nfunction makeCacheKey(db: Database, key: string) {\n  return db.name + key\n}\n\nfunction makeCacheItem(doc: any, lastWrite: number | null = null): CacheItem {\n  return { doc, lastWrite: lastWrite || Date.now() }\n}\n\nasync function put(\n  db: Database,\n  doc: Document,\n  writeRateMs: number = DEFAULT_WRITE_RATE_MS\n) {\n  const cache = await getCache()\n  const key = doc._id\n  let cacheItem: CacheItem | undefined\n  if (key) {\n    cacheItem = await cache.get(makeCacheKey(db, key))\n  }\n  const updateDb = !cacheItem || cacheItem.lastWrite < Date.now() - writeRateMs\n  let output = doc\n  if (updateDb) {\n    const lockResponse = await locks.doWithLock(\n      {\n        type: LockType.TRY_ONCE,\n        name: LockName.PERSIST_WRITETHROUGH,\n        resource: key,\n        ttl: 15000,\n      },\n      async () => {\n        const writeDb = async (toWrite: any) => {\n          // doc should contain the _id and _rev\n          const response = await db.put(toWrite, { force: true })\n          output = {\n            ...doc,\n            _id: response.id,\n            _rev: response.rev,\n          }\n        }\n        try {\n          await writeDb(doc)\n        } catch (err: any) {\n          if (err.status !== 409) {\n            throw err\n          } else {\n            // Swallow 409s but log them\n            logWarn(`Ignoring conflict in write-through cache`)\n          }\n        }\n      }\n    )\n\n    if (!lockResponse.executed) {\n      logWarn(`Ignoring redlock conflict in write-through cache`)\n    }\n  }\n  // if we are updating the DB then need to set the lastWrite to now\n  cacheItem = makeCacheItem(output, updateDb ? null : cacheItem?.lastWrite)\n  if (output._id) {\n    await cache.store(makeCacheKey(db, output._id), cacheItem)\n  }\n  return { ok: true, id: output._id, rev: output._rev }\n}\n\nasync function get(db: Database, id: string): Promise<any> {\n  const cache = await getCache()\n  const cacheKey = makeCacheKey(db, id)\n  let cacheItem: CacheItem = await cache.get(cacheKey)\n  if (!cacheItem) {\n    const doc = await db.get(id)\n    cacheItem = makeCacheItem(doc)\n    await cache.store(cacheKey, cacheItem)\n  }\n  return cacheItem.doc\n}\n\nasync function remove(db: Database, docOrId: any, rev?: any): Promise<void> {\n  const cache = await getCache()\n  if (!docOrId) {\n    throw new Error(\"No ID/Rev provided.\")\n  }\n  const id = typeof docOrId === \"string\" ? docOrId : docOrId._id\n  rev = typeof docOrId === \"string\" ? rev : docOrId._rev\n  try {\n    await cache.delete(makeCacheKey(db, id))\n  } finally {\n    await db.remove(id, rev)\n  }\n}\n\nexport class Writethrough {\n  db: Database\n  writeRateMs: number\n\n  constructor(db: Database, writeRateMs: number = DEFAULT_WRITE_RATE_MS) {\n    this.db = db\n    this.writeRateMs = writeRateMs\n  }\n\n  async put(doc: any) {\n    return put(this.db, doc, this.writeRateMs)\n  }\n\n  async get(id: string) {\n    return get(this.db, id)\n  }\n\n  async remove(docOrId: any, rev?: any) {\n    return remove(this.db, docOrId, rev)\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["BaseCache"]
+}

package/dist/src/configs/configs.js

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configs_exports = {};
+__export(configs_exports, {
+  analyticsEnabled: () => analyticsEnabled,
+  generateConfigID: () => generateConfigID,
+  getConfig: () => getConfig,
+  getDefaultGoogleConfig: () => getDefaultGoogleConfig,
+  getGoogleConfig: () => getGoogleConfig,
+  getGoogleDatasourceConfig: () => getGoogleDatasourceConfig,
+  getOIDCConfig: () => getOIDCConfig,
+  getOIDCConfigById: () => getOIDCConfigById,
+  getOIDCLogosDoc: () => getOIDCLogosDoc,
+  getPlatformUrl: () => getPlatformUrl,
+  getSCIMConfig: () => getSCIMConfig,
+  getSMTPConfig: () => getSMTPConfig,
+  getSMTPConfigDoc: () => getSMTPConfigDoc,
+  getSettingsConfig: () => getSettingsConfig,
+  getSettingsConfigDoc: () => getSettingsConfigDoc,
+  save: () => save
+});
+module.exports = __toCommonJS(configs_exports);
+var import_types = require("@budibase/types");
+var import_constants = require("../constants");
+var import_cache = require("../cache");
+var context = __toESM(require("../context"));
+var import_environment = __toESM(require("../environment"));
+var import_environment2 = __toESM(require("../environment"));
+function generateConfigID(type) {
+  return `${import_constants.DocumentType.CONFIG}${import_constants.SEPARATOR}${type}`;
+}
+async function getConfig(type) {
+  const db = context.getGlobalDB();
+  try {
+    return await db.get(generateConfigID(type));
+  } catch (e) {
+    if (e.status === 404) {
+      return;
+    }
+    throw e;
+  }
+}
+async function save(config) {
+  const db = context.getGlobalDB();
+  return db.put(config);
+}
+async function getSettingsConfigDoc() {
+  let config = await getConfig(import_types.ConfigType.SETTINGS);
+  if (!config) {
+    config = {
+      _id: generateConfigID(import_types.ConfigType.SETTINGS),
+      type: import_types.ConfigType.SETTINGS,
+      config: {}
+    };
+  }
+  config.config.platformUrl = await getPlatformUrl({
+    tenantAware: true,
+    config: config.config
+  });
+  config.config.analyticsEnabled = await analyticsEnabled({
+    config: config.config
+  });
+  return config;
+}
+async function getSettingsConfig() {
+  return (await getSettingsConfigDoc()).config;
+}
+async function getPlatformUrl(opts = {
+  tenantAware: true
+}) {
+  let platformUrl = import_environment.default.PLATFORM_URL || "http://localhost:10000";
+  if (!import_environment.default.SELF_HOSTED && import_environment.default.MULTI_TENANCY && opts.tenantAware) {
+    const tenantId = context.getTenantId();
+    if (!platformUrl.includes("localhost:")) {
+      platformUrl = platformUrl.replace("://", `://${tenantId}.`);
+    }
+  } else if (import_environment.default.SELF_HOSTED) {
+    const config = opts?.config ? opts.config : (
+      // direct to db to prevent infinite loop
+      (await getConfig(import_types.ConfigType.SETTINGS))?.config
+    );
+    if (config?.platformUrl) {
+      platformUrl = config.platformUrl;
+    }
+  }
+  return platformUrl;
+}
+const analyticsEnabled = async (opts) => {
+  if (!import_environment.default.SELF_HOSTED) {
+    return !!import_environment.default.ENABLE_ANALYTICS;
+  }
+  const enabledInDB = await (0, import_cache.withCache)(
+    import_cache.CacheKey.ANALYTICS_ENABLED,
+    import_cache.TTL.ONE_DAY,
+    async () => {
+      const config = opts?.config ? opts.config : (
+        // direct to db to prevent infinite loop
+        (await getConfig(import_types.ConfigType.SETTINGS))?.config
+      );
+      if (config?.analyticsEnabled === false) {
+        return false;
+      } else if (config?.analyticsEnabled === true) {
+        return true;
+      }
+    }
+  );
+  if (enabledInDB !== void 0) {
+    return enabledInDB;
+  }
+  const envEnabled = import_environment.default.ENABLE_ANALYTICS;
+  if (envEnabled === 0 || envEnabled === false) {
+    return false;
+  } else {
+    return true;
+  }
+};
+async function getGoogleConfigDoc() {
+  return await getConfig(import_types.ConfigType.GOOGLE);
+}
+async function getGoogleConfig() {
+  const config = await getGoogleConfigDoc();
+  return config?.config;
+}
+async function getGoogleDatasourceConfig() {
+  if (!import_environment.default.SELF_HOSTED) {
+    return getDefaultGoogleConfig();
+  }
+  let config = await getGoogleConfig();
+  if (!config || !config.activated) {
+    config = getDefaultGoogleConfig();
+  }
+  return config;
+}
+function getDefaultGoogleConfig() {
+  if (import_environment2.default.GOOGLE_CLIENT_ID && import_environment2.default.GOOGLE_CLIENT_SECRET) {
+    return {
+      clientID: import_environment2.default.GOOGLE_CLIENT_ID,
+      clientSecret: import_environment2.default.GOOGLE_CLIENT_SECRET,
+      activated: true
+    };
+  }
+}
+async function getOIDCLogosDoc() {
+  return getConfig(import_types.ConfigType.OIDC_LOGOS);
+}
+async function getOIDCConfigDoc() {
+  return getConfig(import_types.ConfigType.OIDC);
+}
+async function getOIDCConfig() {
+  const config = (await getOIDCConfigDoc())?.config;
+  return config?.configs && config.configs[0];
+}
+async function getOIDCConfigById(configId) {
+  const config = (await getConfig(import_types.ConfigType.OIDC))?.config;
+  return config && config.configs.filter((c) => c.uuid === configId)[0];
+}
+async function getSMTPConfigDoc() {
+  return getConfig(import_types.ConfigType.SMTP);
+}
+async function getSMTPConfig(isAutomation) {
+  const config = await getSMTPConfigDoc();
+  if (config) {
+    return config.config;
+  }
+  const allowFallback = import_environment.default.SELF_HOSTED || !isAutomation;
+  if (import_environment.default.SMTP_FALLBACK_ENABLED && allowFallback) {
+    return {
+      port: import_environment.default.SMTP_PORT,
+      host: import_environment.default.SMTP_HOST,
+      secure: false,
+      from: import_environment.default.SMTP_FROM_ADDRESS,
+      auth: {
+        user: import_environment.default.SMTP_USER,
+        pass: import_environment.default.SMTP_PASSWORD
+      }
+    };
+  }
+}
+async function getSCIMConfig() {
+  const config = await getConfig(import_types.ConfigType.SCIM);
+  return config?.config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyticsEnabled,
+  generateConfigID,
+  getConfig,
+  getDefaultGoogleConfig,
+  getGoogleConfig,
+  getGoogleDatasourceConfig,
+  getOIDCConfig,
+  getOIDCConfigById,
+  getOIDCLogosDoc,
+  getPlatformUrl,
+  getSCIMConfig,
+  getSMTPConfig,
+  getSMTPConfigDoc,
+  getSettingsConfig,
+  getSettingsConfigDoc,
+  save
+});
+//# sourceMappingURL=configs.js.map