[Alert Summaries] [BE] Move “Notify When” and throttle from rule to action

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

@@ -20,7 +20,7 @@ export interface AlertSummary {
   ruleTypeId: string;
   consumer: string;
   muteAll: boolean;
-  throttle: string | null;
+  throttle?: string | null;
   enabled: boolean;
   statusStartDate: string;
   statusEndDate: string;

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

@@ -72,6 +72,11 @@ export interface RuleAction {
   id: string;
   actionTypeId: string;
   params: RuleActionParams;
+  frequency?: {
+    summary: boolean;
+    notifyWhen: RuleNotifyWhenType;
+    throttle: string | null;
+  };
 }
 
 export interface RuleAggregations {
@@ -107,9 +112,9 @@ export interface Rule<Params extends RuleTypeParams = never> {
   updatedAt: Date;
   apiKey: string | null;
   apiKeyOwner: string | null;
-  throttle: string | null;
+  throttle?: string | null;
   muteAll: boolean;
-  notifyWhen: RuleNotifyWhenType | null;
+  notifyWhen?: RuleNotifyWhenType | null;
   mutedInstanceIds: string[];
   executionStatus: RuleExecutionStatus;
   monitoring?: RuleMonitoring;

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

@@ -5,7 +5,7 @@
  * 2.0.
  */
 
-const RuleNotifyWhenTypeValues = [
+export const RuleNotifyWhenTypeValues = [
   'onActionGroupChange',
   'onActiveAlert',
   'onThrottleInterval',

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

@@ -31,7 +31,7 @@ export function alertSummaryFromEventLog(params: AlertSummaryFromEventLogParams)
     statusEndDate: dateEnd,
     status: 'OK',
     muteAll: rule.muteAll,
-    throttle: rule.throttle,
+    throttle: rule.throttle ?? null,
     enabled: rule.enabled,
     lastRun: undefined,
     errorMessages: [],

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

@@ -0,0 +1,24 @@
+/*
+ * 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 { RuleTypeParams, RuleTypeParamsValidator } from '../types';
+
+export function validateRuleTypeParams<Params extends RuleTypeParams>(
+  params: Record<string, unknown>,
+  validator?: RuleTypeParamsValidator<Params>
+): Params {
+  if (!validator) {
+    return params as Params;
+  }
+
+  try {
+    return validator.validate(params);
+  } catch (err) {
+    throw Boom.badRequest(`params invalid: ${err.message}`);
+  }
+}

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

@@ -11,9 +11,11 @@ import { CreateOptions } from '../rules_client';
 import {
   RewriteRequestCase,
   RewriteResponseCase,
+  rewriteActions,
   handleDisabledApiKeysError,
   verifyAccessAndContext,
   countUsageOfPredefinedIds,
+  actionsSchema,
 } from './lib';
 import {
   SanitizedRule,
@@ -30,20 +32,13 @@ export const bodySchema = schema.object({
   enabled: schema.boolean({ defaultValue: true }),
   consumer: schema.string(),
   tags: schema.arrayOf(schema.string(), { defaultValue: [] }),
-  throttle: schema.nullable(schema.string({ validate: validateDurationSchema })),
+  throttle: schema.nullable(schema.maybe(schema.string({ validate: validateDurationSchema }))),
   params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
   schedule: schema.object({
     interval: schema.string({ validate: validateDurationSchema }),
   }),
-  actions: schema.arrayOf(
-    schema.object({
-      group: schema.string(),
-      id: schema.string(),
-      params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
-    }),
-    { defaultValue: [] }
-  ),
-  notify_when: schema.string({ validate: validateNotifyWhenType }),
+  actions: actionsSchema,
+  notify_when: schema.maybe(schema.string({ validate: validateNotifyWhenType })),
 });
 
 const rewriteBodyReq: RewriteRequestCase<CreateOptions<RuleTypeParams>['data']> = ({
@@ -55,6 +50,7 @@ const rewriteBodyReq: RewriteRequestCase<CreateOptions<RuleTypeParams>['data']>
   alertTypeId,
   notifyWhen,
 });
+
 const rewriteBodyRes: RewriteResponseCase<SanitizedRule<RuleTypeParams>> = ({
   actions,
   alertTypeId,
@@ -127,6 +123,7 @@ export const createRuleRoute = ({ router, licenseState, usageCounter }: RouteOpt
               await rulesClient.create<RuleTypeParams>({
                 data: rewriteBodyReq({
                   ...rule,
+                  actions: rewriteActions(rule.actions),
                   notify_when: rule.notify_when as RuleNotifyWhenType,
                 }),
                 options: { id: params?.id },

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

@@ -0,0 +1,29 @@
+/*
+ * 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 { validateDurationSchema } from '../../lib';
+
+export const actionsSchema = schema.arrayOf(
+  schema.object({
+    group: schema.string(),
+    id: schema.string(),
+    params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
+    frequency: schema.maybe(
+      schema.object({
+        summary: schema.boolean(),
+        notify_when: schema.oneOf([
+          schema.literal('onActionGroupChange'),
+          schema.literal('onActiveAlert'),
+          schema.literal('onThrottleInterval'),
+        ]),
+        throttle: schema.nullable(schema.string({ validate: validateDurationSchema })),
+      })
+    ),
+  }),
+  { defaultValue: [] }
+);

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

@@ -19,4 +19,6 @@ export type {
 export { verifyAccessAndContext } from './verify_access_and_context';
 export { countUsageOfPredefinedIds } from './count_usage_of_predefined_ids';
 export { rewriteRule } from './rewrite_rule';
+export { rewriteActions } from './rewrite_actions';
+export { actionsSchema } from './actions_schema';
 export { rewriteNamespaces } from './rewrite_namespaces';

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

@@ -0,0 +1,32 @@
+/*
+ * 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 { CamelToSnake, RewriteRequestCase } from './rewrite_request_case';
+import { RuleAction } from '../../types';
+
+type ReqRuleAction = Omit<RuleAction, 'actionTypeId' | 'frequency'> & {
+  frequency?: {
+    [K in keyof NonNullable<RuleAction['frequency']> as CamelToSnake<K>]: NonNullable<
+      RuleAction['frequency']
+    >[K];
+  };
+};
+export const rewriteActions: (
+  actions?: ReqRuleAction[]
+) => Array<Omit<RuleAction, 'actionTypeId'>> = (actions) => {
+  const rewriteFrequency: RewriteRequestCase<NonNullable<RuleAction['frequency']>> = ({
+    notify_when: notifyWhen,
+    ...rest
+  }) => ({ ...rest, notifyWhen });
+  if (!actions) return [];
+  return actions.map(
+    (action) =>
+      ({
+        ...action,
+        ...(action.frequency ? { frequency: rewriteFrequency(action.frequency) } : {}),
+      } as RuleAction)
+  );
+};

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

@@ -71,7 +71,7 @@ export type RewriteResponseCase<T> = (
  *
  * For more details see this PR comment: https://github.com/microsoft/TypeScript/pull/40336#issuecomment-686723087
  */
-type CamelToSnake<T extends string> = string extends T
+export type CamelToSnake<T extends string> = string extends T
   ? string
   : T extends `${infer C0}${infer C1}${infer R}`
   ? `${C0 extends Uppercase<C0> ? '_' : ''}${Lowercase<C0>}${C1 extends Uppercase<C1>

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

@@ -45,10 +45,18 @@ export const rewriteRule = ({
     last_execution_date: executionStatus.lastExecutionDate,
     last_duration: executionStatus.lastDuration,
   },
-  actions: actions.map(({ group, id, actionTypeId, params }) => ({
+  actions: actions.map(({ group, id, actionTypeId, params, frequency }) => ({
     group,
     id,
     params,
     connector_type_id: actionTypeId,
+    ...(frequency
+      ? {
+          frequency: {
+            ...frequency,
+            notify_when: frequency.notifyWhen,
+          },
+        }
+      : {}),
   })),
 });

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

@@ -15,6 +15,8 @@ import {
   RewriteResponseCase,
   RewriteRequestCase,
   handleDisabledApiKeysError,
+  rewriteActions,
+  actionsSchema,
 } from './lib';
 import {
   RuleTypeParams,
@@ -34,17 +36,10 @@ const bodySchema = schema.object({
   schedule: schema.object({
     interval: schema.string({ validate: validateDurationSchema }),
   }),
-  throttle: schema.nullable(schema.string({ validate: validateDurationSchema })),
+  throttle: schema.nullable(schema.maybe(schema.string({ validate: validateDurationSchema }))),
   params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
-  actions: schema.arrayOf(
-    schema.object({
-      group: schema.string(),
-      id: schema.string(),
-      params: schema.recordOf(schema.string(), schema.any(), { defaultValue: {} }),
-    }),
-    { defaultValue: [] }
-  ),
-  notify_when: schema.string({ validate: validateNotifyWhenType }),
+  actions: actionsSchema,
+  notify_when: schema.maybe(schema.string({ validate: validateNotifyWhenType })),
 });
 
 const rewriteBodyReq: RewriteRequestCase<UpdateOptions<RuleTypeParams>> = (result) => {
@@ -132,6 +127,7 @@ export const updateRuleRoute = (
                 id,
                 data: {
                   ...rule,
+                  actions: rewriteActions(rule.actions),
                   notify_when: rule.notify_when as RuleNotifyWhenType,
                 },
               })