@budibase/backend-core 2.9.38 → 2.9.39-alpha.1

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

package/dist/src/configs/configs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/configs/configs.ts"],
+  "sourcesContent": ["import {\n  Config,\n  ConfigType,\n  GoogleConfig,\n  GoogleInnerConfig,\n  OIDCConfig,\n  OIDCInnerConfig,\n  OIDCLogosConfig,\n  SCIMConfig,\n  SCIMInnerConfig,\n  SettingsConfig,\n  SettingsInnerConfig,\n  SMTPConfig,\n  SMTPInnerConfig,\n} from \"@budibase/types\"\nimport { DocumentType, SEPARATOR } from \"../constants\"\nimport { CacheKey, TTL, withCache } from \"../cache\"\nimport * as context from \"../context\"\nimport env from \"../environment\"\nimport environment from \"../environment\"\n\n// UTILS\n\n/**\n * Generates a new configuration ID.\n * @returns {string} The new configuration ID which the config doc can be stored under.\n */\nexport function generateConfigID(type: ConfigType) {\n  return `${DocumentType.CONFIG}${SEPARATOR}${type}`\n}\n\nexport async function getConfig<T extends Config>(\n  type: ConfigType\n): Promise<T | undefined> {\n  const db = context.getGlobalDB()\n  try {\n    // await to catch error\n    return (await db.get(generateConfigID(type))) as T\n  } catch (e: any) {\n    if (e.status === 404) {\n      return\n    }\n    throw e\n  }\n}\n\nexport async function save(\n  config: Config\n): Promise<{ id: string; rev: string }> {\n  const db = context.getGlobalDB()\n  return db.put(config)\n}\n\n// SETTINGS\n\nexport async function getSettingsConfigDoc(): Promise<SettingsConfig> {\n  let config = await getConfig<SettingsConfig>(ConfigType.SETTINGS)\n\n  if (!config) {\n    config = {\n      _id: generateConfigID(ConfigType.SETTINGS),\n      type: ConfigType.SETTINGS,\n      config: {},\n    }\n  }\n\n  // overridden fields\n  config.config.platformUrl = await getPlatformUrl({\n    tenantAware: true,\n    config: config.config,\n  })\n  config.config.analyticsEnabled = await analyticsEnabled({\n    config: config.config,\n  })\n\n  return config\n}\n\nexport async function getSettingsConfig(): Promise<SettingsInnerConfig> {\n  return (await getSettingsConfigDoc()).config\n}\n\nexport async function getPlatformUrl(\n  opts: { tenantAware: boolean; config?: SettingsInnerConfig } = {\n    tenantAware: true,\n  }\n) {\n  let platformUrl = env.PLATFORM_URL || \"http://localhost:10000\"\n\n  if (!env.SELF_HOSTED && env.MULTI_TENANCY && opts.tenantAware) {\n    // cloud and multi tenant - add the tenant to the default platform url\n    const tenantId = context.getTenantId()\n    if (!platformUrl.includes(\"localhost:\")) {\n      platformUrl = platformUrl.replace(\"://\", `://${tenantId}.`)\n    }\n  } else if (env.SELF_HOSTED) {\n    const config = opts?.config\n      ? opts.config\n      : // direct to db to prevent infinite loop\n        (await getConfig<SettingsConfig>(ConfigType.SETTINGS))?.config\n    if (config?.platformUrl) {\n      platformUrl = config.platformUrl\n    }\n  }\n\n  return platformUrl\n}\n\nexport const analyticsEnabled = async (opts?: {\n  config?: SettingsInnerConfig\n}) => {\n  // cloud - always use the environment variable\n  if (!env.SELF_HOSTED) {\n    return !!env.ENABLE_ANALYTICS\n  }\n\n  // self host - prefer the settings doc\n  // use cache as events have high throughput\n  const enabledInDB = await withCache(\n    CacheKey.ANALYTICS_ENABLED,\n    TTL.ONE_DAY,\n    async () => {\n      const config = opts?.config\n        ? opts.config\n        : // direct to db to prevent infinite loop\n          (await getConfig<SettingsConfig>(ConfigType.SETTINGS))?.config\n\n      // need to do explicit checks in case the field is not set\n      if (config?.analyticsEnabled === false) {\n        return false\n      } else if (config?.analyticsEnabled === true) {\n        return true\n      }\n    }\n  )\n\n  if (enabledInDB !== undefined) {\n    return enabledInDB\n  }\n\n  // fallback to the environment variable\n  // explicitly check for 0 or false here, undefined or otherwise is treated as true\n  const envEnabled: any = env.ENABLE_ANALYTICS\n  if (envEnabled === 0 || envEnabled === false) {\n    return false\n  } else {\n    return true\n  }\n}\n\n// GOOGLE\n\nasync function getGoogleConfigDoc(): Promise<GoogleConfig | undefined> {\n  return await getConfig<GoogleConfig>(ConfigType.GOOGLE)\n}\n\nexport async function getGoogleConfig(): Promise<\n  GoogleInnerConfig | undefined\n> {\n  const config = await getGoogleConfigDoc()\n  return config?.config\n}\n\nexport async function getGoogleDatasourceConfig(): Promise<\n  GoogleInnerConfig | undefined\n> {\n  if (!env.SELF_HOSTED) {\n    // always use the env vars in cloud\n    return getDefaultGoogleConfig()\n  }\n\n  // prefer the config in self-host\n  let config = await getGoogleConfig()\n\n  // fallback to env vars\n  if (!config || !config.activated) {\n    config = getDefaultGoogleConfig()\n  }\n\n  return config\n}\n\nexport function getDefaultGoogleConfig(): GoogleInnerConfig | undefined {\n  if (environment.GOOGLE_CLIENT_ID && environment.GOOGLE_CLIENT_SECRET) {\n    return {\n      clientID: environment.GOOGLE_CLIENT_ID!,\n      clientSecret: environment.GOOGLE_CLIENT_SECRET!,\n      activated: true,\n    }\n  }\n}\n\n// OIDC\n\nexport async function getOIDCLogosDoc(): Promise<OIDCLogosConfig | undefined> {\n  return getConfig<OIDCLogosConfig>(ConfigType.OIDC_LOGOS)\n}\n\nasync function getOIDCConfigDoc(): Promise<OIDCConfig | undefined> {\n  return getConfig<OIDCConfig>(ConfigType.OIDC)\n}\n\nexport async function getOIDCConfig(): Promise<OIDCInnerConfig | undefined> {\n  const config = (await getOIDCConfigDoc())?.config\n  // default to the 0th config\n  return config?.configs && config.configs[0]\n}\n\n/**\n * @param configId The config id of the inner config to retrieve\n */\nexport async function getOIDCConfigById(\n  configId: string\n): Promise<OIDCInnerConfig | undefined> {\n  const config = (await getConfig<OIDCConfig>(ConfigType.OIDC))?.config\n  return config && config.configs.filter((c: any) => c.uuid === configId)[0]\n}\n\n// SMTP\n\nexport async function getSMTPConfigDoc(): Promise<SMTPConfig | undefined> {\n  return getConfig<SMTPConfig>(ConfigType.SMTP)\n}\n\nexport async function getSMTPConfig(\n  isAutomation?: boolean\n): Promise<SMTPInnerConfig | undefined> {\n  const config = await getSMTPConfigDoc()\n  if (config) {\n    return config.config\n  }\n\n  // always allow fallback in self host\n  // in cloud don't allow for automations\n  const allowFallback = env.SELF_HOSTED || !isAutomation\n\n  // Use an SMTP fallback configuration from env variables\n  if (env.SMTP_FALLBACK_ENABLED && allowFallback) {\n    return {\n      port: env.SMTP_PORT,\n      host: env.SMTP_HOST!,\n      secure: false,\n      from: env.SMTP_FROM_ADDRESS!,\n      auth: {\n        user: env.SMTP_USER!,\n        pass: env.SMTP_PASSWORD!,\n      },\n    }\n  }\n}\n\n// SCIM\n\nexport async function getSCIMConfig(): Promise<SCIMInnerConfig | undefined> {\n  const config = await getConfig<SCIMConfig>(ConfigType.SCIM)\n  return config?.config\n}\n"],
+  "mappings": "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",
+  "names": ["import_environment", "env", "environment"]
+}

package/dist/src/configs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configs_exports = {};
+module.exports = __toCommonJS(configs_exports);
+__reExport(configs_exports, require("./configs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./configs")
+});
+//# sourceMappingURL=index.js.map

package/dist/src/configs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/configs/index.ts"],
+  "sourcesContent": ["export * from \"./configs\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,4BAAc,sBAAd;",
+  "names": []
+}