[RAM] System actions update rule api (#171099)

## Summary

Summarize your PR. If it involves visual changes include a screenshot or
gif.


- [ ] [Unit or functional
tests](https://www.elastic.co/guide/en/kibana/master/development-tests.html)
were updated or added to match the most common scenarios

---------

Co-authored-by: kibanamachine <42973632+kibanamachine@users.noreply.github.com>

x-pack/plugins/alerting/server/application/rule/transforms/index.ts

@@ -8,3 +8,5 @@
 export { transformRuleAttributesToRuleDomain } from './transform_rule_attributes_to_rule_domain';
 export { transformRuleDomainToRuleAttributes } from './transform_rule_domain_to_rule_attributes';
 export { transformRuleDomainToRule } from './transform_rule_domain_to_rule';
+export { transformDomainActionsToRawActions } from './transform_domain_actions_to_raw_actions';
+export { transformRawActionsToDomainActions } from './transform_raw_actions_to_domain_actions';

x-pack/plugins/alerting/server/routes/bulk_enable_rules.test.ts

@@ -206,7 +206,6 @@ describe('bulkEnableRulesRoute', () => {
  bulkEnableRulesRoute({ router, licenseState });
  const [_, handler] = router.patch.mock.calls[0];
 
- // rulesClient.bulkDisableRules.mockResolvedValueOnce(bulkDisableActionsResult);
  rulesClient.bulkEnableRules.mockResolvedValueOnce(bulkEnableActionsResult);
 
  const [context, req, res] = mockHandlerArguments(

x-pack/plugins/alerting/server/routes/lib/actions_schema.ts

@@ -12,7 +12,7 @@ import { validateHours } from './validate_hours';
 
 export const actionsSchema = schema.arrayOf(
  schema.object({
- group: schema.string(),
+ group: schema.maybe(schema.string()),
  id: schema.string(),
  params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
  frequency: schema.maybe(

x-pack/plugins/alerting/server/routes/lib/index.ts

@@ -18,7 +18,11 @@ export type {
 } from './rewrite_request_case';
 export { verifyAccessAndContext } from './verify_access_and_context';
 export { countUsageOfPredefinedIds } from './count_usage_of_predefined_ids';
-export { rewriteActionsReq, rewriteActionsRes } from './rewrite_actions';
+export {
+ rewriteActionsReq,
+ rewriteActionsRes,
+ rewriteActionsReqWithSystemActions,
+} from './rewrite_actions';
 export { actionsSchema } from './actions_schema';
 export { rewriteRule, rewriteRuleLastRun } from './rewrite_rule';
 export { rewriteNamespaces } from './rewrite_namespaces';

x-pack/plugins/alerting/server/routes/lib/rewrite_actions.ts

@@ -9,6 +9,7 @@ import { omit } from 'lodash';
 import { NormalizedAlertAction } from '../../rules_client';
 import { RuleAction } from '../../types';
 import { actionsSchema } from './actions_schema';
+import { RuleActionTypes } from '../../../common';
 
 export const rewriteActionsReq = (
  actions?: TypeOf<typeof actionsSchema>
@@ -31,6 +32,42 @@ export const rewriteActionsReq = (
  });
 };
 
+export const rewriteActionsReqWithSystemActions = (
+ actions: TypeOf<typeof actionsSchema>,
+ isSystemAction: (connectorId: string) => boolean
+): NormalizedAlertAction[] => {
+ if (!actions) return [];
+
+ return actions.map(({ frequency, alerts_filter: alertsFilter, ...action }) => {
+ if (isSystemAction(action.id)) {
+ return {
+ id: action.id,
+ params: action.params,
+ ...(action.uuid ? { uuid: action.uuid } : {}),
+ type: RuleActionTypes.SYSTEM,
+ };
+ }
+
+ return {
+ group: action.group ?? 'default',
+ id: action.id,
+ params: action.params,
+ ...(action.uuid ? { uuid: action.uuid } : {}),
+ ...(frequency
+ ? {
+ frequency: {
+ summary: frequency.summary,
+ throttle: frequency.throttle,
+ notifyWhen: frequency.notify_when,
+ },
+ }
+ : {}),
+ ...(alertsFilter ? { alertsFilter } : {}),
+ type: RuleActionTypes.DEFAULT,
+ };
+ });
+};
+
 export const rewriteActionsRes = (actions?: RuleAction[]) => {
  const rewriteFrequency = ({ notifyWhen, ...rest }: NonNullable<RuleAction['frequency']>) => ({
  ...rest,

x-pack/plugins/alerting/server/routes/rule/transforms/index.ts

@@ -7,3 +7,5 @@
 
 export { transformRuleToRuleResponse } from './transform_rule_to_rule_response/latest';
 export { transformRuleToRuleResponse as transformRuleToRuleResponseV1 } from './transform_rule_to_rule_response/v1';
+export { transformRuleActions } from './transform_rule_to_rule_response/latest';
+export { transformRuleActions as transformRuleActionsV1 } from './transform_rule_to_rule_response/v1';

x-pack/plugins/alerting/server/routes/rule/transforms/transform_rule_to_rule_response/latest.ts

@@ -5,4 +5,4 @@
  * 2.0.
  */
 
-export { transformRuleToRuleResponse } from './v1';
+export { transformRuleToRuleResponse, transformRuleActions } from './v1';

x-pack/plugins/alerting/server/routes/rule/transforms/transform_rule_to_rule_response/v1.ts

@@ -39,7 +39,7 @@ const transformMonitoring = (monitoring: Monitoring): MonitoringV1 => {
  };
 };
 
-const transformRuleActions = (actions: Rule['actions']): RuleResponseV1['actions'] => {
+export const transformRuleActions = (actions: Rule['actions']): RuleResponseV1['actions'] => {
  return actions.map((action) => {
  if (action.type === RuleActionTypes.SYSTEM) {
  const { id, actionTypeId, params, uuid } = action;

x-pack/plugins/alerting/server/routes/update_rule.ts

@@ -6,18 +6,17 @@
  */
 
 import { schema } from '@kbn/config-schema';
+import { TypeOf } from '@kbn/config-schema/src/types/object_type';
 import { IRouter } from '@kbn/core/server';
 import { ILicenseState, RuleTypeDisabledError, validateDurationSchema } from '../lib';
 import { UpdateOptions } from '../rules_client';
 import {
  verifyAccessAndContext,
- RewriteResponseCase,
- RewriteRequestCase,
+ AsApiContract,
  handleDisabledApiKeysError,
- rewriteActionsReq,
- rewriteActionsRes,
  actionsSchema,
  rewriteRuleLastRun,
+ rewriteActionsReqWithSystemActions,
 } from './lib';
 import {
  RuleTypeParams,
@@ -26,6 +25,13 @@ import {
  validateNotifyWhenType,
  PartialRule,
 } from '../types';
+import { transformRuleActions } from './rule/transforms';
+import { RuleResponse } from '../../common/routes/rule/response';
+
+type RuleBody = TypeOf<typeof bodySchema>;
+interface RuleUpdateOptionsResult extends Omit<UpdateOptions<RuleTypeParams>, 'data'> {
+ data: RuleBody;
+}
 
 const paramSchema = schema.object({
  id: schema.string(),
@@ -54,18 +60,22 @@ const bodySchema = schema.object({
  ),
 });
 
-const rewriteBodyReq: RewriteRequestCase<UpdateOptions<RuleTypeParams>> = (result) => {
+const rewriteBodyReq = (
+ result: RuleUpdateOptionsResult,
+ isSystemAction: (connectorId: string) => boolean
+): UpdateOptions<RuleTypeParams> => {
  const { notify_when: notifyWhen, actions, ...rest } = result.data;
  return {
  ...result,
  data: {
  ...rest,
  notifyWhen,
- actions: rewriteActionsReq(actions),
+ actions: rewriteActionsReqWithSystemActions(actions, isSystemAction),
  },
  };
 };
-const rewriteBodyRes: RewriteResponseCase<PartialRule<RuleTypeParams>> = ({
+
+const rewriteBodyRes = ({
  actions,
  alertTypeId,
  scheduledTaskId,
@@ -84,7 +94,10 @@ const rewriteBodyRes: RewriteResponseCase<PartialRule<RuleTypeParams>> = ({
  lastRun,
  nextRun,
  ...rest
-}) => ({
+}: PartialRule<RuleTypeParams>): Omit<
+ AsApiContract<PartialRule<RuleTypeParams> & { actions?: RuleResponse['actions'] }>,
+ 'actions'
+> => ({
  ...rest,
  api_key_owner: apiKeyOwner,
  created_by: createdBy,
@@ -109,7 +122,7 @@ const rewriteBodyRes: RewriteResponseCase<PartialRule<RuleTypeParams>> = ({
  : {}),
  ...(actions
  ? {
- actions: rewriteActionsRes(actions),
+ actions: transformRuleActions(actions),
  }
  : {}),
  ...(lastRun ? { last_run: rewriteRuleLastRun(lastRun) } : {}),
@@ -133,10 +146,16 @@ export const updateRuleRoute = (
  router.handleLegacyErrors(
  verifyAccessAndContext(licenseState, async function (context, req, res) {
  const rulesClient = (await context.alerting).getRulesClient();
+ const actionsClient = (await context.actions).getActionsClient();
+
  const { id } = req.params;
  const rule = req.body;
  try {
- const alertRes = await rulesClient.update(rewriteBodyReq({ id, data: rule }));
+ const alertRes = await rulesClient.update(
+ rewriteBodyReq({ id, data: rule }, (connectorId: string) =>
+ actionsClient.isSystemAction(connectorId)
+ )
+ );
  return res.ok({
  body: rewriteBodyRes(alertRes),
  });

x-pack/plugins/alerting/server/rules_client/methods/update.ts

@@ -14,6 +14,8 @@ import {
  RuleTypeParams,
  RuleNotifyWhenType,
  IntervalSchedule,
+ RuleSystemAction,
+ RuleActionTypes,
 } from '../../types';
 import { validateRuleTypeParams, getRuleNotifyWhenType } from '../../lib';
 import { WriteOperations, AlertingAuthorizationEntity } from '../../authorization';
@@ -37,6 +39,12 @@ import {
  validateScheduleLimit,
  ValidateScheduleLimitResult,
 } from '../../application/rule/methods/get_schedule_frequency';
+import { validateSystemActions } from '../../lib/validate_system_actions';
+import { denormalizeActions } from '../lib/denormalize_actions';
+import {
+ transformDomainActionsToRawActions,
+ transformRawActionsToDomainActions,
+} from '../../application/rule/transforms';
 
 type ShouldIncrementRevision = (params?: RuleTypeParams) => boolean;
 
@@ -211,12 +219,22 @@ async function updateAlert<Params extends RuleTypeParams>(
 ): Promise<PartialRule<Params>> {
  const { attributes, version } = currentRule;
  const data = { ...initialData, actions: addGeneratedActionValues(initialData.actions) };
+ const actionsClient = await context.getActionsClient();
+
+ const systemActions = initialData.actions.filter(
+ (action): action is RuleSystemAction => action.type === RuleActionTypes.SYSTEM
+ );
 
  const ruleType = context.ruleTypeRegistry.get(attributes.alertTypeId);
 
  // Validate
  const validatedAlertTypeParams = validateRuleTypeParams(data.params, ruleType.validate.params);
  await validateActions(context, ruleType, data, allowMissingConnectorSecrets);
+ await validateSystemActions({
+ actionsClient,
+ connectorAdapterRegistry: context.connectorAdapterRegistry,
+ systemActions,
+ });
 
  // Throw error if schedule interval is less than the minimum and we are enforcing it
  const intervalInMs = parseDuration(data.schedule.interval);
@@ -230,11 +248,14 @@ async function updateAlert<Params extends RuleTypeParams>(
  }
 
  // Extract saved object references for this rule
- const {
- references,
- params: updatedParams,
- actions,
- } = await extractReferences(context, ruleType, data.actions, validatedAlertTypeParams);
+ const { references, params: updatedParams } = await extractReferences(
+ context,
+ ruleType,
+ data.actions,
+ validatedAlertTypeParams
+ );
+
+ const { actions: actionsWithRefs } = await denormalizeActions(context, data.actions);
 
  const username = await context.getUserName();
 
@@ -262,7 +283,7 @@ async function updateAlert<Params extends RuleTypeParams>(
  ...data,
  ...apiKeyAttributes,
  params: updatedParams as RawRule['params'],
- actions,
+ actions: actionsWithRefs,
  notifyWhen,
  revision,
  updatedBy: username,
@@ -278,7 +299,7 @@ async function updateAlert<Params extends RuleTypeParams>(
  try {
  updatedObject = await context.unsecuredSavedObjectsClient.create<RawRule>(
  'alert',
- createAttributes,
+ { ...createAttributes, actions: transformDomainActionsToRawActions(createAttributes) },
  {
  id,
  overwrite: true,
@@ -311,8 +332,7 @@ async function updateAlert<Params extends RuleTypeParams>(
  `Rule schedule interval (${data.schedule.interval}) for "${ruleType.id}" rule type with ID "${id}" is less than the minimum value (${context.minimumScheduleInterval.value}). Running rules at this interval may impact alerting performance. Set "xpack.alerting.rules.minimumScheduleInterval.enforce" to true to prevent such changes.`
  );
  }
-
- return getPartialRuleFromRaw(
+ const rules = getPartialRuleFromRaw<Params>(
  context,
  id,
  ruleType,
@@ -321,4 +341,15 @@ async function updateAlert<Params extends RuleTypeParams>(
  false,
  true
  );
+
+ return {
+ ...rules,
+ actions: transformRawActionsToDomainActions({
+ ruleId: id,
+ references: updatedObject.references,
+ actions: updatedObject.attributes.actions,
+ omitGeneratedValues: false,
+ isSystemAction: (connectorId: string) => actionsClient.isSystemAction(connectorId),
+ }),
+ };
 }