A platform for community discussion. Free, open, simple.
FEATURE: Let workflow nodes fail individual items when continuing on error
Régis Hanole808c12da5ae
diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/executions/detail.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/executions/detail.gjsindex 5581d7d599d..bf4197b6ea5 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/executions/detail.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/executions/detail.gjs@@ -201,6 +201,15 @@ function stepWarnings(step) {);}+ step.metadata?.item_errors?.forEach(({ message, items }) => {+ warnings.push(+ i18n("discourse_workflows.executions.item_error", {+ count: items.length,+ message,+ })+ );+ });+return warnings;}diff --git a/plugins/discourse-workflows/config/locales/client.en.yml b/plugins/discourse-workflows/config/locales/client.en.ymlindex eca3ceaf35f..33e06837987 100644--- a/plugins/discourse-workflows/config/locales/client.en.yml+++ b/plugins/discourse-workflows/config/locales/client.en.yml@@ -1412,6 +1412,9 @@ en:no_output_data: "This node produced no output data, so the execution stopped and no items were passed to connected nodes. To continue the execution with an empty item, turn on Always output data in this node's Settings tab."items: "items"handled_error: "The node failed but the workflow continued because of its error settings: %{message}"+ item_error:+ one: "An item failed but the workflow continued because of its error settings: %{message}"+ other: "%{count} items failed but the workflow continued because of its error settings: %{message}"logs: "Console"workflow_call: "Workflow call"workflow_call_called_by: "Called by"diff --git a/plugins/discourse-workflows/lib/discourse_workflows/executor.rb b/plugins/discourse-workflows/lib/discourse_workflows/executor.rbindex acd60c2d45e..9c8e4d0376d 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/executor.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/executor.rb@@ -161,7 +161,7 @@ module DiscourseWorkflowsif (handled_outputs = continued_error_outputs(waiting_node, input_groups, error))handled_outputs = enforce_node_output_budget(handled_outputs, nil)all_items = handled_outputs.flatten(1)- step&.add_metadata("handled_error", error_metadata(error))+ step&.add_metadata("handled_error", Item.error_metadata(error))step&.succeed!(output: all_items)step&.apply_updates!("error" => nil)@store.publish_progress(step:) if step@@ -380,6 +380,7 @@ module DiscourseWorkflowsports = node_type_class.ports(node.parameters)output_arrays = normalize_result(result, node, ports, input_groups)output_arrays = apply_always_output_data(output_arrays, node, input_groups)+ output_arrays = route_failed_items(output_arrays, node, ports)output_arrays = enforce_node_output_budget(output_arrays, step_log)attach_step_log(step, step_log)all_items = output_arrays.flatten(1)@@ -410,7 +411,7 @@ module DiscourseWorkflowsstep_log = collect_step_log(exec_ctx, resolver)handled_outputs = enforce_node_output_budget(handled_outputs, step_log)attach_step_log(step, step_log)- step.add_metadata("handled_error", error_metadata(e))+ step.add_metadata("handled_error", Item.error_metadata(e))all_items = handled_outputs.flatten(1)step.succeed!(output: all_items)step.apply_updates!("error" => nil)@@ -706,9 +707,28 @@ module DiscourseWorkflowsendend+ def route_failed_items(output_arrays, node, ports)+ if output_arrays.none? { |items| items.any? { |item| failed_item?(item) } }+ return output_arrays+ end++ if ports.one? && node_error_mode(node) == "continueErrorOutput"+ failed, succeeded = output_arrays[0].partition { |item| failed_item?(item) }+ return succeeded, failed.map { |item| item.except(Item::FAILED_KEY) }+ end++ output_arrays.map do |items|+ items.map { |item| failed_item?(item) ? item.except(Item::FAILED_KEY) : item }+ end+ end++ def failed_item?(item)+ item.key?(Item::FAILED_KEY)+ end+def node_error_mode(node)on_error = DiscourseWorkflows::NodeData.read(node, "onError").presence- return on_error if %w[continueRegularOutput continueErrorOutput].include?(on_error)+ return on_error if NodeDataShape::CONTINUE_ON_ERROR_MODES.include?(on_error)return "stopWorkflow" if on_error == "stopWorkflow"return if on_error.present?@@ -720,18 +740,13 @@ module DiscourseWorkflowsenddef error_output_items(input_items, error)- metadata = error_metadata(error)- return [{ "json" => {}, "error" => metadata }] if input_items.empty?+ return [Item.with_error({ "json" => {} }, error, paired_item: nil)] if input_items.empty?input_items.map.with_index do |item, index|- item.deep_dup.merge("error" => metadata, "pairedItem" => pair_for(input: 0, item: index))+ Item.with_error(item, error, paired_item: pair_for(input: 0, item: index))endend- def error_metadata(error)- { "message" => error.message, "name" => error.class.name }- end-def route_downstream(node, output_arrays)output_arrays.each_with_index { |items, index| enqueue_downstream(node, index, items) }enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/executor/node_execution_context.rb b/plugins/discourse-workflows/lib/discourse_workflows/executor/node_execution_context.rbindex 66a8df64ee1..3bee3ce1a7d 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/executor/node_execution_context.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/executor/node_execution_context.rb@@ -68,6 +68,8 @@ module DiscourseWorkflowsendclass RuntimeState+ MAX_ITEM_ERROR_GROUPS = 20+attr_reader :condition_step_details, :execution_hints, :log, :metadata, :wait_requestdef initialize@@ -92,6 +94,17 @@ module DiscourseWorkflows@execution_hints |= hints.map(&:deep_stringify_keys)end+ def add_item_error(item_index, error)+ groups = (@metadata["item_errors"] ||= [])+ group = groups.find { |entry| entry["message"] == error.summary }++ if group+ group["items"] << item_index+ elsif groups.size < MAX_ITEM_ERROR_GROUPS+ groups << { "message" => error.summary, "items" => [item_index] }+ end+ end+def merge_metadata(metadata)@metadata.merge!(metadata.deep_stringify_keys)end@@ -264,11 +277,36 @@ module DiscourseWorkflowsdef continue_on_failon_error = @node_settings["onError"]- return %w[continueRegularOutput continueErrorOutput].include?(on_error) if on_error.present?+ return NodeDataShape::CONTINUE_ON_ERROR_MODES.include?(on_error) if on_error.present?ActiveModel::Type::Boolean.new.cast(@node_settings["continueOnFail"]) == trueend+ # Fails only this item when the node continues on error, so items already handled+ # aren't reported as failed too.+ def guard_item(item, item_index)+ expression_error_count = expression_errors.size+ yield+ rescue DiscourseWorkflows::NodeError => e+ raise if !continue_on_fail++ demote_expression_errors(from: expression_error_count, item_index:)+ @runtime_state.add_item_error(item_index, e)+ Item.with_error(item, e, paired_item: item_index).merge(Item::FAILED_KEY => true)+ end++ def each_item+ input_items.flat_map.with_index do |item, item_index|+ Array+ .wrap(guard_item(item, item_index) { yield item, item_index })+ .map do |output|+ next output if Item.paired_item(output)++ Item.with_paired_item(output, item_index)+ end+ end+ end+def start_job(job_type, settings, item_index)raise ArgumentError, "Unsupported job type: #{job_type}" unless job_type == "javascript"@@ -286,10 +324,10 @@ module DiscourseWorkflowsenddef ensure_no_expression_errors!- error = @resolver.expression_errors.first+ error = expression_errors.firstreturn unless error- raise NodeError, "#{error[:expression]}: #{error[:error]}"+ raise NodeError, format_expression_error(error)enddef helpers@@ -532,6 +570,22 @@ module DiscourseWorkflowsprivate+ def expression_errors+ @resolver&.expression_errors || []+ end++ # Any expression error fails the whole step, so a failed item's own ones become warnings.+ # Those of an item that succeeds still fail the step.+ def demote_expression_errors(from:, item_index:)+ @resolver+ &.discard_expression_errors(from:)+ &.each { |error| log.warn("#{format_expression_error(error)} [item #{item_index}]") }+ end++ def format_expression_error(error)+ "#{error[:expression]}: #{error[:error]}"+ end+def ensure_actor_allowed!(actor, item_index:)return if actor.is_a?(DiscourseWorkflows::AnonymousActor)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/expression_resolver.rb b/plugins/discourse-workflows/lib/discourse_workflows/expression_resolver.rbindex 3c9c7d32cd2..b81deeeccaf 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/expression_resolver.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/expression_resolver.rb@@ -76,6 +76,10 @@ module DiscourseWorkflows@js_evaluator&.expression_errors || []end+ def discard_expression_errors(from:)+ @js_evaluator&.expression_errors&.slice!(from..) || []+ end+def evaluate_expression(expression)result = js_evaluator.evaluate(expression)last_error = js_evaluator.expression_errors.lastdiff --git a/plugins/discourse-workflows/lib/discourse_workflows/item.rb b/plugins/discourse-workflows/lib/discourse_workflows/item.rbindex 867b7c1259c..43efeb37f12 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/item.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/item.rb@@ -3,6 +3,9 @@module DiscourseWorkflowsmodule ItemPAIRED_ITEM_KEY = "pairedItem"+ ERROR_KEY = "error"+ # Set by NodeExecutionContext#guard_item; the executor reads and removes it after every node run.+ FAILED_KEY = "__failed"INCONSISTENT_ITEM_FORMAT_MESSAGE = "Every returned item must use the same format."class InconsistentItemFormatError < ArgumentError@@ -51,6 +54,15 @@ module DiscourseWorkflowsitem.except(PAIRED_ITEM_KEY).merge(PAIRED_ITEM_KEY => normalize_paired_item(paired_item))end+ def self.error_metadata(error)+ { "message" => error.message, "name" => error.class.name }+ end++ def self.with_error(item, error, paired_item:)+ failed = item.deep_dup.merge(ERROR_KEY => error_metadata(error))+ paired_item.nil? ? failed : with_paired_item(failed, paired_item)+ end+def self.normalize_paired_item(paired_item)case paired_itemwhen Arraydiff --git a/plugins/discourse-workflows/lib/discourse_workflows/item_contract.rb b/plugins/discourse-workflows/lib/discourse_workflows/item_contract.rbindex 6366e88ec93..af18ea63db1 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/item_contract.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/item_contract.rb@@ -2,7 +2,7 @@module DiscourseWorkflowsmodule ItemContract- VALID_ITEM_KEYS = %w[json pairedItem error index].freeze+ VALID_ITEM_KEYS = ["json", "pairedItem", "error", "index", Item::FAILED_KEY].freezeclass Error < StandardErrorenddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_data_shape.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_data_shape.rbindex c5b3cd0b8bd..709a8b3933e 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_data_shape.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_data_shape.rb@@ -10,6 +10,8 @@ module DiscourseWorkflows"continueOnFail" => :continue_on_fail,}.freeze+ CONTINUE_ON_ERROR_MODES = %w[continueRegularOutput continueErrorOutput].freeze+FORM_TRIGGER_TYPE = "trigger:form"FORM_TRIGGER_WEBHOOK_ID_KEY = "webhookId"diff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_error.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_error.rbindex a3e442d9ff7..d0f4ab50b28 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_error.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_error.rb@@ -2,5 +2,14 @@module DiscourseWorkflowsclass NodeError < StandardError+ def initialize(message = nil, summary: nil)+ super(message)+ @summary = summary+ end++ # The message without its item or line location, so per-item failures can be grouped.+ def summary+ @summary || message+ endendenddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_error_handling.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_error_handling.rbindex 7edafffbc61..375e075ff4b 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_error_handling.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_error_handling.rb@@ -10,10 +10,12 @@ module DiscourseWorkflowssuffix << (line_number ? ", for item #{item_index}" : " [item #{item_index}") if item_indexsuffix.presence&.<<("]")- full_message = +"#{message}#{suffix}"- full_message << ": #{description}" if description.present?+ details = description.present? ? ": #{description}" : ""- raise DiscourseWorkflows::NodeError, full_message+ raise DiscourseWorkflows::NodeError.new(+ "#{message}#{suffix}#{details}",+ summary: "#{message}#{details}",+ )endendenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/node_execution_context_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/node_execution_context_spec.rbindex 747371a17be..c07bf32f939 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/node_execution_context_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/node_execution_context_spec.rb@@ -309,6 +309,120 @@ RSpec.describe DiscourseWorkflows::Executor::NodeExecutionContext doendend+ describe "#guard_item" do+ let(:item) { { "json" => { "id" => 1 } } }+ let(:error) { DiscourseWorkflows::NodeError.new("Boom [item 0]", summary: "Boom") }++ def continuing_context(**args)+ described_class.new(+ input_items: [item],+ resolver: nil,+ node_settings: {+ "onError" => "continueRegularOutput",+ },+ **args,+ )+ end++ it "re-raises node errors when the node stops on error" do+ ctx = described_class.new(input_items: [item], resolver: nil)++ expect { ctx.guard_item(item, 0) { raise error } }.to raise_error(error)+ end++ it "lets other errors through even when continuing" do+ expect { continuing_context.guard_item(item, 0) { raise ArgumentError } }.to raise_error(+ ArgumentError,+ )+ end++ it "turns a node error into a marked failed item when continuing", :aggregate_failures do+ ctx = continuing_context++ failed = ctx.guard_item(item, 3) { raise error }++ expect(failed).to eq(+ "json" => {+ "id" => 1,+ },+ "error" => {+ "message" => "Boom [item 0]",+ "name" => "DiscourseWorkflows::NodeError",+ },+ "pairedItem" => {+ "item" => 3,+ },+ DiscourseWorkflows::Item::FAILED_KEY => true,+ )+ expect(item).not_to have_key("error")+ expect(ctx.metadata["item_errors"]).to eq([{ "message" => "Boom", "items" => [3] }])+ end++ it "groups item errors by summary, up to a limit" do+ ctx = continuing_context+ other_error = DiscourseWorkflows::NodeError.new("Bang [item 2]", summary: "Bang")+ ignored_error = DiscourseWorkflows::NodeError.new("Ignored")++ stub_const(described_class::RuntimeState, :MAX_ITEM_ERROR_GROUPS, 2) do+ ctx.guard_item(item, 0) { raise error }+ ctx.guard_item(item, 1) { raise error }+ ctx.guard_item(item, 2) { raise other_error }+ ctx.guard_item(item, 3) { raise ignored_error }+ end++ expect(ctx.metadata["item_errors"]).to eq(+ [{ "message" => "Boom", "items" => [0, 1] }, { "message" => "Bang", "items" => [2] }],+ )+ end++ it "keeps a failed item's expression errors from failing the whole step", :aggregate_failures do+ ctx, resolver, sandbox =+ build_parameter_context(+ { "recipient" => "={{ $json.missing.name }}" },+ node_settings: {+ "onError" => "continueRegularOutput",+ },+ )++ ctx.guard_item(ctx.input_items.first, 0) do+ ctx.get_node_parameter("recipient", 0)+ raise error+ end++ expect(resolver.expression_errors).to be_empty+ expect(ctx.log.errors?).to eq(false)+ expect(ctx.log.entries.sole).to include(+ "level" => "warn",+ "message" => a_string_including("$json.missing.name", "[item 0]"),+ )+ ensure+ resolver&.dispose+ sandbox&.dispose+ end+ end++ describe "#each_item" do+ it "pairs the outputs of each item with it unless already paired", :aggregate_failures do+ items = [{ "json" => { "id" => 1 } }, { "json" => { "id" => 2 } }]+ ctx = described_class.new(input_items: items, resolver: nil)++ output =+ ctx.each_item do |item, index|+ next { "json" => { "sent" => item["json"]["id"] } } if index == 0++ [{ "json" => {}, "pairedItem" => { "item" => 0 } }, { "json" => {} }]+ end++ expect(output).to eq(+ [+ { "json" => { "sent" => 1 }, "pairedItem" => { "item" => 0 } },+ { "json" => {}, "pairedItem" => { "item" => 0 } },+ { "json" => {}, "pairedItem" => { "item" => 1 } },+ ],+ )+ end+ end+describe "#set_metadata" doit "merges execution metadata with string keys" doctx = described_class.new(input_items: [], resolver: nil)@@ -1153,6 +1267,7 @@ RSpec.describe DiscourseWorkflows::Executor::NodeExecutionContext doparameters = nil,schema: {},input_items: [{ "json" => {} }],+ node_settings: {},**keyword_parameters)parameters ||= keyword_parameters@@ -1165,6 +1280,7 @@ RSpec.describe DiscourseWorkflows::Executor::NodeExecutionContext doparameters: parameters,property_schema: schema,resolver: resolver,+ node_settings: node_settings,)[ctx, resolver, sandbox]enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rbindex 6c89ebe96c6..b86879582cf 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb@@ -544,6 +544,100 @@ RSpec.describe DiscourseWorkflows::Executor doexpect(code_2_step["input"].first["pairedItem"]).to eq("item" => 0)end+ context "with items failed one by one" do+ let(:upstream_failure_too) { true }+ let(:per_item_node_class) do+ upstream_failure_too = self.upstream_failure_too++ Class.new(DiscourseWorkflows::NodeType) do+ description(name: "action:per_item_failure_test", version: "1.0")++ define_method(:execute) do |exec_ctx|+ upstream_failure = { "json" => { "id" => 1 }, "error" => { "message" => "Upstream" } }+ failed =+ exec_ctx.guard_item({ "json" => { "id" => 2 } }, 0) do+ raise DiscourseWorkflows::NodeError, "Boom"+ end+ [upstream_failure_too ? [upstream_failure, failed] : [failed]]+ end+ end+ end++ before do+ DiscoursePluginRegistry.register_discourse_workflows_node(+ per_item_node_class,+ Plugin::Instance.new,+ )+ DiscourseWorkflows::Registry.reset_indexes!+ end++ after { unregister_workflow_nodes(per_item_node_class) }++ it "routes only the items the node failed through the error output", :aggregate_failures do+ graph =+ build_workflow_graph do |g|+ g.node "trigger-1", "trigger:topic_closed"+ g.node "per-item-1",+ "action:per_item_failure_test",+ configuration: {+ "onError" => "continueErrorOutput",+ }+ g.node "success-1", "action:code", configuration: { "code" => "return $input.all();" }+ g.node "error-1", "action:code", configuration: { "code" => "return $input.all();" }+ g.connect "trigger-1", "per-item-1"+ g.connect "per-item-1", "success-1"+ g.connect "per-item-1", "error-1", output: 1+ end+ workflow =+ Fabricate(:discourse_workflows_workflow, created_by: user, published: true, **graph)++ execution = described_class.new(workflow, "trigger-1", { topic_id: topic.id }).run++ expect(execution.status).to eq("success")+ success_input = execution.execution_data.find_step(node_id: "success-1")["input"]+ error_input = execution.execution_data.find_step(node_id: "error-1")["input"]+ expect(success_input).to contain_exactly(+ include("json" => { "id" => 1 }, "error" => { "message" => "Upstream" }),+ )+ expect(error_input).to contain_exactly(+ include("json" => { "id" => 2 }, "error" => include("message" => "Boom")),+ )+ expect(error_input.first).not_to have_key(DiscourseWorkflows::Item::FAILED_KEY)+ end++ context "when every item fails" do+ let(:upstream_failure_too) { false }++ it "does not add an always-output item to the success output", :aggregate_failures do+ graph =+ build_workflow_graph do |g|+ g.node "trigger-1", "trigger:topic_closed"+ g.node "per-item-1",+ "action:per_item_failure_test",+ configuration: {+ "onError" => "continueErrorOutput",+ "alwaysOutputData" => true,+ }+ g.node "success-1", "action:code", configuration: { "code" => "return $input.all();" }+ g.node "error-1", "action:code", configuration: { "code" => "return $input.all();" }+ g.connect "trigger-1", "per-item-1"+ g.connect "per-item-1", "success-1"+ g.connect "per-item-1", "error-1", output: 1+ end+ workflow =+ Fabricate(:discourse_workflows_workflow, created_by: user, published: true, **graph)++ execution = described_class.new(workflow, "trigger-1", { topic_id: topic.id }).run++ expect(execution.status).to eq("success")+ expect(execution.execution_data.find_step(node_id: "success-1")).to be_nil+ expect(+ execution.execution_data.find_step(node_id: "error-1")["input"],+ ).to contain_exactly(include("json" => { "id" => 2 }))+ end+ end+ end+it "truncates long error messages" dograph =build_workflow_graph do |g|diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/node_error_handling_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_error_handling_spec.rbnew file mode 100644index 00000000000..586bec29882--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_error_handling_spec.rb@@ -0,0 +1,20 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::NodeErrorHandling do+ subject(:handler) { Class.new { include DiscourseWorkflows::NodeErrorHandling }.new }++ it "keeps the location out of the error's summary", :aggregate_failures do+ expect {+ handler.send(+ :raise_node_error!,+ "Boom",+ description: "details",+ item_index: 2,+ line_number: 4,+ )+ }.to raise_error(DiscourseWorkflows::NodeError) { |error|+ expect(error.message).to eq("Boom [line 4, for item 2]: details")+ expect(error.summary).to eq("Boom: details")+ }+ end+enddiff --git a/plugins/discourse-workflows/spec/support/node_execution_helpers.rb b/plugins/discourse-workflows/spec/support/node_execution_helpers.rbindex 954d5b1bfea..d8fe308e60f 100644--- a/plugins/discourse-workflows/spec/support/node_execution_helpers.rb+++ b/plugins/discourse-workflows/spec/support/node_execution_helpers.rb@@ -9,13 +9,15 @@ module NodeExecutionHelpersnode_context: nil,user: nil,workflow: nil,+ node_settings: {},+ node: nil,&block)item = { "json" => {} } if item.nil? && input_items.nil?input_items = input_items || [item]node_credentials = configuration.fetch("credentials") { {} }node_parameters = configuration.except("credentials")- action = described_class.new(parameters: node_parameters, credentials: node_credentials)+ node ||= described_class.new(parameters: node_parameters, credentials: node_credentials)resolver_context = { "$json" => input_items.first&.dig("json") || {} }sandbox = DiscourseWorkflows::JsSandbox.new(resolver_context, user: user)resolver =@@ -31,12 +33,13 @@ module NodeExecutionHelpersnode_identifier: described_class.identifier,resolver_context: resolver_context,user: user,+ node_settings: node_settings,}kwargs[:node_context] = node_context if node_contextkwargs[:workflow] = workflow if workflowctx = DiscourseWorkflows::Executor::NodeExecutionContext.new(**kwargs)- output_arrays = action.execute(ctx)+ output_arrays = node.execute(ctx)DiscourseWorkflows::ItemContract.validate_output_arrays!(output_arrays,source: described_class.name,diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/executions/detail-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/executions/detail-test.gjsindex 206da3d05d4..76438862ef6 100644--- a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/executions/detail-test.gjs+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/executions/detail-test.gjs@@ -179,6 +179,32 @@ module();});+ test("renders the errors of items that failed individually", async function (assert) {+ this.execution = executionWithOutput([{ json: { value: 1 } }]);+ this.execution.steps[0].metadata = {+ item_errors: [+ { message: "Boom", items: [1, 2] },+ { message: "Bang", items: [3] },+ ],+ };++ await render(+ <template><ExecutionDetail @execution={{this.execution}} /></template>+ );++ const warnings = [+ ...document.querySelectorAll(+ ".workflows-execution-detail__step-warning.alert-warning"+ ),+ ].map((warning) => warning.textContent.trim());++ assert.deepEqual(warnings, [+ "2 items failed but the workflow continued because of its error settings: Boom",+ "An item failed but the workflow continued because of its error settings: Bang",+ ]);+ assert.dom(".workflows-execution-detail__hint").doesNotExist();+ });+test("explains why an execution was rate limited", async function (assert) {const error ="This workflow wasn't run because it already started 10 executions in the last minute.";@@ -236,6 +262,7 @@ module(this.execution.steps[0].metadata = {hints: [{ message: "First hint" }],handled_error: { message: "Boom" },+ item_errors: [{ message: "Item boom", items: [0] }],};const createObjectURL = sinon.stub(URL, "createObjectURL")@@ -257,6 +284,12 @@ module(),"the handled error is exported");+ assert.true(+ text.includes(+ " Warning: An item failed but the workflow continued because of its error settings: Item boom"+ ),+ "the item error is exported"+ );assert.true(text.includes(" Hint: First hint"),"the hint is exported"