@budibase/backend-core 3.2.4 → 3.2.6

package/src/events/publishers/index.ts

@@ -1,25 +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 ai } from "./ai"
-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"

package/src/events/publishers/installation.ts

@@ -1,38 +0,0 @@
-import { publishEvent } from "../events"
-import { Event, VersionCheckedEvent, VersionChangeEvent } from "@budibase/types"
-
-async function versionChecked(version: string) {
-  const properties: VersionCheckedEvent = {
-    currentVersion: version,
-  }
-  await publishEvent(Event.INSTALLATION_VERSION_CHECKED, properties)
-}
-
-async function upgraded(from: string, to: string) {
-  const properties: VersionChangeEvent = {
-    from,
-    to,
-  }
-
-  await publishEvent(Event.INSTALLATION_VERSION_UPGRADED, properties)
-}
-
-async function downgraded(from: string, to: string) {
-  const properties: VersionChangeEvent = {
-    from,
-    to,
-  }
-  await publishEvent(Event.INSTALLATION_VERSION_DOWNGRADED, properties)
-}
-
-async function firstStartup() {
-  const properties = {}
-  await publishEvent(Event.INSTALLATION_FIRST_STARTUP, properties)
-}
-
-export default {
-  versionChecked,
-  upgraded,
-  downgraded,
-  firstStartup,
-}

package/src/events/publishers/layout.ts

@@ -1,26 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  Layout,
-  LayoutCreatedEvent,
-  LayoutDeletedEvent,
-} from "@budibase/types"
-
-async function created(layout: Layout, timestamp?: string | number) {
-  const properties: LayoutCreatedEvent = {
-    layoutId: layout._id as string,
-  }
-  await publishEvent(Event.LAYOUT_CREATED, properties, timestamp)
-}
-
-async function deleted(layoutId: string) {
-  const properties: LayoutDeletedEvent = {
-    layoutId,
-  }
-  await publishEvent(Event.LAYOUT_DELETED, properties)
-}
-
-export default {
-  created,
-  deleted,
-}

package/src/events/publishers/license.ts

@@ -1,84 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  LicenseActivatedEvent,
-  LicensePlanChangedEvent,
-  PlanType,
-  Account,
-  LicensePortalOpenedEvent,
-  LicenseCheckoutSuccessEvent,
-  LicenseCheckoutOpenedEvent,
-  LicensePaymentFailedEvent,
-  LicensePaymentRecoveredEvent,
-  PriceDuration,
-} from "@budibase/types"
-
-async function planChanged(
-  account: Account,
-  opts: {
-    from: PlanType
-    to: PlanType
-    fromQuantity: number | undefined
-    toQuantity: number | undefined
-    fromDuration: PriceDuration | undefined
-    toDuration: PriceDuration | undefined
-  }
-) {
-  const properties: LicensePlanChangedEvent = {
-    accountId: account.accountId,
-    ...opts,
-  }
-  await publishEvent(Event.LICENSE_PLAN_CHANGED, properties)
-}
-
-async function activated(account: Account) {
-  const properties: LicenseActivatedEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_ACTIVATED, properties)
-}
-
-async function checkoutOpened(account: Account) {
-  const properties: LicenseCheckoutOpenedEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_CHECKOUT_OPENED, properties)
-}
-
-async function checkoutSuccess(account: Account) {
-  const properties: LicenseCheckoutSuccessEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_CHECKOUT_SUCCESS, properties)
-}
-
-async function portalOpened(account: Account) {
-  const properties: LicensePortalOpenedEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_PORTAL_OPENED, properties)
-}
-
-async function paymentFailed(account: Account) {
-  const properties: LicensePaymentFailedEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_PAYMENT_FAILED, properties)
-}
-
-async function paymentRecovered(account: Account) {
-  const properties: LicensePaymentRecoveredEvent = {
-    accountId: account.accountId,
-  }
-  await publishEvent(Event.LICENSE_PAYMENT_RECOVERED, properties)
-}
-
-export default {
-  planChanged,
-  activated,
-  checkoutOpened,
-  checkoutSuccess,
-  portalOpened,
-  paymentFailed,
-  paymentRecovered,
-}

