@budibase/backend-core 2.9.19 → 2.9.21-alpha.0

package/src/events/publishers/app.ts

@@ -1,155 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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"