[Actions] Connector Adapters MVP

x-pack/plugins/alerting/common/rule.ts

@@ -108,6 +108,19 @@ export interface AlertsFilter extends SavedObjectAttributes {
 
 export type RuleActionAlertsFilterProperty = AlertsFilterTimeframe | RuleActionParam;
 
+/**
+ * The RuleActionTypes is being used in versioned
+ * routes and rule client's schemas. Renaming
+ * or removing a type will introduce a
+ * breaking change
+ */
+export const RuleActionTypes = {
+  DEFAULT: 'default' as const,
+  SYSTEM: 'system' as const,
+} as const;
+
+export type RuleActionTypes = typeof RuleActionTypes[keyof typeof RuleActionTypes];
+
 export interface RuleAction {
   uuid?: string;
   group: string;
@@ -116,6 +129,7 @@ export interface RuleAction {
   params: RuleActionParams;
   frequency?: RuleActionFrequency;
   alertsFilter?: AlertsFilter;
+  type?: typeof RuleActionTypes.DEFAULT;
 }
 
 export interface AggregateOptions {

x-pack/plugins/alerting/server/application/rule/methods/bulk_edit/bulk_edit_rules.test.ts

@@ -35,6 +35,7 @@ import {
 } from '../../../../rules_client/tests/test_helpers';
 import { migrateLegacyActions } from '../../../../rules_client/lib';
 import { migrateLegacyActionsMock } from '../../../../rules_client/lib/siem_legacy_actions/retrieve_migrated_legacy_actions.mock';
+import { ConnectorAdapterRegistry } from '../../../../connector_adapters/connector_adapter_registry';
 
 jest.mock('../../../../rules_client/lib/siem_legacy_actions/migrate_legacy_actions', () => {
   return {
@@ -102,6 +103,7 @@ const rulesClientParams: jest.Mocked<ConstructorOptions> = {
   minimumScheduleInterval: { value: '1m', enforce: false },
   isAuthenticationTypeAPIKey: isAuthenticationTypeApiKeyMock,
   getAuthenticationAPIKey: getAuthenticationApiKeyMock,
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 const paramsModifier = jest.fn();
 

x-pack/plugins/alerting/server/application/rule/methods/create/create_rule.test.ts

@@ -27,6 +27,7 @@ import { getBeforeSetup, setGlobalDate } from '../../../../rules_client/tests/li
 import { RecoveredActionGroup } from '../../../../../common';
 import { bulkMarkApiKeysForInvalidation } from '../../../../invalidate_pending_api_keys/bulk_mark_api_keys_for_invalidation';
 import { getRuleExecutionStatusPending, getDefaultMonitoring } from '../../../../lib';
+import { ConnectorAdapterRegistry } from '../../../../connector_adapters/connector_adapter_registry';
 
 jest.mock('../../../../invalidate_pending_api_keys/bulk_mark_api_keys_for_invalidation', () => ({
   bulkMarkApiKeysForInvalidation: jest.fn(),
@@ -82,6 +83,7 @@ const rulesClientParams: jest.Mocked<ConstructorOptions> = {
   minimumScheduleInterval: { value: '1m', enforce: false },
   isAuthenticationTypeAPIKey: jest.fn(),
   getAuthenticationAPIKey: jest.fn(),
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 
 beforeEach(() => {

x-pack/plugins/alerting/server/application/rule/methods/get_schedule_frequency/get_schedule_frequency.test.ts

@@ -20,6 +20,7 @@ import { actionsAuthorizationMock } from '@kbn/actions-plugin/server/mocks';
 import { AlertingAuthorization } from '../../../../authorization/alerting_authorization';
 import { ActionsAuthorization } from '@kbn/actions-plugin/server';
 import { auditLoggerMock } from '@kbn/security-plugin/server/audit/mocks';
+import { ConnectorAdapterRegistry } from '../../../../connector_adapters/connector_adapter_registry';
 
 const taskManager = taskManagerMock.createStart();
 const ruleTypeRegistry = ruleTypeRegistryMock.create();
@@ -53,6 +54,7 @@ const rulesClientParams: jest.Mocked<ConstructorOptions> = {
   minimumScheduleInterval: { value: '1m', enforce: false },
   isAuthenticationTypeAPIKey: jest.fn(),
   getAuthenticationAPIKey: jest.fn(),
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 
 const getMockAggregationResult = (

x-pack/plugins/alerting/server/connector_adapters/connector_adapter_registry.test.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { schema } from '@kbn/config-schema';
+import { ConnectorAdapterRegistry } from './connector_adapter_registry';
+import type { ConnectorAdapter } from './types';
+
+describe('ConnectorAdapterRegistry', () => {
+  const connectorAdapter: ConnectorAdapter = {
+    connectorTypeId: '.test',
+    ruleActionParamsSchema: schema.object({}),
+    buildActionParams: jest.fn(),
+  };
+
+  let registry: ConnectorAdapterRegistry;
+
+  beforeEach(() => {
+    registry = new ConnectorAdapterRegistry();
+  });
+
+  describe('has', () => {
+    it('returns true if the connector adapter is registered', () => {
+      registry.register(connectorAdapter);
+      expect(registry.has('.test')).toBe(true);
+    });
+
+    it('returns false if the connector adapter is not registered', () => {
+      expect(registry.has('.not-exist')).toBe(false);
+    });
+  });
+
+  describe('register', () => {
+    it('registers a connector adapter correctly', () => {
+      registry.register(connectorAdapter);
+      expect(registry.get('.test')).toEqual(connectorAdapter);
+    });
+
+    it('throws an error if the connector adapter exists', () => {
+      registry.register(connectorAdapter);
+
+      expect(() => registry.register(connectorAdapter)).toThrowErrorMatchingInlineSnapshot(
+        `".test is already registered to the ConnectorAdapterRegistry"`
+      );
+    });
+  });
+
+  describe('get', () => {
+    it('gets a connector adapter correctly', () => {
+      registry.register(connectorAdapter);
+      expect(registry.get('.test')).toEqual(connectorAdapter);
+    });
+
+    it('throws an error if the connector adapter does not exists', () => {
+      expect(() => registry.get('.not-exists')).toThrowErrorMatchingInlineSnapshot(
+        `"Connector adapter \\".not-exists\\" is not registered."`
+      );
+    });
+  });
+});

x-pack/plugins/alerting/server/connector_adapters/connector_adapter_registry.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import Boom from '@hapi/boom';
+import { i18n } from '@kbn/i18n';
+
+import { ConnectorAdapter } from './types';
+
+export class ConnectorAdapterRegistry {
+  private readonly connectorAdapters: Map<string, ConnectorAdapter> = new Map();
+
+  public has(connectorTypeId: string): boolean {
+    return this.connectorAdapters.has(connectorTypeId);
+  }
+
+  public register(connectorAdapter: ConnectorAdapter) {
+    if (this.has(connectorAdapter.connectorTypeId)) {
+      throw new Error(
+        `${connectorAdapter.connectorTypeId} is already registered to the ConnectorAdapterRegistry`
+      );
+    }
+
+    this.connectorAdapters.set(connectorAdapter.connectorTypeId, connectorAdapter);
+  }
+
+  public get(connectorTypeId: string): ConnectorAdapter {
+    if (!this.connectorAdapters.has(connectorTypeId)) {
+      throw Boom.badRequest(
+        i18n.translate(
+          'xpack.alerting.connectorAdapterRegistry.get.missingConnectorAdapterErrorMessage',
+          {
+            defaultMessage: 'Connector adapter "{connectorTypeId}" is not registered.',
+            values: {
+              connectorTypeId,
+            },
+          }
+        )
+      );
+    }
+
+    return this.connectorAdapters.get(connectorTypeId)!;
+  }
+}

x-pack/plugins/alerting/server/connector_adapters/types.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { ObjectType } from '@kbn/config-schema';
+import type {
+  RuleActionParams as GenericRuleActionParams,
+  RuleTypeParams,
+  SanitizedRule,
+} from '../../common';
+import { CombinedSummarizedAlerts } from '../types';
+
+type ActionTypeParams = Record<string, unknown>;
+
+type Rule = Pick<SanitizedRule<RuleTypeParams>, 'id' | 'name' | 'tags'>;
+
+interface BuildActionParamsArgs<
+  RuleActionParams extends GenericRuleActionParams = GenericRuleActionParams
+> {
+  alerts: CombinedSummarizedAlerts;
+  rule: Rule;
+  params: RuleActionParams;
+  spaceId: string;
+  ruleUrl?: string;
+}
+
+export interface ConnectorAdapter {
+  connectorTypeId: string;
+  /**
+   * The schema of the action persisted
+   * in the rule. The schema will be validated
+   * when a rule is created or updated.
+   * The schema should be backwards compatible
+   * and should never introduce any breaking
+   * changes.
+   */
+  ruleActionParamsSchema: ObjectType;
+  buildActionParams: <RuleActionParams extends GenericRuleActionParams>(
+    args: BuildActionParamsArgs<RuleActionParams>
+  ) => ActionTypeParams;
+}

x-pack/plugins/alerting/server/lib/alerting_event_logger/alerting_event_logger.ts

@@ -54,7 +54,7 @@ interface AlertOpts {
   maintenanceWindowIds?: string[];
 }
 
-interface ActionOpts {
+export interface ActionOpts {
   id: string;
   typeId: string;
   alertId?: string;

x-pack/plugins/alerting/server/mocks.ts

@@ -36,6 +36,7 @@ const createSetupMock = () => {
       getContextInitializationPromise: jest.fn(),
     },
     getDataStreamAdapter: jest.fn(),
+    registerConnectorAdapter: jest.fn(),
   };
   return mock;
 };

x-pack/plugins/alerting/server/plugin.test.ts

@@ -37,6 +37,7 @@ jest.mock('./alerts_service/alerts_service', () => ({
 import { SharePluginStart } from '@kbn/share-plugin/server';
 import { dataViewPluginMocks } from '@kbn/data-views-plugin/public/mocks';
 import { generateAlertingConfig } from './test_utils';
+import { schema } from '@kbn/config-schema';
 
 const sampleRuleType: RuleType<never, never, {}, never, never, 'default', 'recovered', {}> = {
   id: 'test',
@@ -220,6 +221,32 @@ describe('Alerting Plugin', () => {
             expect(ruleType.cancelAlertsOnRuleTimeout).toBe(false);
           });
         });
+
+        describe('registerConnectorAdapter()', () => {
+          let setup: PluginSetupContract;
+
+          beforeEach(async () => {
+            const context = coreMock.createPluginInitializerContext<AlertingConfig>(
+              generateAlertingConfig()
+            );
+
+            plugin = new AlertingPlugin(context);
+            setup = await plugin.setup(setupMocks, mockPlugins);
+          });
+
+          it('should register a connector adapter', () => {
+            const adapter = {
+              connectorTypeId: '.test',
+              ruleActionParamsSchema: schema.object({}),
+              buildActionParams: jest.fn(),
+            };
+
+            setup.registerConnectorAdapter(adapter);
+
+            // @ts-expect-error: private properties cannot be accessed
+            expect(plugin.connectorAdapterRegistry.get('.test')).toEqual(adapter);
+          });
+        });
       });
 
       describe('start()', () => {

x-pack/plugins/alerting/server/plugin.ts

@@ -99,6 +99,8 @@ import {
 } from './alerts_service';
 import { rulesSettingsFeature } from './rules_settings_feature';
 import { maintenanceWindowFeature } from './maintenance_window_feature';
+import { ConnectorAdapterRegistry } from './connector_adapters/connector_adapter_registry';
+import { ConnectorAdapter } from './connector_adapters/types';
 import { DataStreamAdapter, getDataStreamAdapter } from './alerts_service/lib/data_stream_adapter';
 import { createGetAlertIndicesAliasFn, GetAlertIndicesAlias } from './lib';
 
@@ -117,6 +119,7 @@ export const LEGACY_EVENT_LOG_ACTIONS = {
 };
 
 export interface PluginSetupContract {
+  registerConnectorAdapter(adapter: ConnectorAdapter): void;
   registerType<
     Params extends RuleTypeParams = RuleTypeParams,
     ExtractedParams extends RuleTypeParams = RuleTypeParams,
@@ -213,6 +216,7 @@ export class AlertingPlugin {
   private alertsService: AlertsService | null;
   private pluginStop$: Subject<void>;
   private dataStreamAdapter?: DataStreamAdapter;
+  private readonly connectorAdapterRegistry = new ConnectorAdapterRegistry();
 
   constructor(initializerContext: PluginInitializerContext) {
     this.config = initializerContext.config.get();
@@ -368,6 +372,9 @@ export class AlertingPlugin {
     });
 
     return {
+      registerConnectorAdapter: (adapter: ConnectorAdapter) => {
+        this.connectorAdapterRegistry.register(adapter);
+      },
       registerType: <
         Params extends RuleTypeParams = never,
         ExtractedParams extends RuleTypeParams = never,
@@ -494,6 +501,7 @@ export class AlertingPlugin {
       eventLogger: this.eventLogger,
       minimumScheduleInterval: this.config.rules.minimumScheduleInterval,
       maxScheduledPerMinute: this.config.rules.maxScheduledPerMinute,
+      connectorAdapterRegistry: this.connectorAdapterRegistry,
     });
 
     rulesSettingsClientFactory.initialize({
@@ -556,6 +564,7 @@ export class AlertingPlugin {
       usageCounter: this.usageCounter,
       getRulesSettingsClientWithRequest,
       getMaintenanceWindowClientWithRequest,
+      connectorAdapterRegistry: this.connectorAdapterRegistry,
     });
 
     this.eventLogService!.registerSavedObjectProvider('alert', (request) => {

x-pack/plugins/alerting/server/rules_client/lib/create_new_api_key_set.test.ts

@@ -21,6 +21,7 @@ import { RawRule } from '../../types';
 import { getBeforeSetup, mockedDateString } from '../tests/lib';
 import { createNewAPIKeySet } from './create_new_api_key_set';
 import { RulesClientContext } from '../types';
+import { ConnectorAdapterRegistry } from '../../connector_adapters/connector_adapter_registry';
 
 const taskManager = taskManagerMock.createStart();
 const ruleTypeRegistry = ruleTypeRegistryMock.create();
@@ -52,6 +53,7 @@ const rulesClientParams: jest.Mocked<RulesClientContext> = {
   fieldsToExcludeFromPublicApi: [],
   isAuthenticationTypeAPIKey: jest.fn(),
   getAuthenticationAPIKey: jest.fn(),
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 
 const username = 'test';

x-pack/plugins/alerting/server/rules_client/tests/aggregate.test.ts

@@ -27,6 +27,7 @@ import {
 } from '../../../common';
 import { RegistryRuleType } from '../../rule_type_registry';
 import { fromKueryExpression, nodeTypes } from '@kbn/es-query';
+import { ConnectorAdapterRegistry } from '../../connector_adapters/connector_adapter_registry';
 
 const taskManager = taskManagerMock.createStart();
 const ruleTypeRegistry = ruleTypeRegistryMock.create();
@@ -59,6 +60,7 @@ const rulesClientParams: jest.Mocked<ConstructorOptions> = {
   kibanaVersion,
   isAuthenticationTypeAPIKey: jest.fn(),
   getAuthenticationAPIKey: jest.fn(),
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 
 beforeEach(() => {

x-pack/plugins/alerting/server/rules_client/tests/bulk_delete.test.ts

@@ -29,6 +29,7 @@ import {
 } from './test_helpers';
 import { schema } from '@kbn/config-schema';
 import { migrateLegacyActions } from '../lib';
+import { ConnectorAdapterRegistry } from '../../connector_adapters/connector_adapter_registry';
 
 jest.mock('../lib/siem_legacy_actions/migrate_legacy_actions', () => {
   return {
@@ -78,6 +79,7 @@ const rulesClientParams: jest.Mocked<ConstructorOptions> = {
   minimumScheduleInterval: { value: '1m', enforce: false },
   isAuthenticationTypeAPIKey: jest.fn(),
   getAuthenticationAPIKey: jest.fn(),
+  connectorAdapterRegistry: new ConnectorAdapterRegistry(),
 };
 
 const getBulkOperationStatusErrorResponse = (statusCode: number) => ({