@budibase/backend-core 2.9.40-alpha.6 → 2.10.1

package/src/events/publishers/app.ts

@@ -0,0 +1,155 @@
+import { publishEvent } from "../events"
+import {
+  Event,
+  App,
+  AppCreatedEvent,
+  AppUpdatedEvent,
+  AppDeletedEvent,
+  AppPublishedEvent,
+  AppUnpublishedEvent,
+  AppFileImportedEvent,
+  AppTemplateImportedEvent,
+  AppVersionUpdatedEvent,
+  AppVersionRevertedEvent,
+  AppRevertedEvent,
+  AppExportedEvent,
+} from "@budibase/types"
+
+const created = async (app: App, timestamp?: string | number) => {
+  const properties: AppCreatedEvent = {
+    appId: app.appId,
+    version: app.version,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_CREATED, properties, timestamp)
+}
+
+async function updated(app: App) {
+  const properties: AppUpdatedEvent = {
+    appId: app.appId,
+    version: app.version,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_UPDATED, properties)
+}
+
+async function deleted(app: App) {
+  const properties: AppDeletedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_DELETED, properties)
+}
+
+async function published(app: App, timestamp?: string | number) {
+  const properties: AppPublishedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_PUBLISHED, properties, timestamp)
+}
+
+async function unpublished(app: App) {
+  const properties: AppUnpublishedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_UNPUBLISHED, properties)
+}
+
+async function fileImported(app: App) {
+  const properties: AppFileImportedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_FILE_IMPORTED, properties)
+}
+
+async function templateImported(app: App, templateKey: string) {
+  const properties: AppTemplateImportedEvent = {
+    appId: app.appId,
+    templateKey,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_TEMPLATE_IMPORTED, properties)
+}
+
+async function versionUpdated(
+  app: App,
+  currentVersion: string,
+  updatedToVersion: string
+) {
+  const properties: AppVersionUpdatedEvent = {
+    appId: app.appId,
+    currentVersion,
+    updatedToVersion,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_VERSION_UPDATED, properties)
+}
+
+async function versionReverted(
+  app: App,
+  currentVersion: string,
+  revertedToVersion: string
+) {
+  const properties: AppVersionRevertedEvent = {
+    appId: app.appId,
+    currentVersion,
+    revertedToVersion,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_VERSION_REVERTED, properties)
+}
+
+async function reverted(app: App) {
+  const properties: AppRevertedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_REVERTED, properties)
+}
+
+async function exported(app: App) {
+  const properties: AppExportedEvent = {
+    appId: app.appId,
+    audited: {
+      name: app.name,
+    },
+  }
+  await publishEvent(Event.APP_EXPORTED, properties)
+}
+
+export default {
+  created,
+  updated,
+  deleted,
+  published,
+  unpublished,
+  fileImported,
+  templateImported,
+  versionUpdated,
+  versionReverted,
+  reverted,
+  exported,
+}

package/src/events/publishers/auditLog.ts

@@ -0,0 +1,26 @@
+import {
+  Event,
+  AuditLogSearchParams,
+  AuditLogFilteredEvent,
+  AuditLogDownloadedEvent,
+} from "@budibase/types"
+import { publishEvent } from "../events"
+
+async function filtered(search: AuditLogSearchParams) {
+  const properties: AuditLogFilteredEvent = {
+    filters: search,
+  }
+  await publishEvent(Event.AUDIT_LOGS_FILTERED, properties)
+}
+
+async function downloaded(search: AuditLogSearchParams) {
+  const properties: AuditLogDownloadedEvent = {
+    filters: search,
+  }
+  await publishEvent(Event.AUDIT_LOGS_DOWNLOADED, properties)
+}
+
+export default {
+  filtered,
+  downloaded,
+}

package/src/events/publishers/auth.ts

