@pgflow/dsl 0.0.0-array-map-steps-cd94242a-20251008042921 → 0.0.0-condition-4354fcb6-20260108134756

package/README.md

@@ -31,30 +31,30 @@ type Input = {
 
 // Define a flow with steps and dependencies
 export const AnalyzeWebsite = new Flow<Input>({
-  slug: 'analyze_website',
+  slug: 'analyzeWebsite',
   maxAttempts: 3,
   baseDelay: 5,
   timeout: 10,
 })
   .step(
     { slug: 'website' },
-    async (input) => await scrapeWebsite(input.run.url)
+    async (flowInput) => await scrapeWebsite(flowInput.url)
   )
   .step(
     { slug: 'sentiment', dependsOn: ['website'] },
-    async (input) => await analyzeSentiment(input.website.content)
+    async (deps) => await analyzeSentiment(deps.website.content)
   )
   .step(
     { slug: 'summary', dependsOn: ['website'] },
-    async (input) => await summarizeWithAI(input.website.content)
+    async (deps) => await summarizeWithAI(deps.website.content)
   )
   .step(
     { slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] },
-    async (input) => {
+    async (deps, ctx) => {
       return await saveToDb({
-        websiteUrl: input.run.url,
-        sentiment: input.sentiment.score,
-        summary: input.summary.aiSummary,
+        websiteUrl: ctx.flowInput.url,
+        sentiment: deps.sentiment.score,
+        summary: deps.summary.aiSummary,
       });
     }
   );
@@ -62,16 +62,22 @@ export const AnalyzeWebsite = new Flow<Input>({
 
 ### Understanding Data Flow
 
-In pgflow, each step receives an `input` object that contains:
+In pgflow, step handlers use **asymmetric signatures** based on whether they have dependencies:
 
-1. **`input.run`** - The original flow input (available to all steps)
-2. **`input.{stepName}`** - Outputs from dependency steps
+**Root steps (no dependencies):**
+- First parameter: `flowInput` - the original flow input directly
+- Second parameter: `ctx` - context object (env, supabase, flowInput, etc.)
+
+**Dependent steps (with dependsOn):**
+- First parameter: `deps` - object with outputs from dependency steps (`deps.{stepName}`)
+- Second parameter: `ctx` - context object (includes `ctx.flowInput` if needed)
 
 This design ensures:
 
-- Original flow parameters are accessible throughout the entire flow
-- Data doesn't need to be manually forwarded through intermediate steps
-- Steps can combine original input with processed data from previous steps
+- Root steps receive flow input directly for clean, simple handlers
+- Dependent steps focus on their dependencies without wrapping
+- Original flow input is always accessible via `ctx.flowInput` when needed
+- Steps can combine dependency outputs with original input via context
 
 ### Step Methods
 
@@ -84,8 +90,9 @@ The standard method for adding steps to a flow. Each step processes input and re
 ```typescript
 .step(
   { slug: 'process', dependsOn: ['previous'] },
-  async (input) => {
-    // Access input.run and input.previous
+  async (deps, ctx) => {
+    // Access deps.previous for dependency output
+    // Access ctx.flowInput if original flow input is needed
     return { result: 'processed' };
   }
 )
@@ -98,14 +105,14 @@ A semantic wrapper around `.step()` that provides type enforcement for steps tha
 ```typescript
 // Fetch an array of items to be processed
 .array(
-  { slug: 'fetch_items' },
+  { slug: 'fetchItems' },
   async () => [1, 2, 3, 4, 5]
 )
 
 // With dependencies - combining data from multiple sources
 .array(
-  { slug: 'combine_results', dependsOn: ['source1', 'source2'] },
-  async (input) => [...input.source1, ...input.source2]
+  { slug: 'combineResults', dependsOn: ['source1', 'source2'] },
+  async (deps) => [...deps.source1, ...deps.source2]
 )
 ```
 
@@ -131,7 +138,7 @@ Processes arrays element-by-element, similar to JavaScript's `Array.map()`. The
 ```typescript
 // ROOT MAP - No array: property means use flow input
 // Flow input MUST be an array (e.g., ["hello", "world"])
-new Flow<string[]>({ slug: 'process_strings' })
+new Flow<string[]>({ slug: 'processStrings' })
   .map(
     { slug: 'uppercase' }, // No array: property!
     (item) => item.toUpperCase()
@@ -139,7 +146,7 @@ new Flow<string[]>({ slug: 'process_strings' })
 // Each string in the input array gets uppercased in parallel
 
 // DEPENDENT MAP - array: property specifies the source step
-new Flow<{}>({ slug: 'data_pipeline' })
+new Flow<{}>({ slug: 'dataPipeline' })
   .array({ slug: 'numbers' }, () => [1, 2, 3])
   .map(
     { slug: 'double', array: 'numbers' }, // Processes 'numbers' output
@@ -166,7 +173,7 @@ The `.map()` method provides full TypeScript type inference for array elements:
 ```typescript
 type User = { id: number; name: string };
 
-new Flow<{}>({ slug: 'user_flow' })
+new Flow<{}>({ slug: 'userFlow' })
   .array({ slug: 'users' }, (): User[] => [
     { id: 1, name: 'Alice' },
     { id: 2, name: 'Bob' }
@@ -181,7 +188,7 @@ new Flow<{}>({ slug: 'user_flow' })
 
 ```typescript
 // Batch processing - process multiple items in parallel
-new Flow<number[]>({ slug: 'batch_processor' })
+new Flow<number[]>({ slug: 'batchProcessor' })
   .map({ slug: 'validate' }, (item) => {
     if (item < 0) throw new Error('Invalid item');
     return item;
@@ -192,17 +199,17 @@ new Flow<number[]>({ slug: 'batch_processor' })
   });
 
 // Data transformation pipeline
-new Flow<{}>({ slug: 'etl_pipeline' })
-  .step({ slug: 'fetch_urls' }, () => ['url1', 'url2', 'url3'])
-  .map({ slug: 'scrape', array: 'fetch_urls' }, async (url) => {
+new Flow<{}>({ slug: 'etlPipeline' })
+  .step({ slug: 'fetchUrls' }, () => ['url1', 'url2', 'url3'])
+  .map({ slug: 'scrape', array: 'fetchUrls' }, async (url) => {
     return await fetchContent(url);
   })
   .map({ slug: 'extract', array: 'scrape' }, (html) => {
     return extractData(html);
   })
-  .step({ slug: 'aggregate', dependsOn: ['extract'] }, (input) => {
-    // input.extract is the aggregated array from all map tasks
-    return consolidateResults(input.extract);
+  .step({ slug: 'aggregate', dependsOn: ['extract'] }, (deps) => {
+    // deps.extract is the aggregated array from all map tasks
+    return consolidateResults(deps.extract);
   });
 ```
 
@@ -218,9 +225,9 @@ Step handlers can optionally receive a second parameter - the **context object**
 ```typescript
 .step(
   { slug: 'saveToDb' },
-  async (input, context) => {
+  async (flowInput, ctx) => {
     // Access platform resources through context
-    const result = await context.sql`SELECT * FROM users WHERE id = ${input.userId}`;
+    const result = await ctx.sql`SELECT * FROM users WHERE id = ${flowInput.userId}`;
     return result[0];
   }
 )
@@ -230,40 +237,40 @@ Step handlers can optionally receive a second parameter - the **context object**
 
 All platforms provide these core resources:
 
-- **`context.env`** - Environment variables (`Record<string, string | undefined>`)
-- **`context.shutdownSignal`** - AbortSignal for graceful shutdown handling
-- **`context.rawMessage`** - Original pgmq message with metadata
+- **`ctx.env`** - Environment variables (`Record<string, string | undefined>`)
+- **`ctx.flowInput`** - Original flow input (typed as the flow's input type)
+- **`ctx.shutdownSignal`** - AbortSignal for graceful shutdown handling
+- **`ctx.rawMessage`** - Original pgmq message with metadata
   ```typescript
   interface PgmqMessageRecord<T> {
     msg_id: number;
     read_ct: number;
     enqueued_at: Date;
     vt: Date;
-    message: T; // <-- this is your 'input'
+    message: T;
   }
   ```
-- **`context.stepTask`** - Current step task details (flow handlers only)
+- **`ctx.stepTask`** - Current step task details (flow handlers only)
   ```typescript
   interface StepTaskRecord<TFlow> {
     flow_slug: string;
     run_id: string;
     step_slug: string;
-    input: StepInput<TFlow, StepSlug>; // <-- this is handler 'input'
     msg_id: number;
   }
   ```
-- **`context.workerConfig`** - Resolved worker configuration with all defaults applied
+- **`ctx.workerConfig`** - Resolved worker configuration with all defaults applied
   ```typescript
   // Provides access to worker settings like retry limits
-  const isLastAttempt = context.rawMessage.read_ct >= context.workerConfig.retry.limit;
+  const isLastAttempt = ctx.rawMessage.read_ct >= ctx.workerConfig.retry.limit;
   ```
 
 #### Supabase Platform Resources
 
 When using the Supabase platform with EdgeWorker, additional resources are available:
 
-- **`context.sql`** - PostgreSQL client (postgres.js)
-- **`context.supabase`** - Supabase client with service role key for full database access
+- **`ctx.sql`** - PostgreSQL client (postgres.js)
+- **`ctx.supabase`** - Supabase client with service role key for full database access
 
 To use Supabase resources, import the `Flow` class from the Supabase preset:
 
@@ -271,18 +278,18 @@ To use Supabase resources, import the `Flow` class from the Supabase preset:
 import { Flow } from '@pgflow/dsl/supabase';
 
 const MyFlow = new Flow<{ userId: string }>({
-  slug: 'my_flow',
-}).step({ slug: 'process' }, async (input, context) => {
-  // TypeScript knows context includes Supabase resources
-  const { data } = await context.supabase
+  slug: 'myFlow',
+}).step({ slug: 'process' }, async (flowInput, ctx) => {
+  // TypeScript knows ctx includes Supabase resources
+  const { data } = await ctx.supabase
     .from('users')
     .select('*')
-    .eq('id', input.userId);
+    .eq('id', flowInput.userId);
 
   // Use SQL directly
-  const stats = await context.sql`
-      SELECT COUNT(*) as total FROM events 
-      WHERE user_id = ${input.userId}
+  const stats = await ctx.sql`
+      SELECT COUNT(*) as total FROM events
+      WHERE user_id = ${flowInput.userId}
     `;
 
   return { user: data[0], eventCount: stats[0].total };
@@ -300,7 +307,7 @@ Configure flows and steps with runtime options:
 
 ```typescript
 new Flow<Input>({
-  slug: 'my_flow', // Required: Unique flow identifier
+  slug: 'myFlow', // Required: Unique flow identifier
   maxAttempts: 3, // Optional: Maximum retry attempts (default: 1)
   baseDelay: 5, // Optional: Base delay in seconds for retries (default: 1)
   timeout: 10, // Optional: Task timeout in seconds (default: 30)

package/dist/CHANGELOG.md

@@ -1,6 +1,60 @@
 # @pgflow/dsl
 
-## 0.0.0-array-map-steps-cd94242a-20251008042921
+## 0.0.0-condition-4354fcb6-20260108134756
+
+### Patch Changes
+
+- c25ab9f: Add whenFailed option for error handling after retries exhausted (fail, skip, skip-cascade)
+
+## 0.13.1
+
+## 0.13.0
+
+## 0.12.0
+
+### Minor Changes
+
+- 37402eb: BREAKING: Asymmetric handler signatures - remove `run` key from step inputs
+
+  - Root steps: `(flowInput, ctx) => ...` - flow input directly as first param
+  - Dependent steps: `(deps, ctx) => ...` - only dependency outputs as first param
+  - Access flow input in dependent steps via `await ctx.flowInput` (async/lazy-loaded)
+  - Lazy loading prevents data duplication for map steps processing large arrays
+  - Enables functional composition and simplifies types for future subflows
+
+### Patch Changes
+
+- 5dc5cfc: Fix Supabase Edge Runtime compatibility by replacing npm:postgres with jsr:@oscar6echo/postgres fork. The npm package fails to parse database URLs in Deno edge environments, causing CONNECT_TIMEOUT errors.
+
+## 0.11.0
+
+## 0.10.0
+
+### Patch Changes
+
+- 0b84bb0: Add automatic flow compilation at worker startup. Workers now call ensure_flow_compiled to verify flows are up-to-date. In development, mismatched flows are recompiled automatically. In production, mismatches cause errors. Use ensureCompiledOnStartup: false to opt-out.
+
+## 0.9.1
+
+### Patch Changes
+
+- 992a86b: Unify connection configuration with improved local detection. The `connectionString` config option now works correctly, and you can pass a raw postgres.js `sql` instance via `config.sql` for full control over connection options (SSL, pooling, etc.).
+
+  Fixes [#469](https://github.com/pgflow-dev/pgflow/issues/469), [#424](https://github.com/pgflow-dev/pgflow/issues/424). Thanks to [@Nciso](https://github.com/Nciso), [@mikz](https://github.com/mikz), [@ddlaws0n](https://github.com/ddlaws0n), and **PixelEcho** for feedback and bug reports.
+
+## 0.9.0
+
+## 0.8.1
+
+## 0.8.0
+
+## 0.7.3
+
+## 0.7.2
+
+## 0.7.1
+
+## 0.7.0
 
 ### Minor Changes
 

package/dist/README.md

@@ -31,30 +31,30 @@ type Input = {
 
 // Define a flow with steps and dependencies
 export const AnalyzeWebsite = new Flow<Input>({
-  slug: 'analyze_website',
+  slug: 'analyzeWebsite',
   maxAttempts: 3,
   baseDelay: 5,
   timeout: 10,
 })
   .step(
     { slug: 'website' },
-    async (input) => await scrapeWebsite(input.run.url)
+    async (flowInput) => await scrapeWebsite(flowInput.url)
   )
   .step(
     { slug: 'sentiment', dependsOn: ['website'] },
-    async (input) => await analyzeSentiment(input.website.content)
+    async (deps) => await analyzeSentiment(deps.website.content)
   )
   .step(
     { slug: 'summary', dependsOn: ['website'] },
-    async (input) => await summarizeWithAI(input.website.content)
+    async (deps) => await summarizeWithAI(deps.website.content)
   )
   .step(
     { slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] },
-    async (input) => {
+    async (deps, ctx) => {
       return await saveToDb({
-        websiteUrl: input.run.url,
-        sentiment: input.sentiment.score,
-        summary: input.summary.aiSummary,
+        websiteUrl: ctx.flowInput.url,
+        sentiment: deps.sentiment.score,
+        summary: deps.summary.aiSummary,
       });
     }
   );
@@ -62,16 +62,22 @@ export const AnalyzeWebsite = new Flow<Input>({
 
 ### Understanding Data Flow
 
-In pgflow, each step receives an `input` object that contains:
+In pgflow, step handlers use **asymmetric signatures** based on whether they have dependencies:
 
-1. **`input.run`** - The original flow input (available to all steps)
-2. **`input.{stepName}`** - Outputs from dependency steps
+**Root steps (no dependencies):**
+- First parameter: `flowInput` - the original flow input directly
+- Second parameter: `ctx` - context object (env, supabase, flowInput, etc.)
+
+**Dependent steps (with dependsOn):**
+- First parameter: `deps` - object with outputs from dependency steps (`deps.{stepName}`)
+- Second parameter: `ctx` - context object (includes `ctx.flowInput` if needed)
 
 This design ensures:
 
-- Original flow parameters are accessible throughout the entire flow
-- Data doesn't need to be manually forwarded through intermediate steps
-- Steps can combine original input with processed data from previous steps
+- Root steps receive flow input directly for clean, simple handlers
+- Dependent steps focus on their dependencies without wrapping
+- Original flow input is always accessible via `ctx.flowInput` when needed
+- Steps can combine dependency outputs with original input via context
 
 ### Step Methods
 
@@ -84,8 +90,9 @@ The standard method for adding steps to a flow. Each step processes input and re
 ```typescript
 .step(
   { slug: 'process', dependsOn: ['previous'] },
-  async (input) => {
-    // Access input.run and input.previous
+  async (deps, ctx) => {
+    // Access deps.previous for dependency output
+    // Access ctx.flowInput if original flow input is needed
     return { result: 'processed' };
   }
 )
@@ -98,14 +105,14 @@ A semantic wrapper around `.step()` that provides type enforcement for steps tha
 ```typescript
 // Fetch an array of items to be processed
 .array(
-  { slug: 'fetch_items' },
+  { slug: 'fetchItems' },
   async () => [1, 2, 3, 4, 5]
 )
 
 // With dependencies - combining data from multiple sources
 .array(
-  { slug: 'combine_results', dependsOn: ['source1', 'source2'] },
-  async (input) => [...input.source1, ...input.source2]
+  { slug: 'combineResults', dependsOn: ['source1', 'source2'] },
+  async (deps) => [...deps.source1, ...deps.source2]
 )
 ```
 
@@ -131,7 +138,7 @@ Processes arrays element-by-element, similar to JavaScript's `Array.map()`. The
 ```typescript
 // ROOT MAP - No array: property means use flow input
 // Flow input MUST be an array (e.g., ["hello", "world"])
-new Flow<string[]>({ slug: 'process_strings' })
+new Flow<string[]>({ slug: 'processStrings' })
   .map(
     { slug: 'uppercase' }, // No array: property!
     (item) => item.toUpperCase()
@@ -139,7 +146,7 @@ new Flow<string[]>({ slug: 'process_strings' })
 // Each string in the input array gets uppercased in parallel
 
 // DEPENDENT MAP - array: property specifies the source step
-new Flow<{}>({ slug: 'data_pipeline' })
+new Flow<{}>({ slug: 'dataPipeline' })
   .array({ slug: 'numbers' }, () => [1, 2, 3])
   .map(
     { slug: 'double', array: 'numbers' }, // Processes 'numbers' output
@@ -166,7 +173,7 @@ The `.map()` method provides full TypeScript type inference for array elements:
 ```typescript
 type User = { id: number; name: string };
 
-new Flow<{}>({ slug: 'user_flow' })
+new Flow<{}>({ slug: 'userFlow' })
   .array({ slug: 'users' }, (): User[] => [
     { id: 1, name: 'Alice' },
     { id: 2, name: 'Bob' }
@@ -181,7 +188,7 @@ new Flow<{}>({ slug: 'user_flow' })
 
 ```typescript
 // Batch processing - process multiple items in parallel
-new Flow<number[]>({ slug: 'batch_processor' })
+new Flow<number[]>({ slug: 'batchProcessor' })
   .map({ slug: 'validate' }, (item) => {
     if (item < 0) throw new Error('Invalid item');
     return item;
@@ -192,17 +199,17 @@ new Flow<number[]>({ slug: 'batch_processor' })
   });
 
 // Data transformation pipeline
-new Flow<{}>({ slug: 'etl_pipeline' })
-  .step({ slug: 'fetch_urls' }, () => ['url1', 'url2', 'url3'])
-  .map({ slug: 'scrape', array: 'fetch_urls' }, async (url) => {
+new Flow<{}>({ slug: 'etlPipeline' })
+  .step({ slug: 'fetchUrls' }, () => ['url1', 'url2', 'url3'])
+  .map({ slug: 'scrape', array: 'fetchUrls' }, async (url) => {
     return await fetchContent(url);
   })
   .map({ slug: 'extract', array: 'scrape' }, (html) => {
     return extractData(html);
   })
-  .step({ slug: 'aggregate', dependsOn: ['extract'] }, (input) => {
-    // input.extract is the aggregated array from all map tasks
-    return consolidateResults(input.extract);
+  .step({ slug: 'aggregate', dependsOn: ['extract'] }, (deps) => {
+    // deps.extract is the aggregated array from all map tasks
+    return consolidateResults(deps.extract);
   });
 ```
 
@@ -218,9 +225,9 @@ Step handlers can optionally receive a second parameter - the **context object**
 ```typescript
 .step(
   { slug: 'saveToDb' },
-  async (input, context) => {
+  async (flowInput, ctx) => {
     // Access platform resources through context
-    const result = await context.sql`SELECT * FROM users WHERE id = ${input.userId}`;
+    const result = await ctx.sql`SELECT * FROM users WHERE id = ${flowInput.userId}`;
     return result[0];
   }
 )
@@ -230,40 +237,40 @@ Step handlers can optionally receive a second parameter - the **context object**
 
 All platforms provide these core resources:
 
-- **`context.env`** - Environment variables (`Record<string, string | undefined>`)
-- **`context.shutdownSignal`** - AbortSignal for graceful shutdown handling
-- **`context.rawMessage`** - Original pgmq message with metadata
+- **`ctx.env`** - Environment variables (`Record<string, string | undefined>`)
+- **`ctx.flowInput`** - Original flow input (typed as the flow's input type)
+- **`ctx.shutdownSignal`** - AbortSignal for graceful shutdown handling
+- **`ctx.rawMessage`** - Original pgmq message with metadata
   ```typescript
   interface PgmqMessageRecord<T> {
     msg_id: number;
     read_ct: number;
     enqueued_at: Date;
     vt: Date;
-    message: T; // <-- this is your 'input'
+    message: T;
   }
   ```
-- **`context.stepTask`** - Current step task details (flow handlers only)
+- **`ctx.stepTask`** - Current step task details (flow handlers only)
   ```typescript
   interface StepTaskRecord<TFlow> {
     flow_slug: string;
     run_id: string;
     step_slug: string;
-    input: StepInput<TFlow, StepSlug>; // <-- this is handler 'input'
     msg_id: number;
   }
   ```
-- **`context.workerConfig`** - Resolved worker configuration with all defaults applied
+- **`ctx.workerConfig`** - Resolved worker configuration with all defaults applied
   ```typescript
   // Provides access to worker settings like retry limits
-  const isLastAttempt = context.rawMessage.read_ct >= context.workerConfig.retry.limit;
+  const isLastAttempt = ctx.rawMessage.read_ct >= ctx.workerConfig.retry.limit;
   ```
 
 #### Supabase Platform Resources
 
 When using the Supabase platform with EdgeWorker, additional resources are available:
 
-- **`context.sql`** - PostgreSQL client (postgres.js)
-- **`context.supabase`** - Supabase client with service role key for full database access
+- **`ctx.sql`** - PostgreSQL client (postgres.js)
+- **`ctx.supabase`** - Supabase client with service role key for full database access
 
 To use Supabase resources, import the `Flow` class from the Supabase preset:
 
@@ -271,18 +278,18 @@ To use Supabase resources, import the `Flow` class from the Supabase preset:
 import { Flow } from '@pgflow/dsl/supabase';
 
 const MyFlow = new Flow<{ userId: string }>({
-  slug: 'my_flow',
-}).step({ slug: 'process' }, async (input, context) => {
-  // TypeScript knows context includes Supabase resources
-  const { data } = await context.supabase
+  slug: 'myFlow',
+}).step({ slug: 'process' }, async (flowInput, ctx) => {
+  // TypeScript knows ctx includes Supabase resources
+  const { data } = await ctx.supabase
     .from('users')
     .select('*')
-    .eq('id', input.userId);
+    .eq('id', flowInput.userId);
 
   // Use SQL directly
-  const stats = await context.sql`
-      SELECT COUNT(*) as total FROM events 
-      WHERE user_id = ${input.userId}
+  const stats = await ctx.sql`
+      SELECT COUNT(*) as total FROM events
+      WHERE user_id = ${flowInput.userId}
     `;
 
   return { user: data[0], eventCount: stats[0].total };
@@ -300,7 +307,7 @@ Configure flows and steps with runtime options:
 
 ```typescript
 new Flow<Input>({
-  slug: 'my_flow', // Required: Unique flow identifier
+  slug: 'myFlow', // Required: Unique flow identifier
   maxAttempts: 3, // Optional: Maximum retry attempts (default: 1)
   baseDelay: 5, // Optional: Base delay in seconds for retries (default: 1)
   timeout: 10, // Optional: Task timeout in seconds (default: 30)

package/dist/compile-flow.js

@@ -46,5 +46,21 @@ function formatRuntimeOptions(options) {
     if ('startDelay' in options && options.startDelay !== undefined) {
         parts.push(`start_delay => ${options.startDelay}`);
     }
+    if ('if' in options && options.if !== undefined) {
+        // Serialize JSON pattern and escape for SQL
+        const jsonStr = JSON.stringify(options.if);
+        parts.push(`condition_pattern => '${jsonStr}'`);
+    }
+    if ('ifNot' in options && options.ifNot !== undefined) {
+        // Serialize JSON pattern and escape for SQL
+        const jsonStr = JSON.stringify(options.ifNot);
+        parts.push(`condition_not_pattern => '${jsonStr}'`);
+    }
+    if ('whenUnmet' in options && options.whenUnmet !== undefined) {
+        parts.push(`when_unmet => '${options.whenUnmet}'`);
+    }
+    if ('retriesExhausted' in options && options.retriesExhausted !== undefined) {
+        parts.push(`when_failed => '${options.retriesExhausted}'`);
+    }
     return parts.length > 0 ? `, ${parts.join(', ')}` : '';
 }