Onboard alerting tasks to use stateSchemaByVersion for task state validation of the framework fields

x-pack/packages/kbn-alerting-state-types/index.ts

@@ -5,20 +5,22 @@
  * 2.0.
  */
 
-export type {
-  ThrottledActions,
-  LastScheduledActions,
-  AlertInstanceMeta,
-  AlertInstanceState,
-  AlertInstanceContext,
-  RawAlertInstance,
-} from './src/alert_instance';
-export { rawAlertInstance } from './src/alert_instance';
-
-export { DateFromString } from './src/date_from_string';
+export type { AlertInstanceContext } from './src/alert_instance';
 
 export type { TrackedLifecycleAlertState, WrappedLifecycleRuleState } from './src/lifecycle_state';
 export { wrappedStateRt } from './src/lifecycle_state';
 
-export type { RuleTaskState, RuleTaskParams } from './src/rule_task_instance';
-export { ActionsCompletion, ruleStateSchema, ruleParamsSchema } from './src/rule_task_instance';
+export type { RuleTaskParams } from './src/rule_task_instance';
+export { ActionsCompletion, ruleParamsSchema } from './src/rule_task_instance';
+
+export type {
+  LatestTaskStateSchema as RuleTaskState,
+  MutableLatestTaskStateSchema as MutableRuleTaskState,
+  LatestRawAlertInstanceSchema as RawAlertInstance,
+  LatestAlertInstanceMetaSchema as AlertInstanceMeta,
+  MutableLatestAlertInstanceMetaSchema as MutableAlertInstanceMeta,
+  LatestAlertInstanceStateSchema as AlertInstanceState,
+  LatestThrottledActionSchema as ThrottledActions,
+  LatestLastScheduledActionsSchema as LastScheduledActions,
+} from './src/task_state';
+export { stateSchemaByVersion, emptyState as emptyTaskState } from './src/task_state';

x-pack/packages/kbn-alerting-state-types/src/alert_instance.ts

@@ -6,50 +6,6 @@
  */
 
 import * as t from 'io-ts';
-import { DateFromString } from './date_from_string';
-
-const actionSchema = t.type({
-  date: DateFromString,
-});
-
-export const throttledActionSchema = t.record(t.string, actionSchema);
-export type ThrottledActions = t.TypeOf<typeof throttledActionSchema>;
-
-const lastScheduledActionsSchema = t.intersection([
-  t.partial({
-    subgroup: t.string,
-  }),
-  t.type({
-    group: t.string,
-    date: DateFromString,
-  }),
-  t.partial({ actions: throttledActionSchema }),
-]);
-
-export type LastScheduledActions = t.TypeOf<typeof lastScheduledActionsSchema>;
-
-const metaSchema = t.partial({
-  lastScheduledActions: lastScheduledActionsSchema,
-  // an array used to track changes in alert state, the order is based on the rule executions (oldest to most recent)
-  // true - alert has changed from active/recovered
-  // false - the status has remained either active or recovered
-  flappingHistory: t.array(t.boolean),
-  // flapping flag that indicates whether the alert is flapping
-  flapping: t.boolean,
-  maintenanceWindowIds: t.array(t.string),
-  pendingRecoveredCount: t.number,
-  uuid: t.string,
-});
-export type AlertInstanceMeta = t.TypeOf<typeof metaSchema>;
-
-const stateSchema = t.record(t.string, t.unknown);
-export type AlertInstanceState = t.TypeOf<typeof stateSchema>;
 
 const contextSchema = t.record(t.string, t.unknown);
 export type AlertInstanceContext = t.TypeOf<typeof contextSchema>;
-
-export const rawAlertInstance = t.partial({
-  state: stateSchema,
-  meta: metaSchema,
-});
-export type RawAlertInstance = t.TypeOf<typeof rawAlertInstance>;

x-pack/packages/kbn-alerting-state-types/src/rule_task_instance.ts

@@ -6,27 +6,12 @@
  */
 
 import * as t from 'io-ts';
-import { throttledActionSchema, rawAlertInstance } from './alert_instance';
-import { DateFromString } from './date_from_string';
 
 export enum ActionsCompletion {
   COMPLETE = 'complete',
   PARTIAL = 'partial',
 }
 
-export const ruleStateSchema = t.partial({
-  alertTypeState: t.record(t.string, t.unknown),
-  // tracks the active alerts
-  alertInstances: t.record(t.string, rawAlertInstance),
-  // tracks the recovered alerts for flapping purposes
-  alertRecoveredInstances: t.record(t.string, rawAlertInstance),
-  previousStartedAt: t.union([t.null, DateFromString]),
-  summaryActions: throttledActionSchema,
-});
-
-// This is serialized in the rule task document
-export type RuleTaskState = t.TypeOf<typeof ruleStateSchema>;
-
 export const ruleParamsSchema = t.intersection([
   t.type({
     alertId: t.string,

x-pack/packages/kbn-alerting-state-types/src/task_state/index.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 { type TypeOf } from '@kbn/config-schema';
+import * as v1 from './v1';
+
+export const stateSchemaByVersion = {
+  1: v1.versionDefinition,
+};
+
+const latest = v1;
+/**
+ * WARNING: Do not modify the code below when doing a new version.
+ * Update the "latest" variable instead.
+ */
+const latestTaskStateSchema = latest.versionDefinition.schema;
+export type LatestTaskStateSchema = TypeOf<typeof latestTaskStateSchema>;
+export type LatestRawAlertInstanceSchema = TypeOf<typeof latest.rawAlertInstanceSchema>;
+export type LatestAlertInstanceMetaSchema = TypeOf<typeof latest.metaSchema>;
+export type LatestAlertInstanceStateSchema = TypeOf<typeof latest.alertStateSchema>;
+export type LatestThrottledActionSchema = TypeOf<typeof latest.throttledActionSchema>;
+export type LatestLastScheduledActionsSchema = TypeOf<typeof latest.lastScheduledActionsSchema>;
+
+export const emptyState: LatestTaskStateSchema = {
+  alertTypeState: {},
+  alertInstances: {},
+  alertRecoveredInstances: {},
+  previousStartedAt: null,
+  summaryActions: {},
+};
+
+type Mutable<T> = {
+  -readonly [k in keyof T]: Mutable<T[k]>;
+};
+export type MutableLatestTaskStateSchema = Mutable<LatestTaskStateSchema>;
+export type MutableLatestAlertInstanceMetaSchema = Mutable<LatestAlertInstanceMetaSchema>;

x-pack/packages/kbn-alerting-state-types/src/task_state/lib/index.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 { isPlainObject } from 'lodash';
+
+export function isJSONObject(obj: unknown): obj is Record<string, unknown> {
+  return isPlainObject(obj);
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number';
+}
+
+export function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+
+export function isBooleanArray(value: unknown): value is boolean[] {
+  return Array.isArray(value) && value.every((item) => typeof item === 'boolean');
+}

x-pack/packages/kbn-alerting-state-types/src/task_state/v1/index.ts

@@ -0,0 +1,23 @@
+/*
+ * 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 { upMigration } from './migration';
+import { versionSchema } from './schema';
+
+export {
+  versionSchema,
+  throttledActionSchema,
+  rawAlertInstanceSchema,
+  metaSchema,
+  alertStateSchema,
+  lastScheduledActionsSchema,
+} from './schema';
+
+export const versionDefinition = {
+  up: upMigration,
+  schema: versionSchema,
+};