@@ -0,0 +1,73 @@
+import { publishEvent } from "../events"
+import {
+  Event,
+  LoginEvent,
+  LoginSource,
+  LogoutEvent,
+  SSOActivatedEvent,
+  SSOCreatedEvent,
+  SSODeactivatedEvent,
+  SSOType,
+  SSOUpdatedEvent,
+} from "@budibase/types"
+import { identification } from ".."
+
+async function login(source: LoginSource, email: string) {
+  const identity = await identification.getCurrentIdentity()
+  const properties: LoginEvent = {
+    userId: identity.id,
+    source,
+    audited: {
+      email,
+    },
+  }
+  await publishEvent(Event.AUTH_LOGIN, properties)
+}
+
+async function logout(email?: string) {
+  const identity = await identification.getCurrentIdentity()
+  const properties: LogoutEvent = {
+    userId: identity.id,
+    audited: {
+      email,
+    },
+  }
+  await publishEvent(Event.AUTH_LOGOUT, properties)
+}
+
+async function SSOCreated(type: SSOType, timestamp?: string | number) {
+  const properties: SSOCreatedEvent = {
+    type,
+  }
+  await publishEvent(Event.AUTH_SSO_CREATED, properties, timestamp)
+}
+
+async function SSOUpdated(type: SSOType) {
+  const properties: SSOUpdatedEvent = {
+    type,
+  }
+  await publishEvent(Event.AUTH_SSO_UPDATED, properties)
+}
+
+async function SSOActivated(type: SSOType, timestamp?: string | number) {
+  const properties: SSOActivatedEvent = {
+    type,
+  }
+  await publishEvent(Event.AUTH_SSO_ACTIVATED, properties, timestamp)
+}
+
+async function SSODeactivated(type: SSOType) {
+  const properties: SSODeactivatedEvent = {
+    type,
+  }
+  await publishEvent(Event.AUTH_SSO_DEACTIVATED, properties)
+}
+
+export default {
+  login,
+  logout,
+  SSOCreated,
+  SSOUpdated,
+  SSOActivated,
+  SSODeactivated,
+}

package/src/events/publishers/automation.ts

@@ -0,0 +1,110 @@
+import { publishEvent } from "../events"
+import {
+  Automation,
+  Event,
+  AutomationStep,
+  AutomationCreatedEvent,
+  AutomationDeletedEvent,
+  AutomationTestedEvent,
+  AutomationStepCreatedEvent,
+  AutomationStepDeletedEvent,
+  AutomationTriggerUpdatedEvent,
+  AutomationsRunEvent,
+} from "@budibase/types"
+
+async function created(automation: Automation, timestamp?: string | number) {
+  const properties: AutomationCreatedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+    audited: {
+      name: automation.name,
+    },
+  }
+  await publishEvent(Event.AUTOMATION_CREATED, properties, timestamp)
+}
+
+async function triggerUpdated(automation: Automation) {
+  const properties: AutomationTriggerUpdatedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+  }
+  await publishEvent(Event.AUTOMATION_TRIGGER_UPDATED, properties)
+}
+
+async function deleted(automation: Automation) {
+  const properties: AutomationDeletedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+    audited: {
+      name: automation.name,
+    },
+  }
+  await publishEvent(Event.AUTOMATION_DELETED, properties)
+}
+
+async function tested(automation: Automation) {
+  const properties: AutomationTestedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+  }
+  await publishEvent(Event.AUTOMATION_TESTED, properties)
+}
+
+const run = async (count: number, timestamp?: string | number) => {
+  const properties: AutomationsRunEvent = {
+    count,
+  }
+  await publishEvent(Event.AUTOMATIONS_RUN, properties, timestamp)
+}
+
+async function stepCreated(
+  automation: Automation,
+  step: AutomationStep,
+  timestamp?: string | number
+) {
+  const properties: AutomationStepCreatedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+    stepId: step.id!,
+    stepType: step.stepId,
+    audited: {
+      name: automation.name,
+    },
+  }
+  await publishEvent(Event.AUTOMATION_STEP_CREATED, properties, timestamp)
+}
+
+async function stepDeleted(automation: Automation, step: AutomationStep) {
+  const properties: AutomationStepDeletedEvent = {
+    appId: automation.appId,
+    automationId: automation._id as string,
+    triggerId: automation.definition?.trigger?.id,
+    triggerType: automation.definition?.trigger?.stepId,
+    stepId: step.id!,
+    stepType: step.stepId,
+    audited: {
+      name: automation.name,
+    },
+  }
+  await publishEvent(Event.AUTOMATION_STEP_DELETED, properties)
+}
+
+export default {
+  created,
+  triggerUpdated,
+  deleted,
+  tested,
+  run,
+  stepCreated,
+  stepDeleted,
+}

package/src/events/publishers/backfill.ts

