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

package/dist/src/events/identification.js

@@ -0,0 +1,275 @@
+"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 identification_exports = {};
+__export(identification_exports, {
+  default: () => identification_default,
+  getUniqueTenantId: () => getUniqueTenantId
+});
+module.exports = __toCommonJS(identification_exports);
+var context = __toESM(require("../context"));
+var identityCtx = __toESM(require("../context/identity"));
+var import_environment = __toESM(require("../environment"));
+var import_types = require("@budibase/types");
+var import_processors = require("./processors");
+var import_utils = require("../utils");
+var installation = __toESM(require("../installation"));
+var configs = __toESM(require("../configs"));
+var users = __toESM(require("../users"));
+var import_generic = require("../cache/generic");
+const getCurrentIdentity = async () => {
+  let identityContext = identityCtx.getIdentity();
+  const environment = getDeploymentEnvironment();
+  let identityType;
+  if (!identityContext) {
+    identityType = import_types.IdentityType.TENANT;
+  } else {
+    identityType = identityContext.type;
+  }
+  if (identityType === import_types.IdentityType.INSTALLATION) {
+    const installationId = await getInstallationId();
+    const hosting = getHostingFromEnv();
+    return {
+      id: formatDistinctId(installationId, identityType),
+      hosting,
+      type: identityType,
+      installationId,
+      environment
+    };
+  } else if (identityType === import_types.IdentityType.TENANT) {
+    const installationId = await getInstallationId();
+    const tenantId = await getEventTenantId(context.getTenantId());
+    const hosting = getHostingFromEnv();
+    return {
+      id: formatDistinctId(tenantId, identityType),
+      type: identityType,
+      hosting,
+      installationId,
+      tenantId,
+      realTenantId: context.getTenantId(),
+      environment
+    };
+  } else if (identityType === import_types.IdentityType.USER) {
+    const userContext = identityContext;
+    const tenantId = await getEventTenantId(context.getTenantId());
+    const installationId = await getInstallationId();
+    const account = userContext.account;
+    let hosting;
+    if (account) {
+      hosting = account.hosting;
+    } else {
+      hosting = getHostingFromEnv();
+    }
+    return {
+      id: userContext._id,
+      type: identityType,
+      hosting,
+      installationId,
+      tenantId,
+      environment,
+      realTenantId: context.getTenantId(),
+      hostInfo: userContext.hostInfo
+    };
+  } else {
+    throw new Error("Unknown identity type");
+  }
+};
+const identifyInstallationGroup = async (installId, timestamp) => {
+  const id = installId;
+  const type = import_types.IdentityType.INSTALLATION;
+  const hosting = getHostingFromEnv();
+  const version = import_environment.default.VERSION;
+  const environment = getDeploymentEnvironment();
+  const group = {
+    id,
+    type,
+    hosting,
+    version,
+    environment
+  };
+  await identifyGroup(group, timestamp);
+  await identify({ ...group, id: `$${type}_${id}` }, timestamp);
+};
+const identifyTenantGroup = async (tenantId, account, timestamp) => {
+  const id = await getEventTenantId(tenantId);
+  const type = import_types.IdentityType.TENANT;
+  const installationId = await getInstallationId();
+  const environment = getDeploymentEnvironment();
+  let hosting;
+  let profession;
+  let companySize;
+  if (account) {
+    profession = account.profession;
+    companySize = account.size;
+    hosting = account.hosting;
+  } else {
+    hosting = getHostingFromEnv();
+  }
+  const group = {
+    id,
+    type,
+    hosting,
+    environment,
+    installationId,
+    profession,
+    companySize
+  };
+  await identifyGroup(group, timestamp);
+  await identify({ ...group, id: `$${type}_${id}` }, timestamp);
+};
+const identifyUser = async (user, account, timestamp) => {
+  const id = user._id;
+  const tenantId = await getEventTenantId(user.tenantId);
+  const type = import_types.IdentityType.USER;
+  let builder = users.hasBuilderPermissions(user);
+  let admin = users.hasAdminPermissions(user);
+  let providerType;
+  if ((0, import_types.isSSOUser)(user)) {
+    providerType = user.providerType;
+  }
+  const accountHolder = account?.budibaseUserId === user._id || false;
+  const verified = account && account?.budibaseUserId === user._id ? account.verified : false;
+  const installationId = await getInstallationId();
+  const hosting = account ? account.hosting : getHostingFromEnv();
+  const environment = getDeploymentEnvironment();
+  const identity = {
+    id,
+    type,
+    hosting,
+    installationId,
+    tenantId,
+    verified,
+    accountHolder,
+    providerType,
+    builder,
+    admin,
+    environment
+  };
+  await identify(identity, timestamp);
+};
+const identifyAccount = async (account) => {
+  let id = account.accountId;
+  const tenantId = account.tenantId;
+  let type = import_types.IdentityType.USER;
+  let providerType = (0, import_types.isSSOAccount)(account) ? account.providerType : void 0;
+  const verified = account.verified;
+  const accountHolder = true;
+  const hosting = account.hosting;
+  const installationId = await getInstallationId();
+  const environment = getDeploymentEnvironment();
+  if ((0, import_types.isCloudAccount)(account)) {
+    if (account.budibaseUserId) {
+      id = account.budibaseUserId;
+    }
+  }
+  const identity = {
+    id,
+    type,
+    hosting,
+    installationId,
+    tenantId,
+    providerType,
+    verified,
+    accountHolder,
+    environment
+  };
+  await identify(identity);
+};
+const identify = async (identity, timestamp) => {
+  await import_processors.processors.identify(identity, timestamp);
+};
+const identifyGroup = async (group, timestamp) => {
+  await import_processors.processors.identifyGroup(group, timestamp);
+};
+const getDeploymentEnvironment = () => {
+  if (import_environment.default.isDev()) {
+    return "development";
+  } else {
+    return import_environment.default.DEPLOYMENT_ENVIRONMENT;
+  }
+};
+const getHostingFromEnv = () => {
+  return import_environment.default.SELF_HOSTED ? import_types.Hosting.SELF : import_types.Hosting.CLOUD;
+};
+const getInstallationId = async () => {
+  if (isAccountPortal()) {
+    return "account-portal";
+  }
+  const install = await installation.getInstall();
+  return install.installId;
+};
+const getEventTenantId = async (tenantId) => {
+  if (import_environment.default.SELF_HOSTED) {
+    return getUniqueTenantId(tenantId);
+  } else {
+    return tenantId;
+  }
+};
+const getUniqueTenantId = async (tenantId) => {
+  return context.doInTenant(tenantId, () => {
+    return (0, import_generic.withCache)(import_generic.CacheKey.UNIQUE_TENANT_ID, import_generic.TTL.ONE_DAY, async () => {
+      const db = context.getGlobalDB();
+      const config = await configs.getSettingsConfigDoc();
+      let uniqueTenantId;
+      if (config.config.uniqueTenantId) {
+        return config.config.uniqueTenantId;
+      } else {
+        uniqueTenantId = `${(0, import_utils.newid)()}_${tenantId}`;
+        config.config.uniqueTenantId = uniqueTenantId;
+        await db.put(config);
+        return uniqueTenantId;
+      }
+    });
+  });
+};
+const isAccountPortal = () => {
+  return import_environment.default.SERVICE === "account-portal";
+};
+const formatDistinctId = (id, type) => {
+  if (type === import_types.IdentityType.INSTALLATION || type === import_types.IdentityType.TENANT) {
+    return `$${type}_${id}`;
+  } else {
+    return id;
+  }
+};
+var identification_default = {
+  getCurrentIdentity,
+  identifyInstallationGroup,
+  identifyTenantGroup,
+  identifyUser,
+  identifyAccount,
+  identify,
+  identifyGroup,
+  getInstallationId,
+  getUniqueTenantId
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUniqueTenantId
+});
+//# sourceMappingURL=identification.js.map