package/src/events/publishers/org.ts

@@ -1,37 +0,0 @@
-import { publishEvent } from "../events"
-import { Event } from "@budibase/types"
-
-async function nameUpdated(timestamp?: string | number) {
-  const properties = {}
-  await publishEvent(Event.ORG_NAME_UPDATED, properties, timestamp)
-}
-
-async function logoUpdated(timestamp?: string | number) {
-  const properties = {}
-  await publishEvent(Event.ORG_LOGO_UPDATED, properties, timestamp)
-}
-
-async function platformURLUpdated(timestamp?: string | number) {
-  const properties = {}
-  await publishEvent(Event.ORG_PLATFORM_URL_UPDATED, properties, timestamp)
-}
-
-// TODO
-
-async function analyticsOptOut() {
-  const properties = {}
-  await publishEvent(Event.ANALYTICS_OPT_OUT, properties)
-}
-
-async function analyticsOptIn() {
-  const properties = {}
-  await publishEvent(Event.ANALYTICS_OPT_OUT, properties)
-}
-
-export default {
-  nameUpdated,
-  logoUpdated,
-  platformURLUpdated,
-  analyticsOptOut,
-  analyticsOptIn,
-}

package/src/events/publishers/plugin.ts

@@ -1,47 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  Plugin,
-  PluginDeletedEvent,
-  PluginImportedEvent,
-  PluginInitEvent,
-} from "@budibase/types"
-
-async function init(plugin: Plugin) {
-  const properties: PluginInitEvent = {
-    type: plugin.schema.type,
-    name: plugin.name,
-    description: plugin.description,
-    version: plugin.version,
-  }
-  await publishEvent(Event.PLUGIN_INIT, properties)
-}
-
-async function imported(plugin: Plugin) {
-  const properties: PluginImportedEvent = {
-    pluginId: plugin._id as string,
-    type: plugin.schema.type,
-    source: plugin.source,
-    name: plugin.name,
-    description: plugin.description,
-    version: plugin.version,
-  }
-  await publishEvent(Event.PLUGIN_IMPORTED, properties)
-}
-
-async function deleted(plugin: Plugin) {
-  const properties: PluginDeletedEvent = {
-    pluginId: plugin._id as string,
-    type: plugin.schema.type,
-    name: plugin.name,
-    description: plugin.description,
-    version: plugin.version,
-  }
-  await publishEvent(Event.PLUGIN_DELETED, properties)
-}
-
-export default {
-  init,
-  imported,
-  deleted,
-}

package/src/events/publishers/query.ts

