feat: validate that monitors are configured for single retry only

Author: sorccu

packages/cli/src/constructs/monitor.ts

@@ -7,10 +7,16 @@ import { CheckGroupV2 } from './check-group-v2'
 import { Frequency } from './frequency'
 import { IncidentTrigger } from './incident'
 import { PrivateLocation, PrivateLocationRef } from './private-location'
-import { RetryStrategy } from './retry-strategy'
+import { RetryStrategyType, SingleRetryStrategy } from './retry-strategy'
 import { Check, CheckProps } from './check'
 import { Diagnostics } from './diagnostics'
 import { validateRemovedDoubleCheck } from './internal/common-diagnostics'
+import { InvalidPropertyValueDiagnostic } from './construct-diagnostics'
+
+/**
+ * Retry strategies supported by monitors.
+ */
+export type MonitorRetryStrategy = SingleRetryStrategy
 
 export interface MonitorProps extends Omit<CheckProps, 'doubleCheck'> {
   /**
@@ -74,8 +80,19 @@ export interface MonitorProps extends Omit<CheckProps, 'doubleCheck'> {
   /**
    * Sets a retry policy for the monitor. Use RetryStrategyBuilder to create a
    * suitable retry strategy.
+   *
+   * Note that monitors only support a single retry.
+   *
+   * @example
+   * ```typescript
+   * // Single retry
+   * RetryStrategyBuilder.singleRetry()
+   *
+   * // No retries
+   * RetryStrategyBuilder.noRetries()
+   * ```
    */
-  retryStrategy?: RetryStrategy
+  retryStrategy?: MonitorRetryStrategy
   /**
    * Determines whether the monitor should create and resolve an incident
    * based on its alert configuration.
@@ -95,6 +112,29 @@ export abstract class Monitor extends Check {
     await validateRemovedDoubleCheck(diagnostics, this)
   }
 
+  async validate (diagnostics: Diagnostics): Promise<void> {
+    await super.validate(diagnostics)
+
+    if (this.retryStrategy) {
+      const supported: RetryStrategyType[] = ['SINGLE', 'NO_RETRIES']
+      if (!supported.includes(this.retryStrategy.type)) {
+        diagnostics.add(new InvalidPropertyValueDiagnostic(
+          'retryStrategy',
+          new Error(
+            `Monitors only support a single retry. The following options `
+            + `are available:`
+            + `\n\n`
+            + `  // Single retry\n`
+            + `  RetryStrategyBuilder.singleRetry()`
+            + `\n\n`
+            + `  // No retries\n`
+            + `  RetryStrategyBuilder.noRetries()`,
+          ),
+        ))
+      }
+    }
+  }
+
   synthesize () {
     return {
       ...super.synthesize(),

packages/cli/src/constructs/retry-strategy.ts

@@ -1,5 +1,5 @@
 /** Available retry strategy types */
-export type RetryStrategyType = 'LINEAR' | 'EXPONENTIAL' | 'FIXED' | 'NO_RETRIES'
+export type RetryStrategyType = 'LINEAR' | 'EXPONENTIAL' | 'FIXED' | 'SINGLE' | 'NO_RETRIES'
 
 /**
  * Conditions can be used to limit when a retry strategy applies.
@@ -20,6 +20,7 @@ export interface RetryStrategy {
    * - FIXED: Same delay for all retries
    * - LINEAR: Base value that increases linearly (baseBackoffSeconds * attempt)
    * - EXPONENTIAL: Base value that increases exponentially (baseBackoffSeconds ^ attempt)
+   * - SINGLE: The delay for the first and only retry
    *
    * @defaultValue 60
    * @example
@@ -32,6 +33,9 @@ export interface RetryStrategy {
    *
    * // Exponential: 5s, 25s, 125s
    * baseBackoffSeconds: 5
+   *
+   * // Single: 10s
+   * baseBackoffSeconds: 10
    * ```
    */
   baseBackoffSeconds?: number
@@ -78,6 +82,18 @@ export interface RetryStrategy {
  */
 export type RetryStrategyOptions = Omit<RetryStrategy, 'type'>
 
+/**
+ * Configuration for single retry behavior.
+ */
+export interface SingleRetryStrategy extends Pick<RetryStrategy, 'baseBackoffSeconds' | 'sameRegion'> {
+  type: 'SINGLE'
+}
+
+/**
+ * Options for configuring single retry strategy behavior.
+ */
+export type SingleRetryStrategyOptions = Pick<RetryStrategyOptions, 'baseBackoffSeconds' | 'sameRegion'>
+
 /**
  * Builder class for creating retry strategies.
  * Provides convenient methods to create different types of retry strategies.
@@ -152,6 +168,16 @@ export class RetryStrategyBuilder {
     return RetryStrategyBuilder.retryStrategy('EXPONENTIAL', options)
   }
 
+  /**
+   * A single retry will be performed.
+   */
+  static singleRetry (options?: SingleRetryStrategyOptions): RetryStrategy {
+    return RetryStrategyBuilder.retryStrategy('SINGLE', {
+      baseBackoffSeconds: options?.baseBackoffSeconds,
+      sameRegion: options?.sameRegion,
+    })
+  }
+
   /**
    * No retries are performed.
    */