package/dist/src/events/identification.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/events/identification.ts"],
+  "sourcesContent": ["import * as context from \"../context\"\nimport * as identityCtx from \"../context/identity\"\nimport env from \"../environment\"\nimport {\n  Hosting,\n  User,\n  Identity,\n  IdentityType,\n  Account,\n  isCloudAccount,\n  isSSOAccount,\n  TenantGroup,\n  CloudAccount,\n  UserIdentity,\n  InstallationGroup,\n  UserContext,\n  Group,\n  isSSOUser,\n} from \"@budibase/types\"\nimport { processors } from \"./processors\"\nimport { newid } from \"../utils\"\nimport * as installation from \"../installation\"\nimport * as configs from \"../configs\"\nimport * as users from \"../users\"\nimport { withCache, TTL, CacheKey } from \"../cache/generic\"\n\n/**\n * An identity can be:\n * - account user (Self host)\n * - budibase user\n * - tenant\n * - installation\n */\nconst getCurrentIdentity = async (): Promise<Identity> => {\n  let identityContext = identityCtx.getIdentity()\n  const environment = getDeploymentEnvironment()\n\n  let identityType\n\n  if (!identityContext) {\n    identityType = IdentityType.TENANT\n  } else {\n    identityType = identityContext.type\n  }\n\n  if (identityType === IdentityType.INSTALLATION) {\n    const installationId = await getInstallationId()\n    const hosting = getHostingFromEnv()\n    return {\n      id: formatDistinctId(installationId, identityType),\n      hosting,\n      type: identityType,\n      installationId,\n      environment,\n    }\n  } else if (identityType === IdentityType.TENANT) {\n    const installationId = await getInstallationId()\n    const tenantId = await getEventTenantId(context.getTenantId())\n    const hosting = getHostingFromEnv()\n\n    return {\n      id: formatDistinctId(tenantId, identityType),\n      type: identityType,\n      hosting,\n      installationId,\n      tenantId,\n      realTenantId: context.getTenantId(),\n      environment,\n    }\n  } else if (identityType === IdentityType.USER) {\n    const userContext = identityContext as UserContext\n    const tenantId = await getEventTenantId(context.getTenantId())\n    const installationId = await getInstallationId()\n\n    const account = userContext.account\n    let hosting\n    if (account) {\n      hosting = account.hosting\n    } else {\n      hosting = getHostingFromEnv()\n    }\n\n    return {\n      id: userContext._id,\n      type: identityType,\n      hosting,\n      installationId,\n      tenantId,\n      environment,\n      realTenantId: context.getTenantId(),\n      hostInfo: userContext.hostInfo,\n    }\n  } else {\n    throw new Error(\"Unknown identity type\")\n  }\n}\n\nconst identifyInstallationGroup = async (\n  installId: string,\n  timestamp?: string | number\n): Promise<void> => {\n  const id = installId\n  const type = IdentityType.INSTALLATION\n  const hosting = getHostingFromEnv()\n  const version = env.VERSION\n  const environment = getDeploymentEnvironment()\n\n  const group: InstallationGroup = {\n    id,\n    type,\n    hosting,\n    version,\n    environment,\n  }\n\n  await identifyGroup(group, timestamp)\n  // need to create a normal identity for the group to be able to query it globally\n  // match the posthog syntax to link this identity to the empty auto generated one\n  await identify({ ...group, id: `$${type}_${id}` }, timestamp)\n}\n\nconst identifyTenantGroup = async (\n  tenantId: string,\n  account: Account | undefined,\n  timestamp?: string | number\n): Promise<void> => {\n  const id = await getEventTenantId(tenantId)\n  const type = IdentityType.TENANT\n  const installationId = await getInstallationId()\n  const environment = getDeploymentEnvironment()\n\n  let hosting: Hosting\n  let profession: string | undefined\n  let companySize: string | undefined\n\n  if (account) {\n    profession = account.profession\n    companySize = account.size\n    hosting = account.hosting\n  } else {\n    hosting = getHostingFromEnv()\n  }\n\n  const group: TenantGroup = {\n    id,\n    type,\n    hosting,\n    environment,\n    installationId,\n    profession,\n    companySize,\n  }\n\n  await identifyGroup(group, timestamp)\n  // need to create a normal identity for the group to be able to query it globally\n  // match the posthog syntax to link this identity to the auto generated one\n  await identify({ ...group, id: `$${type}_${id}` }, timestamp)\n}\n\nconst identifyUser = async (\n  user: User,\n  account: CloudAccount | undefined,\n  timestamp?: string | number\n) => {\n  const id = user._id as string\n  const tenantId = await getEventTenantId(user.tenantId)\n  const type = IdentityType.USER\n  let builder = users.hasBuilderPermissions(user)\n  let admin = users.hasAdminPermissions(user)\n  let providerType\n  if (isSSOUser(user)) {\n    providerType = user.providerType\n  }\n  const accountHolder = account?.budibaseUserId === user._id || false\n  const verified =\n    account && account?.budibaseUserId === user._id ? account.verified : false\n  const installationId = await getInstallationId()\n  const hosting = account ? account.hosting : getHostingFromEnv()\n  const environment = getDeploymentEnvironment()\n\n  const identity: UserIdentity = {\n    id,\n    type,\n    hosting,\n    installationId,\n    tenantId,\n    verified,\n    accountHolder,\n    providerType,\n    builder,\n    admin,\n    environment,\n  }\n\n  await identify(identity, timestamp)\n}\n\nconst identifyAccount = async (account: Account) => {\n  let id = account.accountId\n  const tenantId = account.tenantId\n  let type = IdentityType.USER\n  let providerType = isSSOAccount(account) ? account.providerType : undefined\n  const verified = account.verified\n  const accountHolder = true\n  const hosting = account.hosting\n  const installationId = await getInstallationId()\n  const environment = getDeploymentEnvironment()\n\n  if (isCloudAccount(account)) {\n    if (account.budibaseUserId) {\n      // use the budibase user as the id if set\n      id = account.budibaseUserId\n    }\n  }\n\n  const identity: UserIdentity = {\n    id,\n    type,\n    hosting,\n    installationId,\n    tenantId,\n    providerType,\n    verified,\n    accountHolder,\n    environment,\n  }\n\n  await identify(identity)\n}\n\nconst identify = async (identity: Identity, timestamp?: string | number) => {\n  await processors.identify(identity, timestamp)\n}\n\nconst identifyGroup = async (group: Group, timestamp?: string | number) => {\n  await processors.identifyGroup(group, timestamp)\n}\n\nconst getDeploymentEnvironment = () => {\n  if (env.isDev()) {\n    return \"development\"\n  } else {\n    return env.DEPLOYMENT_ENVIRONMENT\n  }\n}\n\nconst getHostingFromEnv = () => {\n  return env.SELF_HOSTED ? Hosting.SELF : Hosting.CLOUD\n}\n\nconst getInstallationId = async () => {\n  if (isAccountPortal()) {\n    return \"account-portal\"\n  }\n  const install = await installation.getInstall()\n  return install.installId\n}\n\nconst getEventTenantId = async (tenantId: string): Promise<string> => {\n  if (env.SELF_HOSTED) {\n    return getUniqueTenantId(tenantId)\n  } else {\n    // tenant id's in the cloud are already unique\n    return tenantId\n  }\n}\n\nexport const getUniqueTenantId = async (tenantId: string): Promise<string> => {\n  // make sure this tenantId always matches the tenantId in context\n  return context.doInTenant(tenantId, () => {\n    return withCache(CacheKey.UNIQUE_TENANT_ID, TTL.ONE_DAY, async () => {\n      const db = context.getGlobalDB()\n      const config = await configs.getSettingsConfigDoc()\n\n      let uniqueTenantId: string\n      if (config.config.uniqueTenantId) {\n        return config.config.uniqueTenantId\n      } else {\n        uniqueTenantId = `${newid()}_${tenantId}`\n        config.config.uniqueTenantId = uniqueTenantId\n        await db.put(config)\n        return uniqueTenantId\n      }\n    })\n  })\n}\n\nconst isAccountPortal = () => {\n  return env.SERVICE === \"account-portal\"\n}\n\nconst formatDistinctId = (id: string, type: IdentityType) => {\n  if (type === IdentityType.INSTALLATION || type === IdentityType.TENANT) {\n    return `$${type}_${id}`\n  } else {\n    return id\n  }\n}\n\nexport default {\n  getCurrentIdentity,\n  identifyInstallationGroup,\n  identifyTenantGroup,\n  identifyUser,\n  identifyAccount,\n  identify,\n  identifyGroup,\n  getInstallationId,\n  getUniqueTenantId,\n}\n"],
+  "mappings": "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",
+  "names": ["env"]
+}