@@ -1,89 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  Datasource,
-  Query,
-  QueryPreview,
-  QueryCreatedEvent,
-  QueryUpdatedEvent,
-  QueryDeletedEvent,
-  QueryImportedEvent,
-  QueryPreviewedEvent,
-  QueriesRunEvent,
-} from "@budibase/types"
-
-/* eslint-disable */
-
-const created = async (
-  datasource: Datasource,
-  query: Query,
-  timestamp?: string | number
-) => {
-  const properties: QueryCreatedEvent = {
-    queryId: query._id as string,
-    datasourceId: datasource._id as string,
-    source: datasource.source,
-    queryVerb: query.queryVerb,
-  }
-  await publishEvent(Event.QUERY_CREATED, properties, timestamp)
-}
-
-const updated = async (datasource: Datasource, query: Query) => {
-  const properties: QueryUpdatedEvent = {
-    queryId: query._id as string,
-    datasourceId: datasource._id as string,
-    source: datasource.source,
-    queryVerb: query.queryVerb,
-  }
-  await publishEvent(Event.QUERY_UPDATED, properties)
-}
-
-const deleted = async (datasource: Datasource, query: Query) => {
-  const properties: QueryDeletedEvent = {
-    queryId: query._id as string,
-    datasourceId: datasource._id as string,
-    source: datasource.source,
-    queryVerb: query.queryVerb,
-  }
-  await publishEvent(Event.QUERY_DELETED, properties)
-}
-
-const imported = async (
-  datasource: Datasource,
-  importSource: any,
-  count: any
-) => {
-  const properties: QueryImportedEvent = {
-    datasourceId: datasource._id as string,
-    source: datasource.source,
-    count,
-    importSource,
-  }
-  await publishEvent(Event.QUERY_IMPORT, properties)
-}
-
-const run = async (count: number, timestamp?: string | number) => {
-  const properties: QueriesRunEvent = {
-    count,
-  }
-  await publishEvent(Event.QUERIES_RUN, properties, timestamp)
-}
-
-const previewed = async (datasource: Datasource, query: QueryPreview) => {
-  const properties: QueryPreviewedEvent = {
-    queryId: query.queryId,
-    datasourceId: datasource._id as string,
-    source: datasource.source,
-    queryVerb: query.queryVerb,
-  }
-  await publishEvent(Event.QUERY_PREVIEWED, properties)
-}
-
-export default {
-  created,
-  updated,
-  deleted,
-  imported,
-  run,
-  previewed,
-}

package/src/events/publishers/role.ts

@@ -1,62 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  Role,
-  RoleAssignedEvent,
-  RoleCreatedEvent,
-  RoleDeletedEvent,
-  RoleUnassignedEvent,
-  RoleUpdatedEvent,
-  User,
-} from "@budibase/types"
-
-async function created(role: Role, timestamp?: string | number) {
-  const properties: RoleCreatedEvent = {
-    roleId: role._id as string,
-    permissionId: role.permissionId,
-    inherits: role.inherits,
-  }
-  await publishEvent(Event.ROLE_CREATED, properties, timestamp)
-}
-
-async function updated(role: Role) {
-  const properties: RoleUpdatedEvent = {
-    roleId: role._id as string,
-    permissionId: role.permissionId,
-    inherits: role.inherits,
-  }
-  await publishEvent(Event.ROLE_UPDATED, properties)
-}
-
-async function deleted(role: Role) {
-  const properties: RoleDeletedEvent = {
-    roleId: role._id as string,
-    permissionId: role.permissionId,
-    inherits: role.inherits,
-  }
-  await publishEvent(Event.ROLE_DELETED, properties)
-}
-
-async function assigned(user: User, roleId: string, timestamp?: number) {
-  const properties: RoleAssignedEvent = {
-    userId: user._id as string,
-    roleId,
-  }
-  await publishEvent(Event.ROLE_ASSIGNED, properties, timestamp)
-}
-
-async function unassigned(user: User, roleId: string) {
-  const properties: RoleUnassignedEvent = {
-    userId: user._id as string,
-    roleId,
-  }
-  await publishEvent(Event.ROLE_UNASSIGNED, properties)
-}
-
-export default {
-  created,
-  updated,
-  deleted,
-  assigned,
-  unassigned,
-}

package/src/events/publishers/rows.ts

@@ -1,29 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  RowsImportedEvent,
-  RowsCreatedEvent,
-  Table,
-} from "@budibase/types"
-
-/* eslint-disable */
-
-const created = async (count: number, timestamp?: string | number) => {
-  const properties: RowsCreatedEvent = {
-    count,
-  }
-  await publishEvent(Event.ROWS_CREATED, properties, timestamp)
-}
-
-const imported = async (table: Table, count: number) => {
-  const properties: RowsImportedEvent = {
-    tableId: table._id as string,
-    count,
-  }
-  await publishEvent(Event.ROWS_IMPORTED, properties)
-}
-
-export default {
-  created,
-  imported,
-}

