[Actions] Set system actions on Kibana start

x-pack/packages/kbn-elastic-assistant/impl/connectorland/connector_selector/index.tsx

@@ -50,6 +50,7 @@ export const ConnectorSelector: React.FC<Props> = React.memo(
  enabledInLicense: true,
  minimumLicenseRequired: 'platinum',
  supportedFeatureIds: ['general'],
+ isSystemActionType: false,
  id: '.gen-ai',
  name: 'Generative AI',
  enabled: true,

x-pack/packages/kbn-elastic-assistant/impl/connectorland/connector_setup/index.tsx

@@ -92,6 +92,7 @@ export const useConnectorSetup = ({
  actionTypes?.find((at) => at.id === GEN_AI_CONNECTOR_ID) ?? {
  enabledInConfig: true,
  enabledInLicense: true,
+ isSystemActionType: false,
  minimumLicenseRequired: 'platinum',
  supportedFeatureIds: ['general'],
  id: '.gen-ai',

x-pack/plugins/actions/common/types.ts

@@ -22,6 +22,7 @@ export interface ActionType {
  enabledInLicense: boolean;
  minimumLicenseRequired: LicenseType;
  supportedFeatureIds: string[];
+ isSystemActionType: boolean;
 }
 
 export enum InvalidEmailReason {

x-pack/plugins/actions/server/action_type_registry.mock.ts

@@ -17,6 +17,7 @@ const createActionTypeRegistryMock = () => {
  ensureActionTypeEnabled: jest.fn(),
  isActionTypeEnabled: jest.fn(),
  isActionExecutable: jest.fn(),
+ isSystemActionType: jest.fn(),
  getUtils: jest.fn(),
  };
  return mocked;

x-pack/plugins/actions/server/action_type_registry.test.ts

@@ -36,7 +36,7 @@ describe('actionTypeRegistry', () => {
  ),
  actionsConfigUtils: mockedActionsConfig,
  licenseState: mockedLicenseState,
- preconfiguredActions: [
+ inMemoryConnectors: [
  {
  actionTypeId: 'foo',
  config: {},
@@ -47,6 +47,16 @@ describe('actionTypeRegistry', () => {
  isDeprecated: false,
  isSystemAction: false,
  },
+ {
+ actionTypeId: '.cases',
+ config: {},
+ id: 'system-connector-.cases',
+ name: 'System action: .cases',
+ secrets: {},
+ isPreconfigured: false,
+ isDeprecated: false,
+ isSystemAction: true,
+ },
  ],
  };
  });
@@ -217,7 +227,7 @@ describe('actionTypeRegistry', () => {
  expect(actionTypeRegistryParams.licensing.featureUsage.register).not.toHaveBeenCalled();
  });
 
- test('does not allows registering system actions', () => {
+ test('allows registering system actions', () => {
  const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
 
  expect(() =>
@@ -226,15 +236,15 @@ describe('actionTypeRegistry', () => {
  name: 'My action type',
  minimumLicenseRequired: 'basic',
  supportedFeatureIds: ['alerting'],
- isSystemAction: true,
+ isSystemActionType: true,
  validate: {
  config: { schema: schema.object({}) },
  secrets: { schema: schema.object({}) },
  params: { schema: schema.object({}) },
  },
  executor,
  })
- ).toThrowErrorMatchingInlineSnapshot(`"System actions are not supported"`);
+ ).not.toThrow();
  });
  });
 
@@ -302,6 +312,7 @@ describe('actionTypeRegistry', () => {
  enabledInLicense: true,
  minimumLicenseRequired: 'basic',
  supportedFeatureIds: ['alerting'],
+ isSystemActionType: false,
  },
  ]);
  expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalled();
@@ -345,11 +356,46 @@ describe('actionTypeRegistry', () => {
  enabledInLicense: true,
  minimumLicenseRequired: 'basic',
  supportedFeatureIds: ['alerting'],
+ isSystemActionType: false,
  },
  ]);
  expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalled();
  expect(mockedLicenseState.isLicenseValidForActionType).toHaveBeenCalled();
  });
+
+ test('sets the isSystemActionType correctly for system actions', () => {
+ mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+ const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+ actionTypeRegistry.register({
+ id: '.cases',
+ name: 'Cases',
+ minimumLicenseRequired: 'platinum',
+ supportedFeatureIds: ['alerting'],
+ validate: {
+ config: { schema: schema.object({}) },
+ secrets: { schema: schema.object({}) },
+ params: { schema: schema.object({}) },
+ },
+ isSystemActionType: true,
+ executor,
+ });
+
+ const actionTypes = actionTypeRegistry.list();
+
+ expect(actionTypes).toEqual([
+ {
+ id: '.cases',
+ name: 'Cases',
+ enabled: true,
+ enabledInConfig: true,
+ enabledInLicense: true,
+ minimumLicenseRequired: 'platinum',
+ supportedFeatureIds: ['alerting'],
+ isSystemActionType: true,
+ },
+ ]);
+ });
  });
 
  describe('has()', () => {
@@ -378,6 +424,7 @@ describe('actionTypeRegistry', () => {
 
  describe('isActionTypeEnabled', () => {
  let actionTypeRegistry: ActionTypeRegistry;
+
  const fooActionType: ActionType = {
  id: 'foo',
  name: 'Foo',
@@ -393,9 +440,17 @@ describe('actionTypeRegistry', () => {
  },
  };
 
+ const systemActionType: ActionType = {
+ ...fooActionType,
+ id: 'system-action-type',
+ name: 'System action type',
+ isSystemActionType: true,
+ };
+
  beforeEach(() => {
  actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
  actionTypeRegistry.register(fooActionType);
+ actionTypeRegistry.register(systemActionType);
  });
 
  test('should call isActionTypeEnabled of the actions config', async () => {
@@ -417,6 +472,15 @@ describe('actionTypeRegistry', () => {
  expect(actionTypeRegistry.isActionExecutable('my-slack1', 'foo')).toEqual(true);
  });
 
+ test('should return true when isActionTypeEnabled is false and isLicenseValidForActionType is true and it has system connectors', async () => {
+ mockedActionsConfig.isActionTypeEnabled.mockReturnValue(false);
+ mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+
+ expect(
+ actionTypeRegistry.isActionExecutable('system-connector-.cases', 'system-action-type')
+ ).toEqual(true);
+ });
+
  test('should call isLicenseValidForActionType of the license state with notifyUsage false by default', async () => {
  mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
  actionTypeRegistry.isActionTypeEnabled('foo');
@@ -567,4 +631,62 @@ describe('actionTypeRegistry', () => {
  expect(result).toEqual(['foo']);
  });
  });
+
+ describe('isSystemActionType()', () => {
+ it('should return true if the action type is a system action type', () => {
+ const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+ registry.register({
+ id: '.cases',
+ name: 'Cases',
+ minimumLicenseRequired: 'platinum',
+ supportedFeatureIds: ['alerting'],
+ validate: {
+ config: { schema: schema.object({}) },
+ secrets: { schema: schema.object({}) },
+ params: { schema: schema.object({}) },
+ },
+ isSystemActionType: true,
+ executor,
+ });
+
+ const result = registry.isSystemActionType('.cases');
+ expect(result).toBe(true);
+ });
+
+ it('should return false if the action type is not a system action type', () => {
+ mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
+
+ const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+ registry.register({
+ id: 'foo',
+ name: 'Foo',
+ minimumLicenseRequired: 'basic',
+ supportedFeatureIds: ['alerting'],
+ validate: {
+ config: { schema: schema.object({}) },
+ secrets: { schema: schema.object({}) },
+ params: { schema: schema.object({}) },
+ },
+ executor,
+ });
+
+ const allTypes = registry.getAllTypes();
+ expect(allTypes.length).toBe(1);
+
+ const result = registry.isSystemActionType('foo');
+ expect(result).toBe(false);
+ });
+
+ it('should return false if the action type does not exists', () => {
+ const registry = new ActionTypeRegistry(actionTypeRegistryParams);
+
+ const allTypes = registry.getAllTypes();
+ expect(allTypes.length).toBe(0);
+
+ const result = registry.isSystemActionType('not-exist');
+ expect(result).toBe(false);
+ });
+ });
 });

x-pack/plugins/actions/server/action_type_registry.ts

@@ -14,7 +14,7 @@ import { ActionsConfigurationUtilities } from './actions_config';
 import { getActionTypeFeatureUsageName, TaskRunnerFactory, ILicenseState } from './lib';
 import {
  ActionType,
- PreConfiguredAction,
+ InMemoryConnector,
  ActionTypeConfig,
  ActionTypeSecrets,
  ActionTypeParams,
@@ -26,7 +26,7 @@ export interface ActionTypeRegistryOpts {
  taskRunnerFactory: TaskRunnerFactory;
  actionsConfigUtils: ActionsConfigurationUtilities;
  licenseState: ILicenseState;
- preconfiguredActions: PreConfiguredAction[];
+ inMemoryConnectors: InMemoryConnector[];
 }
 
 export class ActionTypeRegistry {
@@ -35,15 +35,15 @@ export class ActionTypeRegistry {
  private readonly taskRunnerFactory: TaskRunnerFactory;
  private readonly actionsConfigUtils: ActionsConfigurationUtilities;
  private readonly licenseState: ILicenseState;
- private readonly preconfiguredActions: PreConfiguredAction[];
+ private readonly inMemoryConnectors: InMemoryConnector[];
  private readonly licensing: LicensingPluginSetup;
 
  constructor(constructorParams: ActionTypeRegistryOpts) {
  this.taskManager = constructorParams.taskManager;
  this.taskRunnerFactory = constructorParams.taskRunnerFactory;
  this.actionsConfigUtils = constructorParams.actionsConfigUtils;
  this.licenseState = constructorParams.licenseState;
- this.preconfiguredActions = constructorParams.preconfiguredActions;
+ this.inMemoryConnectors = constructorParams.inMemoryConnectors;
  this.licensing = constructorParams.licensing;
  }
 
@@ -78,7 +78,7 @@ export class ActionTypeRegistry {
  }
 
  /**
- * Returns true if action type is enabled or it is a preconfigured action type.
+ * Returns true if action type is enabled or it is an in memory action type.
  */
  public isActionExecutable(
  actionId: string,
@@ -89,12 +89,17 @@ export class ActionTypeRegistry {
  return (
  actionTypeEnabled ||
  (!actionTypeEnabled &&
- this.preconfiguredActions.find(
- (preconfiguredAction) => preconfiguredAction.id === actionId
- ) !== undefined)
+ this.inMemoryConnectors.find((inMemoryConnector) => inMemoryConnector.id === actionId) !==
+ undefined)
  );
  }
 
+ /**
+ * Returns true if the action type is a system action type
+ */
+ public isSystemActionType = (actionTypeId: string): boolean =>
+ Boolean(this.actionTypes.get(actionTypeId)?.isSystemActionType);
+
  /**
  * Registers an action type to the action type registry
  */
@@ -104,18 +109,6 @@ export class ActionTypeRegistry {
  Params extends ActionTypeParams = ActionTypeParams,
  ExecutorResultData = void
  >(actionType: ActionType<Config, Secrets, Params, ExecutorResultData>) {
- // TODO: Remove when system action are supported
- if (actionType.isSystemAction) {
- throw new Error(
- i18n.translate(
- 'xpack.actions.actionTypeRegistry.register.systemActionsNotSupportedErrorMessage',
- {
- defaultMessage: 'System actions are not supported',
- }
- )
- );
- }
-
  if (this.has(actionType.id)) {
  throw new Error(
  i18n.translate(
@@ -214,6 +207,7 @@ export class ActionTypeRegistry {
  enabledInConfig: this.actionsConfigUtils.isActionTypeEnabled(actionTypeId),
  enabledInLicense: !!this.licenseState.isLicenseValidForActionType(actionType).isValid,
  supportedFeatureIds: actionType.supportedFeatureIds,
+ isSystemActionType: !!actionType.isSystemActionType,
  }));
  }
 

x-pack/plugins/actions/server/actions_client.mock.ts

@@ -27,6 +27,7 @@ const createActionsClientMock = () => {
  listTypes: jest.fn(),
  isActionTypeEnabled: jest.fn(),
  isPreconfigured: jest.fn(),
+ isSystemAction: jest.fn(),
  getGlobalExecutionKpiWithAuth: jest.fn(),
  getGlobalExecutionLogWithAuth: jest.fn(),
  };