@@ -0,0 +1,74 @@
+import { publishEvent } from "../events"
+import {
+  Event,
+  AppBackfillSucceededEvent,
+  AppBackfillFailedEvent,
+  TenantBackfillSucceededEvent,
+  TenantBackfillFailedEvent,
+  InstallationBackfillSucceededEvent,
+  InstallationBackfillFailedEvent,
+} from "@budibase/types"
+import env from "../../environment"
+
+const shouldSkip = !env.SELF_HOSTED && !env.isDev()
+
+async function appSucceeded(properties: AppBackfillSucceededEvent) {
+  if (shouldSkip) {
+    return
+  }
+  await publishEvent(Event.APP_BACKFILL_SUCCEEDED, properties)
+}
+
+async function appFailed(error: any) {
+  if (shouldSkip) {
+    return
+  }
+  const properties: AppBackfillFailedEvent = {
+    error: JSON.stringify(error, Object.getOwnPropertyNames(error)),
+  }
+  await publishEvent(Event.APP_BACKFILL_FAILED, properties)
+}
+
+async function tenantSucceeded(properties: TenantBackfillSucceededEvent) {
+  if (shouldSkip) {
+    return
+  }
+  await publishEvent(Event.TENANT_BACKFILL_SUCCEEDED, properties)
+}
+
+async function tenantFailed(error: any) {
+  if (shouldSkip) {
+    return
+  }
+  const properties: TenantBackfillFailedEvent = {
+    error: JSON.stringify(error, Object.getOwnPropertyNames(error)),
+  }
+  await publishEvent(Event.TENANT_BACKFILL_FAILED, properties)
+}
+
+async function installationSucceeded() {
+  if (shouldSkip) {
+    return
+  }
+  const properties: InstallationBackfillSucceededEvent = {}
+  await publishEvent(Event.INSTALLATION_BACKFILL_SUCCEEDED, properties)
+}
+
+async function installationFailed(error: any) {
+  if (shouldSkip) {
+    return
+  }
+  const properties: InstallationBackfillFailedEvent = {
+    error: JSON.stringify(error, Object.getOwnPropertyNames(error)),
+  }
+  await publishEvent(Event.INSTALLATION_BACKFILL_FAILED, properties)
+}
+
+export default {
+  appSucceeded,
+  appFailed,
+  tenantSucceeded,
+  tenantFailed,
+  installationSucceeded,
+  installationFailed,
+}

package/src/events/publishers/backup.ts

@@ -0,0 +1,42 @@
+import {
+  AppBackup,
+  AppBackupRestoreEvent,
+  AppBackupTriggeredEvent,
+  AppBackupTrigger,
+  AppBackupType,
+  Event,
+} from "@budibase/types"
+import { publishEvent } from "../events"
+
+async function appBackupRestored(backup: AppBackup) {
+  const properties: AppBackupRestoreEvent = {
+    appId: backup.appId,
+    restoreId: backup._id!,
+    backupCreatedAt: backup.timestamp,
+    name: backup.name as string,
+  }
+
+  await publishEvent(Event.APP_BACKUP_RESTORED, properties)
+}
+
+async function appBackupTriggered(
+  appId: string,
+  backupId: string,
+  type: AppBackupType,
+  trigger: AppBackupTrigger,
+  name: string
+) {
+  const properties: AppBackupTriggeredEvent = {
+    appId: appId,
+    backupId,
+    type,
+    trigger,
+    name,
+  }
+  await publishEvent(Event.APP_BACKUP_TRIGGERED, properties)
+}
+
+export default {
+  appBackupRestored,
+  appBackupTriggered,
+}

package/src/events/publishers/datasource.ts

@@ -0,0 +1,48 @@
+import { publishEvent } from "../events"
+import {
+  Event,
+  Datasource,
+  DatasourceCreatedEvent,
+  DatasourceUpdatedEvent,
+  DatasourceDeletedEvent,
+  SourceName,
+} from "@budibase/types"
+
+function isCustom(datasource: Datasource) {
+  const sources = Object.values(SourceName)
+  // if not in the base source list, then it must be custom
+  return !sources.includes(datasource.source)
+}
+
+async function created(datasource: Datasource, timestamp?: string | number) {
+  const properties: DatasourceCreatedEvent = {
+    datasourceId: datasource._id as string,
+    source: datasource.source,
+    custom: isCustom(datasource),
+  }
+  await publishEvent(Event.DATASOURCE_CREATED, properties, timestamp)
+}
+
+async function updated(datasource: Datasource) {
+  const properties: DatasourceUpdatedEvent = {
+    datasourceId: datasource._id as string,
+    source: datasource.source,
+    custom: isCustom(datasource),
+  }
+  await publishEvent(Event.DATASOURCE_UPDATED, properties)
+}
+
+async function deleted(datasource: Datasource) {
+  const properties: DatasourceDeletedEvent = {
+    datasourceId: datasource._id as string,
+    source: datasource.source,
+    custom: isCustom(datasource),
+  }
+  await publishEvent(Event.DATASOURCE_DELETED, properties)
+}
+
+export default {
+  created,
+  updated,
+  deleted,
+}

package/src/events/publishers/email.ts

@@ -0,0 +1,17 @@
+import { publishEvent } from "../events"
+import { Event, SMTPCreatedEvent, SMTPUpdatedEvent } from "@budibase/types"
+
+async function SMTPCreated(timestamp?: string | number) {
+  const properties: SMTPCreatedEvent = {}
+  await publishEvent(Event.EMAIL_SMTP_CREATED, properties, timestamp)
+}
+
+async function SMTPUpdated() {
+  const properties: SMTPUpdatedEvent = {}
+  await publishEvent(Event.EMAIL_SMTP_UPDATED, properties)
+}
+
+export default {
+  SMTPCreated,
+  SMTPUpdated,
+}