package/src/events/publishers/screen.ts

@@ -1,36 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  Screen,
-  ScreenCreatedEvent,
-  ScreenDeletedEvent,
-} from "@budibase/types"
-
-async function created(screen: Screen, timestamp?: string | number) {
-  const properties: ScreenCreatedEvent = {
-    layoutId: screen.layoutId,
-    screenId: screen._id as string,
-    roleId: screen.routing.roleId,
-    audited: {
-      name: screen.routing?.route,
-    },
-  }
-  await publishEvent(Event.SCREEN_CREATED, properties, timestamp)
-}
-
-async function deleted(screen: Screen) {
-  const properties: ScreenDeletedEvent = {
-    layoutId: screen.layoutId,
-    screenId: screen._id as string,
-    roleId: screen.routing.roleId,
-    audited: {
-      name: screen.routing?.route,
-    },
-  }
-  await publishEvent(Event.SCREEN_DELETED, properties)
-}
-
-export default {
-  created,
-  deleted,
-}

package/src/events/publishers/serve.ts

@@ -1,43 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  App,
-  BuilderServedEvent,
-  Event,
-  AppPreviewServedEvent,
-  AppServedEvent,
-} from "@budibase/types"
-
-async function servedBuilder(timezone: string) {
-  const properties: BuilderServedEvent = {
-    timezone,
-  }
-  await publishEvent(Event.SERVED_BUILDER, properties)
-}
-
-async function servedApp(
-  app: App,
-  timezone: string,
-  embed?: boolean | undefined
-) {
-  const properties: AppServedEvent = {
-    appVersion: app.version,
-    timezone,
-    embed: embed === true,
-  }
-  await publishEvent(Event.SERVED_APP, properties)
-}
-
-async function servedAppPreview(app: App, timezone: string) {
-  const properties: AppPreviewServedEvent = {
-    appId: app.appId,
-    appVersion: app.version,
-    timezone,
-  }
-  await publishEvent(Event.SERVED_APP_PREVIEW, properties)
-}
-
-export default {
-  servedBuilder,
-  servedApp,
-  servedAppPreview,
-}

package/src/events/publishers/table.ts

@@ -1,70 +0,0 @@
-import { publishEvent } from "../events"
-import {
-  Event,
-  TableExportFormat,
-  Table,
-  TableCreatedEvent,
-  TableUpdatedEvent,
-  TableDeletedEvent,
-  TableExportedEvent,
-  TableImportedEvent,
-} from "@budibase/types"
-
-async function created(table: Table, timestamp?: string | number) {
-  const properties: TableCreatedEvent = {
-    tableId: table._id as string,
-    audited: {
-      name: table.name,
-    },
-  }
-  await publishEvent(Event.TABLE_CREATED, properties, timestamp)
-}
-
-async function updated(table: Table) {
-  const properties: TableUpdatedEvent = {
-    tableId: table._id as string,
-    audited: {
-      name: table.name,
-    },
-  }
-  await publishEvent(Event.TABLE_UPDATED, properties)
-}
-
-async function deleted(table: Table) {
-  const properties: TableDeletedEvent = {
-    tableId: table._id as string,
-    audited: {
-      name: table.name,
-    },
-  }
-  await publishEvent(Event.TABLE_DELETED, properties)
-}
-
-async function exported(table: Table, format: TableExportFormat) {
-  const properties: TableExportedEvent = {
-    tableId: table._id as string,
-    format,
-    audited: {
-      name: table.name,
-    },
-  }
-  await publishEvent(Event.TABLE_EXPORTED, properties)
-}
-
-async function imported(table: Table) {
-  const properties: TableImportedEvent = {
-    tableId: table._id as string,
-    audited: {
-      name: table.name,
-    },
-  }
-  await publishEvent(Event.TABLE_IMPORTED, properties)
-}
-
-export default {
-  created,
-  updated,
-  deleted,
-  exported,
-  imported,
-}