package/dist/src/events/index.js

@@ -0,0 +1,62 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 events_exports = {};
+__export(events_exports, {
+  analytics: () => analytics,
+  backfillCache: () => backfillCache,
+  identification: () => import_identification.default,
+  initAsyncEvents: () => initAsyncEvents,
+  processors: () => processors,
+  shutdown: () => shutdown
+});
+module.exports = __toCommonJS(events_exports);
+__reExport(events_exports, require("./publishers"), module.exports);
+var processors = __toESM(require("./processors"));
+var analytics = __toESM(require("./analytics"));
+var import_identification = __toESM(require("./identification"));
+var backfillCache = __toESM(require("./backfill"));
+var import_processors = require("./processors");
+function initAsyncEvents() {
+}
+const shutdown = () => {
+  import_processors.processors.shutdown();
+  console.log("Events shutdown");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analytics,
+  backfillCache,
+  identification,
+  initAsyncEvents,
+  processors,
+  shutdown,
+  ...require("./publishers")
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/events/index.ts"],
+  "sourcesContent": ["export * from \"./publishers\"\nexport * as processors from \"./processors\"\nexport * as analytics from \"./analytics\"\nexport { default as identification } from \"./identification\"\nexport * as backfillCache from \"./backfill\"\n\nimport { processors } from \"./processors\"\n\nexport function initAsyncEvents() {}\n\nexport const shutdown = () => {\n  processors.shutdown()\n  console.log(\"Events shutdown\")\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAAc,yBAAd;AACA,iBAA4B;AAC5B,gBAA2B;AAC3B,4BAA0C;AAC1C,oBAA+B;AAE/B,wBAA2B;AAEpB,SAAS,kBAAkB;AAAC;AAE5B,MAAM,WAAW,MAAM;AAC5B,+BAAW,SAAS;AACpB,UAAQ,IAAI,iBAAiB;AAC/B;",
+  "names": []
+}

package/dist/src/events/processors/AnalyticsProcessor.js

@@ -0,0 +1,76 @@
+"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 AnalyticsProcessor_exports = {};
+__export(AnalyticsProcessor_exports, {
+  default: () => AnalyticsProcessor
+});
+module.exports = __toCommonJS(AnalyticsProcessor_exports);
+var import_types = require("@budibase/types");
+var import_environment = __toESM(require("../../environment"));
+var analytics = __toESM(require("../analytics"));
+var import_posthog = __toESM(require("./posthog"));
+const EVENT_WHITELIST = [
+  import_types.Event.INSTALLATION_VERSION_UPGRADED,
+  import_types.Event.INSTALLATION_VERSION_DOWNGRADED
+];
+const IDENTITY_WHITELIST = [import_types.IdentityType.INSTALLATION, import_types.IdentityType.TENANT];
+class AnalyticsProcessor {
+  constructor() {
+    if (import_environment.default.POSTHOG_TOKEN && !import_environment.default.isTest()) {
+      this.posthog = new import_posthog.default(import_environment.default.POSTHOG_TOKEN);
+    }
+  }
+  async processEvent(event, identity, properties, timestamp) {
+    if (!EVENT_WHITELIST.includes(event) && !await analytics.enabled()) {
+      return;
+    }
+    if (this.posthog) {
+      await this.posthog.processEvent(event, identity, properties, timestamp);
+    }
+  }
+  async identify(identity, timestamp) {
+    if (!IDENTITY_WHITELIST.includes(identity.type) && !await analytics.enabled()) {
+      return;
+    }
+    if (this.posthog) {
+      await this.posthog.identify(identity, timestamp);
+    }
+  }
+  async identifyGroup(group, timestamp) {
+    if (this.posthog) {
+      await this.posthog.identifyGroup(group, timestamp);
+    }
+  }
+  shutdown() {
+    if (this.posthog) {
+      this.posthog.shutdown();
+    }
+  }
+}
+//# sourceMappingURL=AnalyticsProcessor.js.map

package/dist/src/events/processors/AnalyticsProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/events/processors/AnalyticsProcessor.ts"],
+  "sourcesContent": ["import { Event, Identity, Group, IdentityType } from \"@budibase/types\"\nimport { EventProcessor } from \"./types\"\nimport env from \"../../environment\"\nimport * as analytics from \"../analytics\"\nimport PosthogProcessor from \"./posthog\"\n\n/**\n * Events that are always captured.\n */\nconst EVENT_WHITELIST = [\n  Event.INSTALLATION_VERSION_UPGRADED,\n  Event.INSTALLATION_VERSION_DOWNGRADED,\n]\nconst IDENTITY_WHITELIST = [IdentityType.INSTALLATION, IdentityType.TENANT]\n\nexport default class AnalyticsProcessor implements EventProcessor {\n  posthog: PosthogProcessor | undefined\n\n  constructor() {\n    if (env.POSTHOG_TOKEN && !env.isTest()) {\n      this.posthog = new PosthogProcessor(env.POSTHOG_TOKEN)\n    }\n  }\n\n  async processEvent(\n    event: Event,\n    identity: Identity,\n    properties: any,\n    timestamp?: string | number\n  ): Promise<void> {\n    if (!EVENT_WHITELIST.includes(event) && !(await analytics.enabled())) {\n      return\n    }\n    if (this.posthog) {\n      await this.posthog.processEvent(event, identity, properties, timestamp)\n    }\n  }\n\n  async identify(identity: Identity, timestamp?: string | number) {\n    // Group indentifications (tenant and installation) always on\n    if (\n      !IDENTITY_WHITELIST.includes(identity.type) &&\n      !(await analytics.enabled())\n    ) {\n      return\n    }\n    if (this.posthog) {\n      await this.posthog.identify(identity, timestamp)\n    }\n  }\n\n  async identifyGroup(group: Group, timestamp?: string | number) {\n    // Group indentifications (tenant and installation) always on\n    if (this.posthog) {\n      await this.posthog.identifyGroup(group, timestamp)\n    }\n  }\n\n  shutdown() {\n    if (this.posthog) {\n      this.posthog.shutdown()\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAqD;AAErD,yBAAgB;AAChB,gBAA2B;AAC3B,qBAA6B;AAK7B,MAAM,kBAAkB;AAAA,EACtB,mBAAM;AAAA,EACN,mBAAM;AACR;AACA,MAAM,qBAAqB,CAAC,0BAAa,cAAc,0BAAa,MAAM;AAE1E,MAAO,mBAA2D;AAAA,EAGhE,cAAc;AACZ,QAAI,mBAAAA,QAAI,iBAAiB,CAAC,mBAAAA,QAAI,OAAO,GAAG;AACtC,WAAK,UAAU,IAAI,eAAAC,QAAiB,mBAAAD,QAAI,aAAa;AAAA,IACvD;AAAA,EACF;AAAA,EAEA,MAAM,aACJ,OACA,UACA,YACA,WACe;AACf,QAAI,CAAC,gBAAgB,SAAS,KAAK,KAAK,CAAE,MAAM,UAAU,QAAQ,GAAI;AACpE;AAAA,IACF;AACA,QAAI,KAAK,SAAS;AAChB,YAAM,KAAK,QAAQ,aAAa,OAAO,UAAU,YAAY,SAAS;AAAA,IACxE;AAAA,EACF;AAAA,EAEA,MAAM,SAAS,UAAoB,WAA6B;AAE9D,QACE,CAAC,mBAAmB,SAAS,SAAS,IAAI,KAC1C,CAAE,MAAM,UAAU,QAAQ,GAC1B;AACA;AAAA,IACF;AACA,QAAI,KAAK,SAAS;AAChB,YAAM,KAAK,QAAQ,SAAS,UAAU,SAAS;AAAA,IACjD;AAAA,EACF;AAAA,EAEA,MAAM,cAAc,OAAc,WAA6B;AAE7D,QAAI,KAAK,SAAS;AAChB,YAAM,KAAK,QAAQ,cAAc,OAAO,SAAS;AAAA,IACnD;AAAA,EACF;AAAA,EAEA,WAAW;AACT,QAAI,KAAK,SAAS;AAChB,WAAK,QAAQ,SAAS;AAAA,IACxB;AAAA,EACF;AACF;",
+  "names": ["env", "PosthogProcessor"]
+}

package/dist/src/events/processors/AuditLogsProcessor.js

@@ -0,0 +1,97 @@
+"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 AuditLogsProcessor_exports = {};
+__export(AuditLogsProcessor_exports, {
+  default: () => AuditLogsProcessor
+});
+module.exports = __toCommonJS(AuditLogsProcessor_exports);
+var import_types = require("@budibase/types");
+var import_context = require("../../context");
+var import_queue = require("../../queue");
+var import_utils = require("../../utils");
+var import_environment = __toESM(require("../../environment"));
+class AuditLogsProcessor {
+  static {
+    this.auditLogsEnabled = false;
+  }
+  // can't use constructor as need to return promise
+  static init(fn) {
+    AuditLogsProcessor.auditLogsEnabled = true;
+    const writeAuditLogs = fn;
+    AuditLogsProcessor.auditLogQueue = (0, import_queue.createQueue)(
+      import_queue.JobQueue.AUDIT_LOG
+    );
+    return AuditLogsProcessor.auditLogQueue.process(async (job) => {
+      return (0, import_context.doInTenant)(job.data.tenantId, async () => {
+        let properties = job.data.properties;
+        if (properties.audited) {
+          properties = {
+            ...properties,
+            ...properties.audited
+          };
+          delete properties.audited;
+        }
+        let hostInfo = {};
+        if (import_environment.default.ENABLE_AUDIT_LOG_IP_ADDR) {
+          hostInfo = job.data.opts.hostInfo;
+        }
+        await writeAuditLogs(job.data.event, properties, {
+          userId: job.data.opts.userId,
+          timestamp: job.data.opts.timestamp,
+          appId: job.data.opts.appId,
+          hostInfo
+        });
+      });
+    });
+  }
+  async processEvent(event, identity, properties, timestamp) {
+    if (AuditLogsProcessor.auditLogsEnabled && (0, import_utils.isAudited)(event)) {
+      const userId = identity.type === import_types.IdentityType.USER ? identity.id : void 0;
+      await AuditLogsProcessor.auditLogQueue.add({
+        event,
+        properties,
+        opts: {
+          userId,
+          timestamp,
+          appId: (0, import_context.getAppId)(),
+          hostInfo: identity.hostInfo
+        },
+        tenantId: (0, import_context.getTenantId)()
+      });
+    }
+  }
+  async identify(identity, timestamp) {
+  }
+  async identifyGroup(group, timestamp) {
+  }
+  shutdown() {
+    AuditLogsProcessor.auditLogQueue?.close();
+  }
+}
+//# sourceMappingURL=AuditLogsProcessor.js.map

package/dist/src/events/processors/AuditLogsProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/events/processors/AuditLogsProcessor.ts"],
+  "sourcesContent": ["import {\n  Event,\n  Identity,\n  Group,\n  IdentityType,\n  AuditLogQueueEvent,\n  AuditLogFn,\n  HostInfo,\n} from \"@budibase/types\"\nimport { EventProcessor } from \"./types\"\nimport { getAppId, doInTenant, getTenantId } from \"../../context\"\nimport BullQueue from \"bull\"\nimport { createQueue, JobQueue } from \"../../queue\"\nimport { isAudited } from \"../../utils\"\nimport env from \"../../environment\"\n\nexport default class AuditLogsProcessor implements EventProcessor {\n  static auditLogsEnabled = false\n  static auditLogQueue: BullQueue.Queue<AuditLogQueueEvent>\n\n  // can't use constructor as need to return promise\n  static init(fn: AuditLogFn) {\n    AuditLogsProcessor.auditLogsEnabled = true\n    const writeAuditLogs = fn\n    AuditLogsProcessor.auditLogQueue = createQueue<AuditLogQueueEvent>(\n      JobQueue.AUDIT_LOG\n    )\n    return AuditLogsProcessor.auditLogQueue.process(async job => {\n      return doInTenant(job.data.tenantId, async () => {\n        let properties = job.data.properties\n        if (properties.audited) {\n          properties = {\n            ...properties,\n            ...properties.audited,\n          }\n          delete properties.audited\n        }\n\n        // this feature is disabled by default due to privacy requirements\n        // in some countries - available as env var in-case it is desired\n        // in self host deployments\n        let hostInfo: HostInfo | undefined = {}\n        if (env.ENABLE_AUDIT_LOG_IP_ADDR) {\n          hostInfo = job.data.opts.hostInfo\n        }\n\n        await writeAuditLogs(job.data.event, properties, {\n          userId: job.data.opts.userId,\n          timestamp: job.data.opts.timestamp,\n          appId: job.data.opts.appId,\n          hostInfo,\n        })\n      })\n    })\n  }\n\n  async processEvent(\n    event: Event,\n    identity: Identity,\n    properties: any,\n    timestamp?: string\n  ): Promise<void> {\n    if (AuditLogsProcessor.auditLogsEnabled && isAudited(event)) {\n      // only audit log actual events, don't include backfills\n      const userId =\n        identity.type === IdentityType.USER ? identity.id : undefined\n      // add to the event queue, rather than just writing immediately\n      await AuditLogsProcessor.auditLogQueue.add({\n        event,\n        properties,\n        opts: {\n          userId,\n          timestamp,\n          appId: getAppId(),\n          hostInfo: identity.hostInfo,\n        },\n        tenantId: getTenantId(),\n      })\n    }\n  }\n\n  async identify(identity: Identity, timestamp?: string | number) {\n    // no-op\n  }\n\n  async identifyGroup(group: Group, timestamp?: string | number) {\n    // no-op\n  }\n\n  shutdown(): void {\n    AuditLogsProcessor.auditLogQueue?.close()\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAQO;AAEP,qBAAkD;AAElD,mBAAsC;AACtC,mBAA0B;AAC1B,yBAAgB;AAEhB,MAAO,mBAA2D;AAAA,EAChE;AAAA,SAAO,mBAAmB;AAAA;AAAA;AAAA,EAI1B,OAAO,KAAK,IAAgB;AAC1B,uBAAmB,mBAAmB;AACtC,UAAM,iBAAiB;AACvB,uBAAmB,oBAAgB;AAAA,MACjC,sBAAS;AAAA,IACX;AACA,WAAO,mBAAmB,cAAc,QAAQ,OAAM,QAAO;AAC3D,iBAAO,2BAAW,IAAI,KAAK,UAAU,YAAY;AAC/C,YAAI,aAAa,IAAI,KAAK;AAC1B,YAAI,WAAW,SAAS;AACtB,uBAAa;AAAA,YACX,GAAG;AAAA,YACH,GAAG,WAAW;AAAA,UAChB;AACA,iBAAO,WAAW;AAAA,QACpB;AAKA,YAAI,WAAiC,CAAC;AACtC,YAAI,mBAAAA,QAAI,0BAA0B;AAChC,qBAAW,IAAI,KAAK,KAAK;AAAA,QAC3B;AAEA,cAAM,eAAe,IAAI,KAAK,OAAO,YAAY;AAAA,UAC/C,QAAQ,IAAI,KAAK,KAAK;AAAA,UACtB,WAAW,IAAI,KAAK,KAAK;AAAA,UACzB,OAAO,IAAI,KAAK,KAAK;AAAA,UACrB;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,aACJ,OACA,UACA,YACA,WACe;AACf,QAAI,mBAAmB,wBAAoB,wBAAU,KAAK,GAAG;AAE3D,YAAM,SACJ,SAAS,SAAS,0BAAa,OAAO,SAAS,KAAK;AAEtD,YAAM,mBAAmB,cAAc,IAAI;AAAA,QACzC;AAAA,QACA;AAAA,QACA,MAAM;AAAA,UACJ;AAAA,UACA;AAAA,UACA,WAAO,yBAAS;AAAA,UAChB,UAAU,SAAS;AAAA,QACrB;AAAA,QACA,cAAU,4BAAY;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAM,SAAS,UAAoB,WAA6B;AAAA,EAEhE;AAAA,EAEA,MAAM,cAAc,OAAc,WAA6B;AAAA,EAE/D;AAAA,EAEA,WAAiB;AACf,uBAAmB,eAAe,MAAM;AAAA,EAC1C;AACF;",
+  "names": ["env"]
+}

package/dist/src/events/processors/LoggingProcessor.js

@@ -0,0 +1,58 @@
+"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 LoggingProcessor_exports = {};
+__export(LoggingProcessor_exports, {
+  default: () => LoggingProcessor
+});
+module.exports = __toCommonJS(LoggingProcessor_exports);
+var import_environment = __toESM(require("../../environment"));
+const skipLogging = import_environment.default.SELF_HOSTED && !import_environment.default.isDev();
+class LoggingProcessor {
+  async processEvent(event, identity, properties, timestamp) {
+    if (skipLogging) {
+      return;
+    }
+    console.log(`[audit] [identityType=${identity.type}] ${event}`, properties);
+  }
+  async identify(identity, timestamp) {
+    if (skipLogging) {
+      return;
+    }
+    console.log(`[audit] identified`, identity);
+  }
+  async identifyGroup(group, timestamp) {
+    if (skipLogging) {
+      return;
+    }
+    console.log(`[audit] group identified`, group);
+  }
+  shutdown() {
+  }
+}
+//# sourceMappingURL=LoggingProcessor.js.map

package/dist/src/events/processors/LoggingProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/events/processors/LoggingProcessor.ts"],
+  "sourcesContent": ["import { Event, Identity, Group } from \"@budibase/types\"\nimport { EventProcessor } from \"./types\"\nimport env from \"../../environment\"\n\nconst skipLogging = env.SELF_HOSTED && !env.isDev()\n\nexport default class LoggingProcessor implements EventProcessor {\n  async processEvent(\n    event: Event,\n    identity: Identity,\n    properties: any,\n    timestamp?: string\n  ): Promise<void> {\n    if (skipLogging) {\n      return\n    }\n    console.log(`[audit] [identityType=${identity.type}] ${event}`, properties)\n  }\n\n  async identify(identity: Identity, timestamp?: string | number) {\n    if (skipLogging) {\n      return\n    }\n    console.log(`[audit] identified`, identity)\n  }\n\n  async identifyGroup(group: Group, timestamp?: string | number) {\n    if (skipLogging) {\n      return\n    }\n    console.log(`[audit] group identified`, group)\n  }\n\n  shutdown(): void {\n    // no-op\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,yBAAgB;AAEhB,MAAM,cAAc,mBAAAA,QAAI,eAAe,CAAC,mBAAAA,QAAI,MAAM;AAElD,MAAO,iBAAyD;AAAA,EAC9D,MAAM,aACJ,OACA,UACA,YACA,WACe;AACf,QAAI,aAAa;AACf;AAAA,IACF;AACA,YAAQ,IAAI,yBAAyB,SAAS,IAAI,KAAK,KAAK,IAAI,UAAU;AAAA,EAC5E;AAAA,EAEA,MAAM,SAAS,UAAoB,WAA6B;AAC9D,QAAI,aAAa;AACf;AAAA,IACF;AACA,YAAQ,IAAI,sBAAsB,QAAQ;AAAA,EAC5C;AAAA,EAEA,MAAM,cAAc,OAAc,WAA6B;AAC7D,QAAI,aAAa;AACf;AAAA,IACF;AACA,YAAQ,IAAI,4BAA4B,KAAK;AAAA,EAC/C;AAAA,EAEA,WAAiB;AAAA,EAEjB;AACF;",
+  "names": ["env"]
+}