package/src/events/publishers/environmentVariable.ts

@@ -0,0 +1,38 @@
+import {
+  Event,
+  EnvironmentVariableCreatedEvent,
+  EnvironmentVariableDeletedEvent,
+  EnvironmentVariableUpgradePanelOpenedEvent,
+} from "@budibase/types"
+import { publishEvent } from "../events"
+
+async function created(name: string, environments: string[]) {
+  const properties: EnvironmentVariableCreatedEvent = {
+    name,
+    environments,
+  }
+  await publishEvent(Event.ENVIRONMENT_VARIABLE_CREATED, properties)
+}
+
+async function deleted(name: string) {
+  const properties: EnvironmentVariableDeletedEvent = {
+    name,
+  }
+  await publishEvent(Event.ENVIRONMENT_VARIABLE_DELETED, properties)
+}
+
+async function upgradePanelOpened(userId: string) {
+  const properties: EnvironmentVariableUpgradePanelOpenedEvent = {
+    userId,
+  }
+  await publishEvent(
+    Event.ENVIRONMENT_VARIABLE_UPGRADE_PANEL_OPENED,
+    properties
+  )
+}
+
+export default {
+  created,
+  deleted,
+  upgradePanelOpened,
+}

package/src/events/publishers/group.ts

@@ -0,0 +1,99 @@
+import { publishEvent } from "../events"
+import {
+  Event,
+  UserGroup,
+  GroupCreatedEvent,
+  GroupDeletedEvent,
+  GroupUpdatedEvent,
+  GroupUsersAddedEvent,
+  GroupUsersDeletedEvent,
+  GroupAddedOnboardingEvent,
+  GroupPermissionsEditedEvent,
+} from "@budibase/types"
+import { isScim } from "../../context"
+
+async function created(group: UserGroup, timestamp?: number) {
+  const properties: GroupCreatedEvent = {
+    groupId: group._id as string,
+    viaScim: isScim(),
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_CREATED, properties, timestamp)
+}
+
+async function updated(group: UserGroup) {
+  const properties: GroupUpdatedEvent = {
+    groupId: group._id as string,
+    viaScim: isScim(),
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_UPDATED, properties)
+}
+
+async function deleted(group: UserGroup) {
+  const properties: GroupDeletedEvent = {
+    groupId: group._id as string,
+    viaScim: isScim(),
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_DELETED, properties)
+}
+
+async function usersAdded(count: number, group: UserGroup) {
+  const properties: GroupUsersAddedEvent = {
+    count,
+    groupId: group._id as string,
+    viaScim: isScim(),
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_USERS_ADDED, properties)
+}
+
+async function usersDeleted(count: number, group: UserGroup) {
+  const properties: GroupUsersDeletedEvent = {
+    count,
+    groupId: group._id as string,
+    viaScim: isScim(),
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_USERS_REMOVED, properties)
+}
+
+async function createdOnboarding(groupId: string) {
+  const properties: GroupAddedOnboardingEvent = {
+    groupId: groupId,
+    onboarding: true,
+  }
+  await publishEvent(Event.USER_GROUP_ONBOARDING, properties)
+}
+
+async function permissionsEdited(group: UserGroup) {
+  const properties: GroupPermissionsEditedEvent = {
+    permissions: group.roles!,
+    groupId: group._id as string,
+    audited: {
+      name: group.name,
+    },
+  }
+  await publishEvent(Event.USER_GROUP_PERMISSIONS_EDITED, properties)
+}
+
+export default {
+  created,
+  updated,
+  deleted,
+  usersAdded,
+  usersDeleted,
+  createdOnboarding,
+  permissionsEdited,
+}

package/src/events/publishers/index.ts

@@ -0,0 +1,24 @@
+export { default as account } from "./account"
+export { default as app } from "./app"
+export { default as auth } from "./auth"
+export { default as automation } from "./automation"
+export { default as datasource } from "./datasource"
+export { default as email } from "./email"
+export { default as license } from "./license"
+export { default as layout } from "./layout"
+export { default as org } from "./org"
+export { default as query } from "./query"
+export { default as role } from "./role"
+export { default as screen } from "./screen"
+export { default as rows } from "./rows"
+export { default as table } from "./table"
+export { default as serve } from "./serve"
+export { default as user } from "./user"
+export { default as view } from "./view"
+export { default as installation } from "./installation"
+export { default as backfill } from "./backfill"
+export { default as group } from "./group"
+export { default as plugin } from "./plugin"
+export { default as backup } from "./backup"
+export { default as environmentVariable } from "./environmentVariable"
+export { default as auditLog } from "./auditLog"