aws-stepfunctions-tasks: Unable to use `LambdaInvoke` task as `ItemProcessor` when using JSONata

[sascha]

Describe the bug

When a Map.jsonata() state uses itemProcessor() with a tasks.LambdaInvoke inside it, the CDK (tested with v2.134.0) synthesises invalid ASL.
At the map level it emits

"ProcessorConfig": { "Mode": "ITEM_PROCESSOR", "QueryLanguage": "JSONata" }

but the generated LambdaInvoke child state still contains a Parameters block.
The Step Functions schema forbids mixing those two worlds: the JSONPath‑style fields (InputPath, Parameters, ResultSelector, …) are not allowed in a state (or workflow) whose QueryLanguage is JSONata .
As a result the service rejects the template with

SCHEMA_VALIDATION_FAILED: The QueryLanguage is set to 'JSONata', 
but field 'Parameters' is only supported for the 'JSONPath' QueryLanguage …

Regression Issue

• Select this option if this issue appears to be a regression.

Last Known Working CDK Version

No response

Expected Behavior

CDK should produce ASL that passes Step Functions validation.

Either

• remove the Parameters field and emit Arguments/Output (JSONata‑style), or
• fall back to QueryLanguage: JSONPath for the LambdaInvoke state (which is afaik not possible if queryLanguage has been set on the whole step function).

Deployment should succeed and the state machine should execute.

Current Behavior

cdk deploy (or CloudFormation update) fails with UPDATE_FAILED on the AWS::StepFunctions::StateMachine resource. The error is exactly the one quoted above, and the stack rolls back.

Reproduction Steps

The snippet below can be copied into a fresh CDK v2 TypeScript app and deployed; nothing except aws-cdk-lib and constructs is required.

// file: lib/bug-stack.ts
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';

export class BugStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // dummy Lambda – returns its input
    const fn = new lambda.Function(this, 'Fn', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromInline('exports.handler = e => e;'),
    });

    // 1) MAP in ITEM_PROCESSOR mode + JSONata
    const map = sfn.Map.jsonata(this, 'Map', {
      items: sfn.ProvideItems.jsonata('{% [ { "foo": "bar" } ] %}'),
    });

    // 2) little Pass to prove Pass works fine
    const pass = new sfn.Pass.jsonata(this, 'Pass', {
      outputs: '{% $states.input %}',
    });

    // 3) LambdaInvoke – this is the problematic state
    const invoke = new tasks.LambdaInvoke(this, 'Invoke', {
      lambdaFunction: fn,
      payload: sfn.TaskInput.fromObject({
        foo: '{% $states.input.foo %}',
      }),
    });

    // assemble the iterator
    map.itemProcessor(pass.next(invoke));

    // top‑level state‑machine, JSONata turned on
    new sfn.StateMachine(this, 'StateMachine', {
      definitionBody: sfn.DefinitionBody.fromChainable(map),
      queryLanguage: sfn.QueryLanguage.JSONATA,
    });
  }
}

How to run

# 1. create a new project
npx cdk@2 init app --language typescript
npm i aws-cdk-lib constructs

# 2. replace lib/<app>-stack.ts with the file above
npm run build
cdk deploy        # fails with SCHEMA_VALIDATION_FAILED

What you should see

Invalid State Machine Definition: 
SCHEMA_VALIDATION_FAILED: The QueryLanguage is set to 'JSONata', 
but field 'Parameters' is only supported for the 'JSONPath' QueryLanguage
at /States/Map/ItemProcessor/States/Invoke/Resource

---

Removing the LambdaInvoke or removing queryLanguage from the StateMachine and setting it per state (and using Map.jsonPath) makes the deployment succeed, which confirms the issue is confined to LambdaInvoke inside an itemProcessor in JSONata mode.

Possible Solution

No response

Additional Information/Context

No response

CDK CLI Version

2.1013.0

Framework Version

No response

Node.js Version

v22.14.0

OS

macOS 15.4.1

Language

TypeScript

Language Version

TypeScript 5.6.3

Other information

No response

[ykethan]

Hello @sascha,

Thank you for reporting this issue and providing us the detailed reproduction code. I was able to reproduce the issue and confirmed it's a bug in how query language settings are propagated within nested state machines when using JSONata.

Issue Analysis

The problem occurs in the interaction between:

1. Map.jsonata() which correctly sets QueryLanguage: JSONata in the ProcessorConfig
2. LambdaInvoke constructor which generates JSONPath-style Parameters field

The root cause is in how query language context propagation works in the CDK. Specifically:

In packages/aws-cdk-lib/aws-stepfunctions/lib/states/state.ts:

protected renderItemProcessor(): any {
  if (!this.processor) return undefined;
  return {
    ItemProcessor: {
      ...this.renderProcessorConfig(),
      ...this.processor.toGraphJson(), // Doesn't pass query language to nested processor
    },
  };
}

And in packages/aws-cdk-lib/aws-stepfunctions-tasks/lib/lambda/invoke.ts:

protected _renderTask(topLevelQueryLanguage?: sfn.QueryLanguage): any {
  const queryLanguage = sfn._getActualQueryLanguage(topLevelQueryLanguage, this.props.queryLanguage);
  // ... uses queryLanguage for rendering Parameters vs Arguments
}

The issue is that when Map.itemProcessor() is called with a LambdaInvoke task, the query language setting is not correctly propagated to the nested processor, resulting in the Parameters field being generated instead of Arguments.

Reproduction Steps

As you've detailed in your issue report, this can be reproduced with:

// 1. Create Map with JSONata
const map = sfn.Map.jsonata(this, 'Map', {
  items: sfn.ProvideItems.jsonata('{% [ { "foo": "bar" } ] %}'),
});

// 2. Create Pass state
const pass = sfn.Pass.jsonata(this, 'Pass', {
  outputs: '{% $states.input %}',
});

// 3. Create Lambda Invoke task - this generates incompatible Parameters
const invoke = new tasks.LambdaInvoke(this, 'Invoke', {
  lambdaFunction: fn,
  payload: sfn.TaskInput.fromObject({
    foo: '{% $states.input.foo %}',
  }),
});

// 4. Assemble the item processor chain
map.itemProcessor(pass.next(invoke));

// 5. Create state machine with JSONata
new sfn.StateMachine(this, 'StateMachine', {
  definitionBody: sfn.DefinitionBody.fromChainable(map),
  queryLanguage: sfn.QueryLanguage.JSONATA,
});

The deployment fails with:

SCHEMA_VALIDATION_FAILED: The QueryLanguage is set to 'JSONata',
but field 'Parameters' is only supported for the 'JSONPath' QueryLanguage

Workaround

Until this is fixed in the CDK, you can work around this issue by using the LambdaInvoke.jsonata() static method instead of the constructor:

// Use this instead of the constructor
const invoke = tasks.LambdaInvoke.jsonata(this, 'Invoke', {
  lambdaFunction: fn,
  payload: sfn.TaskInput.fromObject({
    foo: '{% $states.input.foo %}',
  }),
});

This ensures that the task is configured to use JSONata-compatible fields (Arguments instead of Parameters). I've verified this workaround successfully deploys without the validation error.

We encourage you or any community member to contribute by submitting a pull request. If you’re interested in contributing, please review the CDK Contributing Guide
Let us know if you have any questions!