A platform for community discussion. Free, open, simple.
FEATURE: schema based workflow (#41684)
Joffrey JAFFEUX4e5aa86db713
diff --git a/plugins/chat/lib/discourse_workflows/nodes/chat_approval/v1.rb b/plugins/chat/lib/discourse_workflows/nodes/chat_approval/v1.rbindex 18ac9474a8a..c0576976182 100644--- a/plugins/chat/lib/discourse_workflows/nodes/chat_approval/v1.rb+++ b/plugins/chat/lib/discourse_workflows/nodes/chat_approval/v1.rb@@ -7,6 +7,19 @@ if defined?(DiscourseWorkflows)class V1 < DiscourseWorkflows::NodeTypeinclude ChatChannelSelection+ APPROVAL_OUTPUT_SCHEMA = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "approved" => {+ "type" => "boolean",+ },+ "channel_id" => {+ "type" => "integer",+ },+ },+ }.freeze+description(name: "action:chat_approval",version: "1.0",@@ -20,6 +33,25 @@ if defined?(DiscourseWorkflows)capabilities: {waits_for_resume: true,},+ output_contracts: [+ {+ schema: APPROVAL_OUTPUT_SCHEMA,+ variants: [+ {+ schema: APPROVAL_OUTPUT_SCHEMA,+ mode: :union,+ display_options: {+ show: {+ timeout_minutes: [{ condition: { exists: true } }],+ },+ hide: {+ timeout_action: ["fail"],+ },+ },+ },+ ],+ },+ ],properties: {message: {type: :string,diff --git a/plugins/chat/lib/discourse_workflows/nodes/chat_message_created/v1.rb b/plugins/chat/lib/discourse_workflows/nodes/chat_message_created/v1.rbindex 3ce3d8b6d15..ead32834c32 100644--- a/plugins/chat/lib/discourse_workflows/nodes/chat_message_created/v1.rb+++ b/plugins/chat/lib/discourse_workflows/nodes/chat_message_created/v1.rb@@ -17,6 +17,67 @@ if defined?(DiscourseWorkflows)group: "discourse_triggers",available: -> { SiteSetting.chat_enabled },unavailable_reason_key: "discourse_workflows.node_unavailable.requires_chat",+ output_contracts: [+ {+ schema: {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "message" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ "message" => {+ "type" => "string",+ },+ "cooked" => {+ "type" => "string",+ },+ "excerpt" => {+ "type" => "string",+ },+ "created_at" => {+ "type" => "string",+ "format" => "date-time",+ },+ "thread_id" => {+ "type" => %w[integer null],+ },+ "chat_channel_id" => {+ "type" => "integer",+ },+ },+ },+ "channel" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ "title" => {+ "type" => "string",+ },+ "slug" => {+ "type" => "string",+ },+ "chatable_type" => {+ "type" => "string",+ },+ "chatable_id" => {+ "type" => "integer",+ },+ },+ },+ "user" => {+ "type" => "object",+ "properties" => DiscourseWorkflows::Schema::BASIC_USER_PROPERTIES,+ },+ },+ },+ },+ ],properties: {channel_id: {type: :integer,diff --git a/plugins/chat/lib/discourse_workflows/nodes/send_chat_message/v1.rb b/plugins/chat/lib/discourse_workflows/nodes/send_chat_message/v1.rbindex e4e2b2f1e63..f4ad8ecf8a0 100644--- a/plugins/chat/lib/discourse_workflows/nodes/send_chat_message/v1.rb+++ b/plugins/chat/lib/discourse_workflows/nodes/send_chat_message/v1.rb@@ -20,6 +20,22 @@ if defined?(DiscourseWorkflows)capabilities: {run_scope: "per_item",},+ output_contracts: [+ {+ schema: {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "channel_id" => {+ "type" => "integer",+ },+ "message" => {+ "type" => "string",+ },+ },+ },+ },+ ],properties: {channel_id: {type: :integer,diff --git a/plugins/chat/spec/lib/discourse_workflows/nodes/chat_approval_spec.rb b/plugins/chat/spec/lib/discourse_workflows/nodes/chat_approval_spec.rbindex dd7f38ec30f..e3988795448 100644--- a/plugins/chat/spec/lib/discourse_workflows/nodes/chat_approval_spec.rb+++ b/plugins/chat/spec/lib/discourse_workflows/nodes/chat_approval_spec.rb@@ -12,6 +12,28 @@ RSpec.describe DiscourseWorkflows::Nodes::ChatApproval::V1 doendend+ describe ".output_schemas" do+ it "unions interaction responses with timeout forwarding", :aggregate_failures do+ input_schema = DiscourseWorkflows::Schema::POST_SCHEMA++ expect(described_class.output_schemas({})).to eq([described_class::APPROVAL_OUTPUT_SCHEMA])+ expect(+ described_class.output_schemas(+ { "timeout_minutes" => "30" },+ input_schemas: [input_schema],+ ),+ ).to eq(+ [DiscourseWorkflows::Schema.union(input_schema, described_class::APPROVAL_OUTPUT_SCHEMA)],+ )+ expect(+ described_class.output_schemas(+ { "timeout_minutes" => "30", "timeout_action" => "fail" },+ input_schemas: [input_schema],+ ),+ ).to eq([described_class::APPROVAL_OUTPUT_SCHEMA])+ end+ end+describe ".load_options_context" dofab!(:other_channel) { Fabricate(:chat_channel, name: "Approvals") }fab!(:closed_channel) { Fabricate(:chat_channel, name: "Archived", status: :closed) }diff --git a/plugins/chat/spec/lib/discourse_workflows/nodes/chat_message_created_spec.rb b/plugins/chat/spec/lib/discourse_workflows/nodes/chat_message_created_spec.rbindex cc2442ef64b..cd925756ae2 100644--- a/plugins/chat/spec/lib/discourse_workflows/nodes/chat_message_created_spec.rb+++ b/plugins/chat/spec/lib/discourse_workflows/nodes/chat_message_created_spec.rb@@ -46,7 +46,7 @@ RSpec.describe DiscourseWorkflows::Nodes::ChatMessageCreated::V1 doendend- it "serializes the message, channel, and user" do+ it "serializes the message, channel, and user", :aggregate_failures dooutput = described_class.new(message, channel, user).outputexpect(output[:message]).to include(@@ -60,6 +60,7 @@ RSpec.describe DiscourseWorkflows::Nodes::ChatMessageCreated::V1 dousername: user.username,avatar_template: user.avatar_template,)+ expect(output).to match_node_output_schema(described_class)endit "matches nodes with no channel filter or the same channel" dodiff --git a/plugins/discourse-ai/discourse_workflows/nodes/ai_agent/v1.rb b/plugins/discourse-ai/discourse_workflows/nodes/ai_agent/v1.rbindex fb23ec17139..f6c5231c984 100644--- a/plugins/discourse-ai/discourse_workflows/nodes/ai_agent/v1.rb+++ b/plugins/discourse-ai/discourse_workflows/nodes/ai_agent/v1.rb@@ -19,6 +19,19 @@ if defined?(DiscourseWorkflows)capabilities: {run_scope: "per_item",},+ output_contracts: [+ {+ schema: {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "result" => {+ "type" => "string",+ },+ },+ },+ },+ ],properties: {agent_id: {type: :integer,diff --git a/plugins/discourse-ai/lib/workflow_schema_fields.rb b/plugins/discourse-ai/lib/workflow_schema_fields.rbnew file mode 100644index 00000000000..5e781d91f76--- /dev/null+++ b/plugins/discourse-ai/lib/workflow_schema_fields.rb@@ -0,0 +1,165 @@+# frozen_string_literal: true++module DiscourseAi+ module WorkflowSchemaFields+ class << self+ def convert(schema)+ schema = effective(normalize(schema))+ return {} unless object_schema?(schema)++ flatten_properties(schema["properties"], nil, {})+ end++ private++ def flatten_properties(properties, parent_path, result)+ properties.each do |name, property_schema|+ flatten_property(+ effective(normalize(property_schema)),+ property_path(parent_path, name),+ result,+ )+ end++ result+ end++ def flatten_property(schema, path, result)+ if schema.key?("const")+ result[path] = JSON.generate(schema["const"])+ elsif object_schema?(schema)+ result[path] = schema["description"].presence || compact_type(schema)+ flatten_properties(schema["properties"], path, result)+ elsif array_schema?(schema)+ flatten_array(schema, path, result)+ else+ result[path] = compact_type(schema)+ end+ end++ def flatten_array(schema, path, result)+ item_schema = effective(normalize(schema["items"]))+ if object_schema?(item_schema)+ result[path] = schema["description"].presence || nullable_suffix("array<object>", schema)+ flatten_properties(item_schema["properties"], "#{path}[0]", result)+ else+ result[path] = nullable_suffix("array<#{compact_type(item_schema)}>", schema)+ end+ end++ def property_path(parent_path, name)+ name = name.to_s+ segment =+ if name.match?(/\A[A-Za-z_$][A-Za-z0-9_$]*\z/)+ parent_path.present? ? ".#{name}" : name+ else+ "[#{JSON.generate(name)}]"+ end++ "#{parent_path}#{segment}"+ end++ def effective(schema)+ branches = schema["anyOf"]+ return schema unless branches.is_a?(Array)++ branches+ .map { |branch| effective(normalize(branch)) }+ .reduce(schema.except("anyOf")) { |combined, branch| display_union(combined, branch) }+ end++ def display_union(left, right)+ return right if left.except("$schema").empty?++ result = {}+ types = type_list(left) | type_list(right)+ result["type"] = types if types.any?++ %w[const format description].each do |key|+ result[key] = left[key] if left.key?(key) && left[key] == right[key]+ end++ if left["properties"].is_a?(Hash) || right["properties"].is_a?(Hash)+ result["properties"] = (left["properties"] || {}).merge(+ right["properties"] || {},+ ) do |_name, left_value, right_value|+ display_union(effective(normalize(left_value)), effective(normalize(right_value)))+ end+ end++ if left.key?("items") || right.key?("items")+ result["items"] = display_union(+ effective(normalize(left["items"])),+ effective(normalize(right["items"])),+ )+ end++ result+ end++ def type_list(schema)+ types = Array(schema["type"]).map(&:to_s)+ return types if types.any?+ return [json_type(schema["const"])] if schema.key?("const")+ return ["object"] if schema["properties"].is_a?(Hash)+ return ["array"] if schema.key?("items")++ []+ end++ def json_type(value)+ case value+ when Array+ "array"+ when Hash+ "object"+ when Integer+ "integer"+ when Numeric+ "number"+ when TrueClass, FalseClass+ "boolean"+ when NilClass+ "null"+ else+ "string"+ end+ end++ def compact_type(schema)+ types = type_list(schema)+ return "null" if types == ["null"]++ nullable = types.delete("null")+ types = ["unknown"] if types.empty?+ types.map! do |type|+ type == "string" && schema["format"] == "date-time" ? "datetime" : type+ end+ types << "null" if nullable+ types.join("|")+ end++ def nullable_suffix(type, schema)+ type_list(schema).include?("null") ? "#{type}|null" : type+ end++ def object_schema?(schema)+ sole_non_null_type?(schema, "object") && schema["properties"].is_a?(Hash)+ end++ def array_schema?(schema)+ sole_non_null_type?(schema, "array") && schema["items"].is_a?(Hash)+ end++ def sole_non_null_type?(schema, type)+ (type_list(schema) - ["null"]).uniq == [type]+ end++ def normalize(schema)+ return {} unless schema.respond_to?(:to_h)++ schema.to_h.deep_stringify_keys+ end+ end+ end+enddiff --git a/plugins/discourse-ai/spec/lib/workflow_schema_fields_spec.rb b/plugins/discourse-ai/spec/lib/workflow_schema_fields_spec.rbnew file mode 100644index 00000000000..571db3e7b66--- /dev/null+++ b/plugins/discourse-ai/spec/lib/workflow_schema_fields_spec.rb@@ -0,0 +1,217 @@+# frozen_string_literal: true++RSpec.describe DiscourseAi::WorkflowSchemaFields do+ before { enable_current_plugin }++ describe ".convert" do+ it "flattens a workflow output JSON Schema to compact AI paths" do+ schema = {+ type: "object",+ properties: {+ user: {+ type: "object",+ description: "Basic safe user attributes",+ properties: {+ username: {+ type: "string",+ },+ name: {+ type: %w[string null],+ },+ created_at: {+ type: "string",+ format: "date-time",+ },+ tags: {+ type: "array",+ items: {+ type: "string",+ },+ },+ groups: {+ type: "array",+ items: {+ type: "object",+ properties: {+ id: {+ type: "integer",+ },+ name: {+ type: %w[string null],+ },+ },+ },+ },+ },+ },+ membership: {+ type: "object",+ description: "Group membership event metadata",+ properties: {+ action: {+ const: "added",+ },+ automatic: {+ type: %w[boolean null],+ },+ removed_at: {+ type: "null",+ },+ },+ },+ },+ }++ expect(described_class.convert(schema)).to eq(+ "user" => "Basic safe user attributes",+ "user.username" => "string",+ "user.name" => "string|null",+ "user.created_at" => "datetime",+ "user.tags" => "array<string>",+ "user.groups" => "array<object>",+ "user.groups[0].id" => "integer",+ "user.groups[0].name" => "string|null",+ "membership" => "Group membership event metadata",+ "membership.action" => '"added"',+ "membership.automatic" => "boolean|null",+ "membership.removed_at" => "null",+ )+ end++ it "does not interpret a flat field map as a schema" do+ expect(described_class.convert("result" => "string")).to eq({})+ expect(described_class.convert(nil)).to eq({})+ end++ it "preserves property segments that require bracket notation" do+ schema = {+ type: "object",+ properties: {+ "full-name" => {+ type: "string",+ },+ "a.b" => {+ type: "boolean",+ },+ :a => {+ type: "object",+ properties: {+ :b => {+ type: "integer",+ },+ "x y" => {+ type: "string",+ },+ },+ },+ },+ }++ expect(described_class.convert(schema)).to eq(+ '["full-name"]' => "string",+ '["a.b"]' => "boolean",+ "a" => "object",+ "a.b" => "integer",+ 'a["x y"]' => "string",+ )+ end++ it "does not narrow mixed structural unions" do+ schema = {+ type: "object",+ properties: {+ object_or_string: {+ type: %w[object string],+ properties: {+ id: {+ type: "integer",+ },+ },+ },+ array_or_string: {+ type: %w[array string],+ items: {+ type: "integer",+ },+ },+ nullable_object: {+ type: %w[object null],+ properties: {+ id: {+ type: "integer",+ },+ },+ },+ nullable_array: {+ type: %w[array null],+ items: {+ type: "integer",+ },+ },+ },+ }++ expect(described_class.convert(schema)).to eq(+ "object_or_string" => "object|string",+ "array_or_string" => "array|string",+ "nullable_object" => "object|null",+ "nullable_object.id" => "integer",+ "nullable_array" => "array<integer>|null",+ )+ end++ it "combines anyOf alternatives into a single display schema" do+ schema = {+ "$schema" => "https://json-schema.org/draft/2020-12/schema",+ "anyOf" => [+ {+ type: "object",+ properties: {+ value: {+ type: "string",+ },+ left_only: {+ type: "boolean",+ },+ },+ },+ {+ type: "object",+ properties: {+ value: {+ type: "integer",+ },+ right_only: {+ type: "boolean",+ },+ },+ },+ ],+ }++ expect(described_class.convert(schema)).to eq(+ "value" => "string|integer",+ "left_only" => "boolean",+ "right_only" => "boolean",+ )+ end++ it "keeps nested anyOf alternatives when combining branches" do+ schema = {+ "anyOf" => [+ {+ type: "object",+ properties: {+ value: {+ "anyOf" => [{ type: "string" }, { type: "integer" }],+ },+ },+ },+ { type: "object", properties: { value: { type: "boolean" } } },+ ],+ }++ expect(described_class.convert(schema)).to eq("value" => "string|integer|boolean")+ end+ end+enddiff --git a/plugins/discourse-assign/lib/discourse_assign/workflows/schema.rb b/plugins/discourse-assign/lib/discourse_assign/workflows/schema.rbnew file mode 100644index 00000000000..7481b138b69--- /dev/null+++ b/plugins/discourse-assign/lib/discourse_assign/workflows/schema.rb@@ -0,0 +1,84 @@+# frozen_string_literal: true++module DiscourseAssign+ module Workflows+ module Schema+ ASSIGNEE_SCHEMA = {+ "type" => "object",+ "properties" => {+ "type" => {+ "type" => %w[string null],+ },+ "user" => {+ "type" => "object",+ "properties" => DiscourseWorkflows::Schema::BASIC_USER_PROPERTIES,+ },+ "group" => {+ "type" => "object",+ "properties" => DiscourseWorkflows::Schema::BASIC_GROUP_PROPERTIES,+ },+ },+ }.freeze++ ASSIGN_TOPIC_OUTPUT_SCHEMA = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "assignee" => ASSIGNEE_SCHEMA,+ "previously_assigned" => ASSIGNEE_SCHEMA,+ },+ }.freeze++ ASSIGNMENT_SCHEMA = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "assignment" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ "target_type" => {+ "type" => "string",+ },+ "target_id" => {+ "type" => "integer",+ },+ "topic_id" => {+ "type" => "integer",+ },+ "topic_assignment" => {+ "type" => "boolean",+ },+ "assigned_to_id" => {+ "type" => "integer",+ },+ "assigned_to_type" => {+ "type" => "string",+ },+ "assigned_to" => ASSIGNEE_SCHEMA,+ "assigned_by_user" => {+ "type" => "object",+ "properties" => DiscourseWorkflows::Schema::BASIC_USER_PROPERTIES,+ },+ "note" => {+ "type" => %w[string null],+ },+ "status" => {+ "type" => %w[string null],+ },+ },+ },+ },+ }.freeze++ ASSIGNED_OUTPUT_SCHEMA =+ DiscourseWorkflows::Schema.merge(+ DiscourseWorkflows::Schema::POST_SCHEMA,+ DiscourseWorkflows::Schema::TOPIC_LIST_ITEM_SCHEMA,+ ASSIGNMENT_SCHEMA,+ ).freeze+ end+ end+enddiff --git a/plugins/discourse-assign/lib/discourse_workflows/nodes/assign_topic/v1.rb b/plugins/discourse-assign/lib/discourse_workflows/nodes/assign_topic/v1.rbindex 108f4710468..e7bfb071273 100644--- a/plugins/discourse-assign/lib/discourse_workflows/nodes/assign_topic/v1.rb+++ b/plugins/discourse-assign/lib/discourse_workflows/nodes/assign_topic/v1.rb@@ -16,6 +16,9 @@ if defined?(DiscourseWorkflows)},available: -> { SiteSetting.assign_enabled },unavailable_reason_key: "discourse_workflows.node_unavailable.requires_assign",+ output_contracts: [+ { schema: DiscourseAssign::Workflows::Schema::ASSIGN_TOPIC_OUTPUT_SCHEMA },+ ],capabilities: {run_scope: "per_item",},diff --git a/plugins/discourse-assign/lib/discourse_workflows/nodes/assigned/v1.rb b/plugins/discourse-assign/lib/discourse_workflows/nodes/assigned/v1.rbindex 2364cd147a5..eb95a3fc9c1 100644--- a/plugins/discourse-assign/lib/discourse_workflows/nodes/assigned/v1.rb+++ b/plugins/discourse-assign/lib/discourse_workflows/nodes/assigned/v1.rb@@ -16,6 +16,9 @@ if defined?(DiscourseWorkflows)events: [:assigned],available: -> { SiteSetting.assign_enabled },unavailable_reason_key: "discourse_workflows.node_unavailable.requires_assign",+ output_contracts: [+ { schema: DiscourseAssign::Workflows::Schema::ASSIGNED_OUTPUT_SCHEMA },+ ],properties: {topic_assignments_only: {type: :boolean,diff --git a/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assign_topic/v1_spec.rb b/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assign_topic/v1_spec.rbindex 93ffede9cc5..6933edbd702 100644--- a/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assign_topic/v1_spec.rb+++ b/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assign_topic/v1_spec.rb@@ -41,7 +41,7 @@ RSpec.describe DiscourseWorkflows::Nodes::AssignTopic::V1 dolet(:item) { { "json" => {} } }context "with assign operation" do- it "assigns the topic to a user" do+ it "assigns the topic to a user", :aggregate_failures doconfig = {"operation" => "assign","topic_id" => topic.id.to_s,@@ -54,9 +54,10 @@ RSpec.describe DiscourseWorkflows::Nodes::AssignTopic::V1 doexpect(result["assignee"]["user"]["id"]).to eq(user.id)expect(result["assignee"]["user"]["username"]).to eq(user.username)expect(Assignment.exists?(target: topic, assigned_to: user)).to eq(true)+ expect(result).to match_node_output_schema(described_class)end- it "assigns the topic to a group" do+ it "assigns the topic to a group", :aggregate_failures doSiteSetting.assign_allowed_on_groups = "#{assign_allowed_group.id}|#{group.id}"group.update!(assignable_level: Group::ALIAS_LEVELS[:everyone])@@ -68,6 +69,7 @@ RSpec.describe DiscourseWorkflows::Nodes::AssignTopic::V1 doexpect(result["assignee"]["group"]["id"]).to eq(group.id)expect(result["assignee"]["group"]["name"]).to eq(group.name)expect(Assignment.exists?(target: topic, assigned_to: group)).to eq(true)+ expect(result).to match_node_output_schema(described_class)endit "raises when assignee does not exist" do@@ -87,7 +89,7 @@ RSpec.describe DiscourseWorkflows::Nodes::AssignTopic::V1 dobefore { ::Assigner.new(topic, Discourse.system_user).assign(other_user) }- it "replaces the existing assignment by default" do+ it "replaces the existing assignment by default", :aggregate_failures doconfig = {"operation" => "assign","topic_id" => topic.id.to_s,@@ -100,6 +102,7 @@ RSpec.describe DiscourseWorkflows::Nodes::AssignTopic::V1 doexpect(result["previously_assigned"]["type"]).to eq("user")expect(result["previously_assigned"]["user"]["username"]).to eq(other_user.username)expect(Assignment.find_by(target: topic).assigned_to).to eq(user)+ expect(result).to match_node_output_schema(described_class)endit "replaces the existing assignment when replace_existing is true" dodiff --git a/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assigned/v1_spec.rb b/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assigned/v1_spec.rbindex 262c07057b9..20c8eb82a5f 100644--- a/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assigned/v1_spec.rb+++ b/plugins/discourse-assign/spec/lib/discourse_workflows/nodes/assigned/v1_spec.rb@@ -31,7 +31,8 @@ RSpec.describe DiscourseWorkflows::Nodes::Assigned::V1 doenddescribe "#output" do- it "returns assignment, post, topic, and assignee data for post assignments" do+ it "returns assignment, post, topic, and assignee data for post assignments",+ :aggregate_failures doassignment =Fabricate(:post_assignment,@@ -60,9 +61,10 @@ RSpec.describe DiscourseWorkflows::Nodes::Assigned::V1 doexpect(output[:assignment][:assigned_by_user][:username]).to eq(assigned_by_user.username)expect(output[:post][:id]).to eq(post.id)expect(output[:topic][:id]).to eq(topic.id)+ expect(output).to match_node_output_schema(described_class)end- it "uses the topic first post for topic assignments" do+ it "uses the topic first post for topic assignments", :aggregate_failures doassignment =Fabricate(:topic_assignment, topic:, assigned_to: group, assigned_by_user: assigned_by_user)@@ -77,6 +79,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Assigned::V1 doexpect(output[:assignment][:assigned_to][:type]).to eq("group")expect(output[:assignment][:assigned_to][:group][:name]).to eq(group.name)expect(output[:post][:id]).to eq(topic.first_post.id)+ expect(output).to match_node_output_schema(described_class)endenddiff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/node-panel.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/node-panel.gjsindex 0ca554dfca2..4b7434a1e06 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/node-panel.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/node-panel.gjs@@ -74,6 +74,15 @@ export function sortNodeTypesByLabel(nodeTypes) {);}+export function nodeTypesForPalette(nodeTypes) {+ return sortNodeTypesByLabel(+ (nodeTypes || []).filter(+ (nodeType) =>+ nodeType.available !== false && nodeType.palette_visible !== false+ )+ );+}+export default class NodePanel extends Component {@tracked selectedCategory = null;@tracked selectedOperationNodeType = null;@@ -83,11 +92,7 @@ export default class NodePanel extends Component {}get availableNodeTypes() {- return sortNodeTypesByLabel(- (this.args.nodeTypes || []).filter(- (nodeType) => nodeType.available !== false- )- );+ return nodeTypesForPalette(this.args.nodeTypes);}get categories() {diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/workflow-node.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/workflow-node.gjsindex 6f64e584f3d..8b8ca1d1e5f 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/workflow-node.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/canvas/workflow-node.gjs@@ -21,6 +21,7 @@ import {nodeTypeRunScopeLabelKey,nodeTypeStyle,resolveNodeTypeVersion,+ typeVersionForNode,} from "../../../lib/workflows/node-types";import { nodeDescription, nodeLabel } from "../../../lib/workflows/node-utils";import CanvasHoverToolbar from "./hover-toolbar";@@ -31,7 +32,7 @@ function resolveType(workflowsNodeTypes, node) {return null;}- return resolveNodeTypeVersion(nodeType, node.typeVersion);+ return resolveNodeTypeVersion(nodeType, typeVersionForNode(node));}const highlightOnInsert = modifier((element) => {diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/condition-builder.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/condition-builder.gjsindex b2c462c4a8f..4813849c3d7 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/condition-builder.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/condition-builder.gjs@@ -7,16 +7,18 @@ import {isSingleValueOperator,operatorsForType,} from "../../../lib/workflows/condition-operators";+import { schemaFieldsForNodeInput } from "../../../lib/workflows/data-preview";import {- inputConnectionsForNode,inputFieldPrefixForConnection,inputIndexForConnection,- inputSummaryForNode,outputIndexForConnection,- previousNodeForConnection,- schemaFieldsForNodeInput,-} from "../../../lib/workflows/data-schema";+} from "../../../lib/workflows/expression-paths";import { isExpression } from "../../../lib/workflows/property-engine";+import {+ inputConnectionsForNode,+ previousNodeForConnection,+ resolveDeclaredOutputSchemas,+} from "../../../lib/workflows/schema-graph";import Collection from "./collection";import Field from "./field";@@ -24,19 +26,40 @@ function flattenFields(fields, prefix = "", labelPrefix = "") {const result = [];for (const field of fields) {const path = prefix ? `${prefix}.${field.key}` : field.key;- if (field.children?.length) {- result.push(...flattenFields(field.children, path, labelPrefix));- } else {+ if (field.type === "array") {result.push({id: field.id || path,label: labelPrefix ? `${labelPrefix}.${path}` : path,- type: field.type,+ type: "array",});}++ if (field.children?.length) {+ result.push(...flattenFields(field.children, path, labelPrefix));+ } else if (field.type !== "array") {+ const type = conditionType(field.type);+ if (type) {+ result.push({+ id: field.id || path,+ label: labelPrefix ? `${labelPrefix}.${path}` : path,+ type,+ });+ }+ }}return result;}+function conditionType(type) {+ if (type === "integer") {+ return "number";+ }++ return ["array", "boolean", "number", "string"].includes(type)+ ? type+ : undefined;+}+const CATEGORY_FIELDS = ["category_id", "category"];const USER_FIELDS = ["username"];@@ -123,7 +146,7 @@ function leftValueSchema(fieldOptions) {const OPERATION_SCHEMAS = {};function operationSchema(item) {- const type = item?.operator?.type || "string";+ const type = conditionType(item?.operator?.type) || "string";return (OPERATION_SCHEMAS[type] ??= {type: "options",required: true,@@ -162,6 +185,7 @@ export default class ConditionBuilder extends Component {nodeTypes: this.args.nodeTypes || [],};const runData = this.args.session?.lastExecutionRunData || {};+ const declaredOutputSchemas = resolveDeclaredOutputSchemas(graph);const inputConnections = inputConnectionsForNode(this.args.node, graph);const primaryConnection = inputConnections[0] || null;@@ -173,25 +197,23 @@ export default class ConditionBuilder extends Component {const inputIndex = inputIndexForConnection(connection);const outputIndex = outputIndexForConnection(connection);- const currentInputSummary = this.args.node- ? inputSummaryForNode(runData, this.args.node.name, inputIndex, {- node: this.args.node,- sourceNode: previousNode,- outputIndex,- })- : null;+ const pinnedItems =+ outputIndex === 0+ ? this.args.session?.pinnedItemsForNode(previousNode.name)+ : undefined;const prefix = inputFieldPrefixForConnection(connection, previousNode, {primaryConnection,});- const fields = currentInputSummary- ? schemaFieldsForNodeInput(runData, this.args.node.name, {- inputIndex,- node: this.args.node,- sourceNode: previousNode,- outputIndex,- prefix,- })- : [];+ const fields = schemaFieldsForNodeInput(runData, this.args.node?.name, {+ inputIndex,+ node: this.args.node,+ sourceNode: previousNode,+ outputIndex,+ prefix,+ graph,+ pinnedItems,+ declaredOutputSchemas,+ });const labelPrefix =inputConnections.length > 1 ? previousNode.name || null : null;@@ -240,7 +262,7 @@ export default class ConditionBuilder extends Component {}const field = this.fieldOptions.find((option) => option.id === value);- const type = field?.type || "string";+ const type = conditionType(field?.type) || "string";const storedValue = this.args.fieldOptions? valuediff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjsindex 9be2184c7aa..b6e62021dac 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs@@ -6,18 +6,22 @@ import { cancel } from "@ember/runloop";import { service } from "@ember/service";import discourseLater from "discourse/lib/later";import {- ancestorOutputNodes,- inputConnectionsForNode,+ schemaFieldsForNodeInput,+ schemaFieldsForNodeOutput,+} from "../../../lib/workflows/data-preview";+import buildExpressionExtensions from "../../../lib/workflows/expression-extensions";+import {inputIndexForConnection,- inputSummaryForNode,- nodeOutputFirstJsonPath,- nodeOutputLinkedItemJsonPath,+ nodeOutputJsonPath,outputIndexForConnection,+} from "../../../lib/workflows/expression-paths";+import { schemaFieldsForItems } from "../../../lib/workflows/schema-fields";+import {+ ancestorOutputNodes,+ inputConnectionsForNode,previousNodeForConnection,- schemaFieldsForItems,- schemaFieldsForNodeInput,-} from "../../../lib/workflows/data-schema";-import buildExpressionExtensions from "../../../lib/workflows/expression-extensions";+ resolveDeclaredOutputSchemas,+} from "../../../lib/workflows/schema-graph";import ExpressionPreview from "../variable/expression-preview";import VariableInput from "../variable/input";import ReferencePropertyPicker from "../variable/reference-property-picker";@@ -70,6 +74,7 @@ export default class ExpressionInput extends Component {const itemPrefix =this.workflowsNodeTypes.expressionContext.item_prefix || "$json";const runData = session?.lastExecutionRunData || {};+ const declaredOutputSchemas = resolveDeclaredOutputSchemas(graph);const previousConnection = node? inputConnectionsForNode(node, graph)[0]: null;@@ -77,42 +82,49 @@ export default class ExpressionInput extends Component {const currentInputIndex = previousConnection? inputIndexForConnection(previousConnection): 0;- const currentInputSummary = node- ? inputSummaryForNode(runData, node.name, currentInputIndex, {+ const previousOutputIndex = previousConnection+ ? outputIndexForConnection(previousConnection)+ : 0;+ const pinnedInputItems =+ previousOutputIndex === 0+ ? session?.pinnedItemsForNode(previousNode?.name)+ : undefined;+ const inputFields = node+ ? schemaFieldsForNodeInput(runData, node.name, {+ inputIndex: currentInputIndex,node,sourceNode: previousNode,- outputIndex: previousConnection- ? outputIndexForConnection(previousConnection)- : 0,+ outputIndex: previousOutputIndex,+ prefix: itemPrefix,+ graph,+ pinnedItems: pinnedInputItems,+ declaredOutputSchemas,})- : null;- let inputFields = [];- if (currentInputSummary) {- inputFields = schemaFieldsForNodeInput(runData, node.name, {- inputIndex: currentInputIndex,- node,- sourceNode: previousNode,- outputIndex: previousConnection- ? outputIndexForConnection(previousConnection)- : 0,- prefix: itemPrefix,- });- }+ : [];// Pinned sample data, falling back to the last run.const ancestorNodes = node? ancestorOutputNodes(node, graph).map((ancestor) => {- const items =- session?.outputItemsForNode(ancestor.node, ancestor.outputIndex) ||- [];- const prefix =- items.length === 1- ? nodeOutputFirstJsonPath(ancestor.node.name, {- outputIndex: ancestor.outputIndex,- })- : nodeOutputLinkedItemJsonPath(ancestor.node.name);+ const pinnedItems =+ ancestor.outputIndex === 0+ ? session?.pinnedItemsForNode(ancestor.node.name)+ : undefined;+ const prefix = nodeOutputJsonPath(runData, ancestor.node.name, {+ outputIndex: ancestor.outputIndex,+ node: ancestor.node,+ itemCount: pinnedItems?.length,+ });return {node: ancestor.node,- fields: schemaFieldsForItems(items, { prefix }),+ fields:+ pinnedItems === undefined+ ? schemaFieldsForNodeOutput(runData, ancestor.node.name, {+ outputIndex: ancestor.outputIndex,+ node: ancestor.node,+ prefix,+ graph,+ declaredOutputSchemas,+ })+ : schemaFieldsForItems(pinnedItems, { prefix }),};}): [];diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/property-engine.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/property-engine.gjsindex 29709d9b2f0..f7b47b67761 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/property-engine.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/property-engine.gjs@@ -4,7 +4,10 @@ import { action } from "@ember/object";import { eq } from "discourse/truth-helpers";import { i18n } from "discourse-i18n";import CONTROL_REGISTRY from "../../../lib/workflows/control-registry";-import { resolveNodeTypeVersion } from "../../../lib/workflows/node-types";+import {+ resolveNodeTypeVersion,+ typeVersionForNode,+} from "../../../lib/workflows/node-types";import {credentialSlotAnchorField,credentialSlotVisible,@@ -35,7 +38,10 @@ export default class PropertyEngineConfigurator extends Component {this.args.nodeDefinition ||findNodeType(this.args.nodeTypes, this.nodeType);- return resolveNodeTypeVersion(definition, this.args.node?.typeVersion);+ return resolveNodeTypeVersion(+ definition,+ typeVersionForNode(this.args.node)+ );}get metadata() {diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/input.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/input.gjsindex fc70e0fadf5..f3785881896 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/input.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/input.gjs@@ -5,20 +5,26 @@ import { trustHTML } from "@ember/template";import dIcon from "discourse/ui-kit/helpers/d-icon";import { i18n } from "discourse-i18n";import {- ancestorOutputNodes,- inputConnectionsForNode,- inputFieldPrefixForConnection,- inputIndexForConnection,inputSummaryForNode,- nodeOutputJsonPath,- outputIndexForConnection,outputSummaryForNode,- previousNodeForConnection,schemaFieldsForNodeInput,schemaFieldsForNodeOutput,-} from "../../../lib/workflows/data-schema";+} from "../../../lib/workflows/data-preview";+import {+ inputFieldPrefixForConnection,+ inputIndexForConnection,+ nodeOutputJsonPath,+ outputIndexForConnection,+} from "../../../lib/workflows/expression-paths";import processFields from "../../../lib/workflows/field-processors";import { nodeTypeColor, nodeTypeIcon } from "../../../lib/workflows/node-types";+import { schemaFieldsForItems } from "../../../lib/workflows/schema-fields";+import {+ ancestorOutputNodes,+ inputConnectionsForNode,+ previousNodeForConnection,+ resolveDeclaredOutputSchemas,+} from "../../../lib/workflows/schema-graph";import DragDropHint from "./drag-drop-hint";import SchemaField from "./schema-field";@@ -109,6 +115,11 @@ export default class InputContext extends Component {};}+ @cached+ get declaredOutputSchemas() {+ return resolveDeclaredOutputSchemas(this.graph);+ }+@cachedget inputConnections() {return inputConnectionsForNode(this.args.node, this.graph);@@ -150,6 +161,10 @@ export default class InputContext extends Component {const inputIndex = inputIndexForConnection(connection);const outputIndex = outputIndexForConnection(connection);+ const pinnedItems =+ outputIndex === 0+ ? this.args.session?.pinnedItemsForNode(previousNode.name)+ : undefined;const recordedInputSummary = inputSummaryForNode(this.runData,this.args.node.name,@@ -158,6 +173,7 @@ export default class InputContext extends Component {node: this.args.node,sourceNode: previousNode,outputIndex,+ pinnedItems,});const fields = schemaFieldsForNodeInput(@@ -171,6 +187,9 @@ export default class InputContext extends Component {prefix: inputFieldPrefixForConnection(connection, previousNode, {primaryConnection: this.primaryInputConnection,}),+ graph: this.graph,+ pinnedItems,+ declaredOutputSchemas: this.declaredOutputSchemas,});@@ -212,32 +231,39 @@ export default class InputContext extends Component {return ancestorOutputNodes(this.args.node, this.graph).filter((ancestor) => !directNodeIds.has(ancestor.node.clientId)).map((ancestor) => {- const fields = schemaFieldsForNodeOutput(- this.runData,- ancestor.node.name,- {- outputIndex: ancestor.outputIndex,- node: ancestor.node,- prefix: nodeOutputJsonPath(this.runData, ancestor.node.name, {+ const pinnedItems =+ ancestor.outputIndex === 0+ ? this.args.session?.pinnedItemsForNode(ancestor.node.name)+ : undefined;+ const prefix = nodeOutputJsonPath(this.runData, ancestor.node.name, {+ outputIndex: ancestor.outputIndex,+ node: ancestor.node,+ itemCount: pinnedItems?.length,+ });+ const fields = pinnedItems+ ? schemaFieldsForItems(pinnedItems, { prefix })+ : schemaFieldsForNodeOutput(this.runData, ancestor.node.name, {outputIndex: ancestor.outputIndex,node: ancestor.node,- }),- }- );+ prefix,+ graph: this.graph,+ declaredOutputSchemas: this.declaredOutputSchemas,+ });+ const summary = pinnedItems+ ? { itemCount: pinnedItems.length, truncated: false }+ : outputSummaryForNode(+ this.runData,+ ancestor.node.name,+ ancestor.outputIndex,+ { node: ancestor.node }+ );return {name: ancestor.node.name,type:this.workflowsNodeTypes.findNodeType(ancestor.node.type) ||ancestor.node.type,fields,- itemCountLabel: this.itemCountLabel(- outputSummaryForNode(- this.runData,- ancestor.node.name,- ancestor.outputIndex,- { node: ancestor.node }- )- ),+ itemCountLabel: this.itemCountLabel(summary),};}).filter((ancestor) => ancestor.fields.length);diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/output.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/output.gjsindex 69ec2acc63a..cc8d68b2aa3 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/output.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/context/output.gjs@@ -1,5 +1,5 @@import Component from "@glimmer/component";-import { tracked } from "@glimmer/tracking";+import { cached, tracked } from "@glimmer/tracking";import { fn } from "@ember/helper";import { on } from "@ember/modifier";import { action } from "@ember/object";@@ -8,7 +8,7 @@ import { eq } from "discourse/truth-helpers";import dConcatClass from "discourse/ui-kit/helpers/d-concat-class";import dIcon from "discourse/ui-kit/helpers/d-icon";import { i18n } from "discourse-i18n";-import { outputSchemaForNode } from "../../../lib/workflows/data-schema";+import { outputPreviewForNode } from "../../../lib/workflows/data-preview";import processFields from "../../../lib/workflows/field-processors";import { nodeTypePorts } from "../../../lib/workflows/node-types";import DragDropHint from "./drag-drop-hint";@@ -94,24 +94,30 @@ export default class OutputContext extends Component {};}- get outputSchema() {+ @cached+ get outputPreview() {const currentNode = this.args.node;- const schema = outputSchemaForNode(+ const preview = outputPreviewForNode(this.args.session?.lastExecutionRunData || {},currentNode.name,- { pinnedItems: this.pinnedItems, node: currentNode }+ {+ pinnedItems: this.pinnedItems,+ node: currentNode,+ graph: this.graph,+ configuration: this.args.configuration,+ });return {- ...schema,- itemCountLabel: this.itemCountLabel(schema.summary),- emptyMessage: this.emptyMessage(schema.summary),- fields: processFields(schema.fields, currentNode, this.graph),+ ...preview,+ itemCountLabel: this.itemCountLabel(preview.summary),+ emptyMessage: this.emptyMessage(preview.summary),+ fields: processFields(preview.fields, currentNode, this.graph),};}get fields() {- return this.outputSchema.fields || [];+ return this.outputPreview.fields || [];}itemCountLabel(summary) {@@ -125,7 +131,7 @@ export default class OutputContext extends Component {}get singleItemCountLabel() {- return this.outputSchema.itemCountLabel;+ return this.outputPreview.itemCountLabel;}emptyMessage(summary) {@@ -143,7 +149,7 @@ export default class OutputContext extends Component {}get emptyOutputMessage() {- return this.outputSchema.emptyMessage;+ return this.outputPreview.emptyMessage;}@action@@ -256,14 +262,20 @@ export default class OutputContext extends Component {{{/if}}</div>- {{#if this.hasNoData}}+ {{#if this.isJsonView}}<PinDataEditor@nodeName={{this.nodeName}}@initialItems={{this.effectiveItems}}@canEdit={{this.canEditPinData}}@session={{@session}}/>- {{else if this.isJsonView}}+ {{else if this.fields.length}}+ <ul class="workflows-schema-field-list">+ {{#each this.fields as |field|}}+ <SchemaField @field={{field}} />+ {{/each}}+ </ul>+ {{else if this.hasNoData}}<PinDataEditor@nodeName={{this.nodeName}}@initialItems={{this.effectiveItems}}@@ -271,17 +283,9 @@ export default class OutputContext extends Component {@session={{@session}}/>{{else}}- {{#if this.fields.length}}- <ul class="workflows-schema-field-list">- {{#each this.fields as |field|}}- <SchemaField @field={{field}} />- {{/each}}- </ul>- {{else}}- <p class="workflows-context-panel__empty">- {{this.emptyOutputMessage}}- </p>- {{/if}}+ <p class="workflows-context-panel__empty">+ {{this.emptyOutputMessage}}+ </p>{{/if}}</div></div>diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/editor/index.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/editor/index.gjsindex 8628632d14d..cdc3cf6e199 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/editor/index.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/editor/index.gjs@@ -21,6 +21,7 @@ import {nodeTypePrimaryOutputKey,nodeTypeVersion,resolveNodeTypeVersion,+ typeVersionForNode,} from "../../../lib/workflows/node-types";import { mergeImportedStaticData } from "../../../lib/workflows/static-data";import StickyNote, { STICKY_NOTE_TYPE } from "../../../models/sticky-note";@@ -55,7 +56,8 @@ export function isNodeUnavailable(workflowsNodeTypes, node) {}return (- resolveNodeTypeVersion(nodeType, node.typeVersion)?.available === false+ resolveNodeTypeVersion(nodeType, typeVersionForNode(node))?.available ===+ false);}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/node/configurator.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/node/configurator.gjsindex 25c1691c6fa..34290608993 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/node/configurator.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/node/configurator.gjs@@ -22,6 +22,7 @@ import {nodeTypeProducesData,nodeTypeStyle,resolveNodeTypeVersion,+ typeVersionForNode,} from "../../../lib/workflows/node-types";import {credentialSlotAnchorField,@@ -124,7 +125,7 @@ export default class NodeConfigurator extends Component {get resolvedNodeType() {return resolveNodeTypeVersion(findNodeType(this.nodeTypes, this.args.model.node.type),- this.args.model.node.typeVersion+ typeVersionForNode(this.args.model.node));}@@ -168,7 +169,7 @@ export default class NodeConfigurator extends Component {return getPropertySchema(this.nodeTypes,this.args.model.node.type,- this.args.model.node.typeVersion+ typeVersionForNode(this.args.model.node));}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-preview.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-preview.jsnew file mode 100644index 00000000000..ffa36813a9d--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-preview.js@@ -0,0 +1,231 @@+import {+ inputPreviewPort,+ latestRunWithOutput,+ outputForRun,+} from "./run-data";+import { fieldsForSchema, schemaFieldsForItems } from "./schema-fields";+import { outputSchemaForNode } from "./schema-graph";++function declaredFieldsForNodeOutput(+ node,+ graph,+ {+ outputIndex = 0,+ prefix = "$json",+ configuration,+ declaredOutputSchemas,+ } = {}+) {+ return fieldsForSchema(+ outputSchemaForNode(node, graph, {+ configuration,+ outputIndex,+ outputSchemas: declaredOutputSchemas,+ }),+ { prefix }+ );+}++function portWasFullyCompacted(port) {+ return (+ port?.truncated === true &&+ (port.item_count ?? 0) > 0 &&+ (port.items?.length ?? 0) === 0+ );+}++export function schemaFieldsForNodeOutput(+ runData,+ nodeName,+ {+ outputIndex = 0,+ prefix = "$json",+ node,+ graph,+ configuration,+ declaredOutputSchemas,+ } = {}+) {+ const run = latestRunWithOutput(runData, nodeName, { node });+ if (!run) {+ return declaredFieldsForNodeOutput(node, graph, {+ outputIndex,+ prefix,+ configuration,+ declaredOutputSchemas,+ });+ }++ const output = outputForRun(run, outputIndex);+ if (portWasFullyCompacted(output)) {+ return declaredFieldsForNodeOutput(node, graph, {+ outputIndex,+ prefix,+ configuration,+ declaredOutputSchemas,+ });+ }++ return schemaFieldsForItems(output?.items || [], { prefix });+}++export function schemaFieldsForNodeInput(+ runData,+ nodeName,+ {+ inputIndex = 0,+ prefix = "$json",+ node,+ sourceNode,+ outputIndex = 0,+ graph,+ pinnedItems,+ declaredOutputSchemas,+ } = {}+) {+ const { port } = inputPreviewPort(runData, nodeName, {+ inputIndex,+ node,+ sourceNode,+ outputIndex,+ pinnedItems,+ });+ if (!port) {+ if (latestRunWithOutput(runData, nodeName, { node })) {+ return [];+ }++ return declaredFieldsForNodeOutput(sourceNode, graph, {+ outputIndex,+ prefix,+ declaredOutputSchemas,+ });+ }++ if (portWasFullyCompacted(port)) {+ return declaredFieldsForNodeOutput(sourceNode, graph, {+ outputIndex,+ prefix,+ declaredOutputSchemas,+ });+ }++ return schemaFieldsForItems(port?.items || [], { prefix });+}++function portSummary(port, indexKey) {+ if (!port) {+ return null;+ }++ return {+ [indexKey]: port.index,+ itemCount: port.item_count ?? port.items?.length ?? 0,+ truncated: port.truncated === true,+ };+}++export function outputSummaryForNode(+ runData,+ nodeName,+ outputIndex = 0,+ { node } = {}+) {+ const run = latestRunWithOutput(runData, nodeName, { node });+ return portSummary(outputForRun(run, outputIndex), "outputIndex");+}++export function inputSummaryForNode(+ runData,+ nodeName,+ inputIndex = 0,+ { node, sourceNode, outputIndex = 0, pinnedItems } = {}+) {+ const { port, source } = inputPreviewPort(runData, nodeName, {+ inputIndex,+ node,+ sourceNode,+ outputIndex,+ pinnedItems,+ });+ const summary = portSummary(port, "inputIndex");+ if (summary && ["source_output", "pinned"].includes(source)) {+ summary.inputIndex = inputIndex;+ }+ return summary;+}++function combinedPortSummary(ports, itemCount) {+ if (!ports) {+ return null;+ }++ return {+ itemCount,+ truncated: ports.some((port) => port.truncated === true),+ };+}++function outputPreviewItems(outputs) {+ if (outputs.length <= 1) {+ return outputs[0]?.items || [];+ }++ return outputs+ .map((output) => output.items?.find((item) => item))+ .filter(Boolean);+}++function outputPreviewItemCount(outputs, items) {+ if (outputs.length <= 1) {+ return outputs[0]?.item_count ?? items.length;+ }++ return items.length ? 1 : 0;+}++export function outputPreviewForNode(+ runData,+ nodeName,+ { pinnedItems, node, graph, configuration, declaredOutputSchemas } = {}+) {+ if (Array.isArray(pinnedItems) && pinnedItems.length > 0) {+ return {+ summary: {+ itemCount: pinnedItems.length,+ truncated: false,+ pinned: true,+ },+ fields: schemaFieldsForItems(pinnedItems, { prefix: "$json" }),+ };+ }++ const run = latestRunWithOutput(runData, nodeName, { node });+ if (!run) {+ return {+ summary: null,+ fields: declaredFieldsForNodeOutput(node, graph, {+ configuration,+ declaredOutputSchemas,+ }),+ };+ }++ const outputs = run.outputs || [];+ const items = outputPreviewItems(outputs);+ const fields =+ items.length === 0 && outputs.some(portWasFullyCompacted)+ ? declaredFieldsForNodeOutput(node, graph, {+ configuration,+ declaredOutputSchemas,+ })+ : schemaFieldsForItems(items, { prefix: "$json" });++ return {+ summary: combinedPortSummary(+ outputs,+ outputPreviewItemCount(outputs, items)+ ),+ fields,+ };+}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-schema.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-schema.jsdeleted file mode 100644index 39b5439d0de..00000000000--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/data-schema.js+++ /dev/null@@ -1,558 +0,0 @@-import {- normalizeSourceOutputIndex,- normalizeTargetInputIndex,-} from "./graph-constants";--const TYPE_EXEMPLARS = {- string: "",- integer: 0,- number: 0,- boolean: false,- array: [],- object: {},- null: null,- unknown: null,-};--function classifyValue(value) {- if (Array.isArray(value)) {- return "array";- }-- if (value === null || value === undefined) {- return value === null ? "null" : "unknown";- }-- if (typeof value === "number") {- return "number";- }-- if (typeof value === "boolean") {- return "boolean";- }-- if (typeof value === "object") {- return "object";- }-- return "string";-}--function propertySegment(key) {- return /^[A-Za-z_$][\w$]*$/.test(key)- ? `.${key}`- : `[${JSON.stringify(key)}]`;-}--export function nodeOutputFirstJsonPath(nodeName, { outputIndex = 0 } = {}) {- const branchArg = outputIndex === 0 ? "" : outputIndex;- return `$(${JSON.stringify(nodeName)}).first(${branchArg}).json`;-}--export function nodeOutputLinkedItemJsonPath(nodeName) {- return `$(${JSON.stringify(nodeName)}).item.json`;-}--export function nodeOutputJsonPath(- runData,- nodeName,- { outputIndex = 0, node } = {}-) {- const run = latestRunWithOutput(runData, nodeName, { node });- const output = outputForRun(run, outputIndex);- const itemCount = output?.item_count ?? output?.items?.length ?? 0;-- if (itemCount === 1) {- return nodeOutputFirstJsonPath(nodeName, { outputIndex });- }-- return nodeOutputLinkedItemJsonPath(nodeName);-}--export function nodeOutputItemJsonPath(- nodeName,- { outputIndex = 0, itemIndex = "$itemIndex" } = {}-) {- return `$(${JSON.stringify(nodeName)}).all(${outputIndex})[${itemIndex}].json`;-}--export function inputFieldPrefixForConnection(- connection,- previousNode,- { primaryConnection, itemPrefix = "$json" } = {}-) {- if (!connection || connection === primaryConnection || !previousNode?.name) {- return itemPrefix;- }-- return nodeOutputItemJsonPath(previousNode.name, {- outputIndex: outputIndexForConnection(connection),- });-}--export function outputIndexForConnection(connection) {- return normalizeSourceOutputIndex(connection);-}--export function inputIndexForConnection(connection) {- return normalizeTargetInputIndex(connection);-}--function arraySegment(index) {- return `[${index}]`;-}--function compactObject(obj) {- return Object.fromEntries(- Object.entries(obj).filter(([, value]) => value !== undefined)- );-}--function representativeValue(values) {- const presentValue = values.find(- (value) => value !== undefined && value !== null- );- if (presentValue !== undefined) {- return presentValue;- }-- return values.includes(null) ? null : undefined;-}--function childValuesForObject(values, childKey) {- return values.map((value) =>- value && typeof value === "object" && !Array.isArray(value)- ? value[childKey]- : undefined- );-}--function childValuesForArray(values, index) {- return values.map((value) =>- Array.isArray(value) ? value[index] : undefined- );-}--function schemaFromValues(values, key, path) {- const value = representativeValue(values);- const type = classifyValue(value);- const field = compactObject({- key,- id: path,- type,- value,- });-- if (type === "object") {- const childKeys = new Set();- for (const candidate of values) {- if (- candidate &&- typeof candidate === "object" &&- !Array.isArray(candidate)- ) {- Object.keys(candidate).forEach((childKey) => childKeys.add(childKey));- }- }- field.children = [...childKeys].map((childKey) =>- schemaFromValues(- childValuesForObject(values, childKey),- childKey,- `${path}${propertySegment(childKey)}`- )- );- }-- if (type === "array") {- const childIndexes = new Set();- for (const candidate of values) {- if (Array.isArray(candidate)) {- candidate.forEach((_, index) => childIndexes.add(index));- }- }- field.children = [...childIndexes].map((index) =>- schemaFromValues(- childValuesForArray(values, index),- index.toString(),- `${path}${arraySegment(index)}`- )- );- }-- return field;-}--export function schemaFieldsForItems(items = [], { prefix = "$json" } = {}) {- const jsonItems = items- .map((item) => item?.json)- .filter((json) => json && typeof json === "object" && !Array.isArray(json));-- const keys = new Set();- jsonItems.forEach((json) =>- Object.keys(json).forEach((key) => keys.add(key))- );-- const jsonFields = [...keys].map((key) =>- schemaFromValues(- jsonItems.map((json) => json[key]),- key,- `${prefix}${propertySegment(key)}`- )- );-- return jsonFields;-}--export function exemplarFromFields(fields = []) {- const obj = Object.create(null);-- for (const field of fields) {- if (field.type === "object" && field.children?.length) {- obj[field.key] = exemplarFromFields(field.children);- } else if (field.type === "array" && field.children?.length) {- const child = field.children[0];- if (child?.type === "object") {- obj[field.key] = [exemplarFromFields(child.children || [])];- } else if (child?.value !== undefined) {- obj[field.key] = [child.value];- } else {- obj[field.key] = [TYPE_EXEMPLARS[child?.type] ?? TYPE_EXEMPLARS.string];- }- } else if (field.value !== undefined) {- obj[field.key] = field.value;- } else {- obj[field.key] = TYPE_EXEMPLARS[field.type] ?? TYPE_EXEMPLARS.string;- }- }-- return obj;-}--function nodeRunMatches(run, node) {- if (!node) {- return true;- }-- const nodeId = node.id ?? node.clientId;- if (run?.node_id && nodeId && run.node_id.toString() !== nodeId.toString()) {- return false;- }-- if (run?.node_type && node.type && run.node_type !== node.type) {- return false;- }-- return true;-}--function portSourceMatches(port, sourceNode, outputIndex) {- if (!sourceNode) {- return true;- }-- const source = port?.source;- if (!source) {- return false;- }-- return (- source.node_name === sourceNode.name &&- (source.output_index ?? 0).toString() === outputIndex.toString()- );-}--function latestSuccessfulRun(runData, nodeName, { node } = {}) {- const runs = (runData?.[nodeName] || []).filter(- (run) => run.status === "success" && nodeRunMatches(run, node)- );- if (!runs?.length) {- return null;- }-- return runs[runs.length - 1] || null;-}--export function latestRunWithOutput(runData, nodeName, { node } = {}) {- return latestSuccessfulRun(runData, nodeName, { node });-}--export function latestRunWithInput(- runData,- nodeName,- { inputIndex = 0, node, sourceNode, outputIndex = 0 } = {}-) {- const run = latestSuccessfulRun(runData, nodeName, { node });- if (!inputForRun(run, inputIndex, { sourceNode, outputIndex })) {- return null;- }-- return run;-}--function portForRun(run, portKey, portIndex = 0) {- if (!run) {- return null;- }-- return (run[portKey] || []).find((port) => port.index === portIndex) || null;-}--export function outputForRun(run, outputIndex = 0) {- return portForRun(run, "outputs", outputIndex);-}--export function inputForRun(- run,- inputIndex = 0,- { sourceNode, outputIndex = 0 } = {}-) {- const input = portForRun(run, "inputs", inputIndex);- if (!input || !portSourceMatches(input, sourceNode, outputIndex)) {- return null;- }-- return input;-}--function connectedSourceOutputForInput(- runData,- nodeName,- { node, sourceNode, outputIndex = 0 } = {}-) {- if (latestSuccessfulRun(runData, nodeName, { node }) || !sourceNode?.name) {- return null;- }-- const sourceRun = latestRunWithOutput(runData, sourceNode.name, {- node: sourceNode,- });- return outputForRun(sourceRun, outputIndex);-}--function inputPreviewPort(- runData,- nodeName,- { inputIndex = 0, node, sourceNode, outputIndex = 0 } = {}-) {- const run = latestRunWithInput(runData, nodeName, {- inputIndex,- node,- sourceNode,- outputIndex,- });- const input = inputForRun(run, inputIndex, { sourceNode, outputIndex });- if (input) {- return { port: input, source: "input" };- }-- const output = connectedSourceOutputForInput(runData, nodeName, {- node,- sourceNode,- outputIndex,- });- if (output) {- return { port: output, source: "source_output" };- }-- return { port: null, source: null };-}--export function schemaFieldsForNodeOutput(- runData,- nodeName,- { outputIndex = 0, prefix = "$json", node } = {}-) {- const run = latestRunWithOutput(runData, nodeName, { node });- const output = outputForRun(run, outputIndex);- return schemaFieldsForItems(output?.items || [], { prefix });-}--export function schemaFieldsForNodeInput(- runData,- nodeName,- { inputIndex = 0, prefix = "$json", node, sourceNode, outputIndex = 0 } = {}-) {- const { port } = inputPreviewPort(runData, nodeName, {- inputIndex,- node,- sourceNode,- outputIndex,- });- return schemaFieldsForItems(port?.items || [], { prefix });-}--function portSummary(port, indexKey) {- if (!port) {- return null;- }-- return {- [indexKey]: port.index,- itemCount: port.item_count ?? port.items?.length ?? 0,- truncated: port.truncated === true,- };-}--export function outputSummaryForNode(- runData,- nodeName,- outputIndex = 0,- { node } = {}-) {- const run = latestRunWithOutput(runData, nodeName, { node });- return portSummary(outputForRun(run, outputIndex), "outputIndex");-}--export function inputSummaryForNode(- runData,- nodeName,- inputIndex = 0,- { node, sourceNode, outputIndex = 0 } = {}-) {- const { port, source } = inputPreviewPort(runData, nodeName, {- inputIndex,- node,- sourceNode,- outputIndex,- });- const summary = portSummary(port, "inputIndex");- if (summary && source === "source_output") {- summary.inputIndex = inputIndex;- }- return summary;-}--function combinedPortSummary(ports, itemCount) {- if (!ports) {- return null;- }-- return {- itemCount,- truncated: ports.some((port) => port.truncated === true),- };-}--function outputPreviewItems(outputs) {- if (outputs.length <= 1) {- return outputs[0]?.items || [];- }-- return outputs- .map((output) => output.items?.find((item) => item))- .filter(Boolean);-}--function outputPreviewItemCount(outputs, items) {- if (outputs.length <= 1) {- return outputs[0]?.item_count ?? items.length;- }-- return items.length ? 1 : 0;-}--export function outputSchemaForNode(- runData,- nodeName,- { pinnedItems, node } = {}-) {- if (Array.isArray(pinnedItems) && pinnedItems.length > 0) {- return {- summary: {- itemCount: pinnedItems.length,- truncated: false,- pinned: true,- },- fields: schemaFieldsForItems(pinnedItems, { prefix: "$json" }),- };- }-- const run = latestRunWithOutput(runData, nodeName, { node });- if (!run) {- return { summary: null, fields: [] };- }-- const outputs = run.outputs || [];- const items = outputPreviewItems(outputs);-- return {- summary: combinedPortSummary(- outputs,- outputPreviewItemCount(outputs, items)- ),- fields: schemaFieldsForItems(items, { prefix: "$json" }),- };-}--export function inputConnectionsForNode(node, graph, visited = new Set()) {- if (!node) {- return [];- }-- return (graph.connections || [])- .filter(- (connection) =>- connection.targetClientId === node.clientId &&- connection.sourceClientId !== node.clientId &&- !visited.has(connection.sourceClientId)- )- .sort((left, right) => {- return (- inputIndexForConnection(left) - inputIndexForConnection(right) ||- left.sourceClientId.localeCompare(right.sourceClientId) ||- outputIndexForConnection(left) - outputIndexForConnection(right)- );- });-}--export function previousConnectionForNode(node, graph, visited = new Set()) {- const connections = inputConnectionsForNode(node, graph, visited);- return connections[0] || null;-}--export function previousNodeForConnection(connection, graph) {- if (!connection) {- return null;- }-- return (- (graph.nodes || []).find(- (node) => node.clientId === connection.sourceClientId- ) || null- );-}--export function ancestorOutputNodes(node, graph) {- const ancestors = [];- const visitedNodes = new Set(node ? [node.clientId] : []);- const seenAncestors = new Set();- const pendingConnections = inputConnectionsForNode(node, graph);-- while (pendingConnections.length) {- const connection = pendingConnections.shift();- const previous = previousNodeForConnection(connection, graph);- if (!previous) {- continue;- }-- const outputIndex = normalizeSourceOutputIndex(connection);- const key = `${previous.clientId}:${outputIndex}`;- if (!seenAncestors.has(key)) {- seenAncestors.add(key);- ancestors.push({- node: previous,- outputIndex,- });- }-- if (visitedNodes.has(previous.clientId)) {- continue;- }- visitedNodes.add(previous.clientId);- pendingConnections.push(- ...inputConnectionsForNode(previous, graph, visitedNodes)- );- }-- return ancestors;-}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/editor-session.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/editor-session.jsindex 663d8a3f2a3..5e375053785 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/editor-session.js+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/editor-session.js@@ -1,15 +1,15 @@import { tracked } from "@glimmer/tracking";import { ajax } from "discourse/lib/ajax";+import {+ normalizeSourceOutputIndex,+ normalizeTargetInputIndex,+} from "./graph-constants";import {inputForRun,latestRunWithInput,latestRunWithOutput,outputForRun,-} from "./data-schema";-import {- normalizeSourceOutputIndex,- normalizeTargetInputIndex,-} from "./graph-constants";+} from "./run-data";function compactObject(object) {return Object.fromEntries(diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/expression-paths.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/expression-paths.jsnew file mode 100644index 00000000000..405e030dada--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/expression-paths.js@@ -0,0 +1,60 @@+import {+ normalizeSourceOutputIndex,+ normalizeTargetInputIndex,+} from "./graph-constants";+import { latestRunWithOutput, outputForRun } from "./run-data";++export function nodeOutputFirstJsonPath(nodeName, { outputIndex = 0 } = {}) {+ const branchArg = outputIndex === 0 ? "" : outputIndex;+ return `$(${JSON.stringify(nodeName)}).first(${branchArg}).json`;+}++export function nodeOutputLinkedItemJsonPath(nodeName) {+ return `$(${JSON.stringify(nodeName)}).item.json`;+}++export function nodeOutputJsonPath(+ runData,+ nodeName,+ { outputIndex = 0, node, itemCount } = {}+) {+ const run = latestRunWithOutput(runData, nodeName, { node });+ const output = outputForRun(run, outputIndex);+ const effectiveItemCount =+ itemCount ?? output?.item_count ?? output?.items?.length ?? 0;++ if (effectiveItemCount === 1) {+ return nodeOutputFirstJsonPath(nodeName, { outputIndex });+ }++ return nodeOutputLinkedItemJsonPath(nodeName);+}++export function nodeOutputItemJsonPath(+ nodeName,+ { outputIndex = 0, itemIndex = "$itemIndex" } = {}+) {+ return `$(${JSON.stringify(nodeName)}).all(${outputIndex})[${itemIndex}].json`;+}++export function inputFieldPrefixForConnection(+ connection,+ previousNode,+ { primaryConnection, itemPrefix = "$json" } = {}+) {+ if (!connection || connection === primaryConnection || !previousNode?.name) {+ return itemPrefix;+ }++ return nodeOutputItemJsonPath(previousNode.name, {+ outputIndex: outputIndexForConnection(connection),+ });+}++export function outputIndexForConnection(connection) {+ return normalizeSourceOutputIndex(connection);+}++export function inputIndexForConnection(connection) {+ return normalizeTargetInputIndex(connection);+}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/node-types.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/node-types.jsindex 30558f87ccd..4cd67106325 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/node-types.js+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/node-types.js@@ -50,6 +50,12 @@ function resolveNodeType(nodeTypeOrIdentifier) {return { name: nodeTypeOrIdentifier, identifier: nodeTypeOrIdentifier };}+export const DEFAULT_TYPE_VERSION = "1.0";++export function typeVersionForNode(node) {+ return node ? (node.typeVersion ?? DEFAULT_TYPE_VERSION) : null;+}+export function resolveNodeTypeVersion(nodeTypeOrIdentifier,typeVersion = null@@ -60,15 +66,11 @@ export function resolveNodeTypeVersion(return nodeType;}- if (typeVersion && nodeType.versions?.[typeVersion]) {- return nodeType.versions[typeVersion];+ if (!typeVersion || !nodeType.versions) {+ return nodeType.latest || nodeType;}- if (nodeType.latest) {- return nodeType.latest;- }-- return nodeType;+ return nodeType.versions[typeVersion] || null;}export function nodeTypeVersion(nodeTypeOrIdentifier, typeVersion = null) {@@ -198,7 +200,7 @@ function indexedPort(port, index) {export function nodeTypeInputs(nodeTypeOrIdentifier, node = null) {const nodeType = resolveNodeTypeVersion(nodeTypeOrIdentifier,- node?.typeVersion+ typeVersionForNode(node));const inputs = nodeType?.inputs;@@ -262,7 +264,7 @@ export function nodeTypeHasConfigurationFields(const nodeType = resolveNodeTypeVersion(nodeTypeOrIdentifier,- node?.typeVersion+ typeVersionForNode(node));return (@@ -299,7 +301,11 @@ export function nodeTypePort(nodeTypeOrIdentifier, key, typeVersion = null) {}export function nodeTypePortLabel(nodeTypeOrIdentifier, key, node = null) {- const port = nodeTypePort(nodeTypeOrIdentifier, key, node?.typeVersion);+ const port = nodeTypePort(+ nodeTypeOrIdentifier,+ key,+ typeVersionForNode(node)+ );if (port.label_key) {return translatedOrNull(port.label_key) || port.label || key;@@ -309,7 +315,7 @@ export function nodeTypePortLabel(nodeTypeOrIdentifier, key, node = null) {}export function nodeTypeOutputKeys(nodeTypeOrIdentifier, node = null) {- return nodeTypePorts(nodeTypeOrIdentifier, node?.typeVersion).map(+ return nodeTypePorts(nodeTypeOrIdentifier, typeVersionForNode(node)).map((port) => port.key);}@@ -342,7 +348,7 @@ function runScopeFromCapability(runScope, node, nodeType) {export function nodeTypeRunScopeLabelKey(nodeTypeOrIdentifier, node = null) {const nodeType = resolveNodeTypeVersion(nodeTypeOrIdentifier,- node?.typeVersion+ typeVersionForNode(node));const runScope = runScopeFromCapability(nodeTypeCapabilities(nodeType).run_scope,diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/property-engine.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/property-engine.jsindex 063033f95d8..3c6c37bb931 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/property-engine.js+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/property-engine.js@@ -68,11 +68,11 @@ export function getPropertySchema(nodeTypes, nodeType, typeVersion = null) {}const versionedDefinition = resolveNodeTypeVersion(definition, typeVersion);- if (versionedDefinition?.properties) {- return versionedDefinition.properties;+ if (!versionedDefinition) {+ return {};}- return definition.properties || {};+ return versionedDefinition.properties || definition.properties || {};}export function normalizeSchema(schema = {}) {diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/run-data.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/run-data.jsnew file mode 100644index 00000000000..aaa0e5aeabe--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/run-data.js@@ -0,0 +1,144 @@+function nodeRunMatches(run, node) {+ if (!node) {+ return true;+ }++ const nodeId = node.id ?? node.clientId;+ if (run?.node_id && nodeId && run.node_id.toString() !== nodeId.toString()) {+ return false;+ }++ if (run?.node_type && node.type && run.node_type !== node.type) {+ return false;+ }++ return true;+}++function portSourceMatches(port, sourceNode, outputIndex) {+ if (!sourceNode) {+ return true;+ }++ const source = port?.source;+ if (!source) {+ return false;+ }++ return (+ source.node_name === sourceNode.name &&+ (source.output_index ?? 0).toString() === outputIndex.toString()+ );+}++function latestSuccessfulRun(runData, nodeName, { node } = {}) {+ const runs = (runData?.[nodeName] || []).filter(+ (run) => run.status === "success" && nodeRunMatches(run, node)+ );+ if (!runs?.length) {+ return null;+ }++ return runs[runs.length - 1] || null;+}++export function latestRunWithOutput(runData, nodeName, { node } = {}) {+ return latestSuccessfulRun(runData, nodeName, { node });+}++export function latestRunWithInput(+ runData,+ nodeName,+ { inputIndex = 0, node, sourceNode, outputIndex = 0 } = {}+) {+ const run = latestSuccessfulRun(runData, nodeName, { node });+ if (!inputForRun(run, inputIndex, { sourceNode, outputIndex })) {+ return null;+ }++ return run;+}++function portForRun(run, portKey, portIndex = 0) {+ if (!run) {+ return null;+ }++ return (run[portKey] || []).find((port) => port.index === portIndex) || null;+}++export function outputForRun(run, outputIndex = 0) {+ return portForRun(run, "outputs", outputIndex);+}++export function inputForRun(+ run,+ inputIndex = 0,+ { sourceNode, outputIndex = 0 } = {}+) {+ const input = portForRun(run, "inputs", inputIndex);+ if (!input || !portSourceMatches(input, sourceNode, outputIndex)) {+ return null;+ }++ return input;+}++function connectedSourceOutputForInput(+ runData,+ nodeName,+ { node, sourceNode, outputIndex = 0 } = {}+) {+ if (latestSuccessfulRun(runData, nodeName, { node }) || !sourceNode?.name) {+ return null;+ }++ const sourceRun = latestRunWithOutput(runData, sourceNode.name, {+ node: sourceNode,+ });+ return outputForRun(sourceRun, outputIndex);+}++export function inputPreviewPort(+ runData,+ nodeName,+ { inputIndex = 0, node, sourceNode, outputIndex = 0, pinnedItems } = {}+) {+ const run = latestRunWithInput(runData, nodeName, {+ inputIndex,+ node,+ sourceNode,+ outputIndex,+ });+ const input = inputForRun(run, inputIndex, { sourceNode, outputIndex });+ if (input) {+ return { port: input, source: "input" };+ }++ if (latestSuccessfulRun(runData, nodeName, { node })) {+ return { port: null, source: null };+ }++ if (Array.isArray(pinnedItems)) {+ return {+ port: {+ index: inputIndex,+ items: pinnedItems,+ item_count: pinnedItems.length,+ truncated: false,+ },+ source: "pinned",+ };+ }++ const output = connectedSourceOutputForInput(runData, nodeName, {+ node,+ sourceNode,+ outputIndex,+ });+ if (output) {+ return { port: output, source: "source_output" };+ }++ return { port: null, source: null };+}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-fields.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-fields.jsnew file mode 100644index 00000000000..a620aa4115b--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-fields.js@@ -0,0 +1,287 @@+function classifyValue(value) {+ if (Array.isArray(value)) {+ return "array";+ }++ if (value === null || value === undefined) {+ return value === null ? "null" : "unknown";+ }++ if (typeof value === "number") {+ return "number";+ }++ if (typeof value === "boolean") {+ return "boolean";+ }++ if (typeof value === "object") {+ return "object";+ }++ return "string";+}++function propertySegment(key) {+ return /^[A-Za-z_$][\w$]*$/.test(key)+ ? `.${key}`+ : `[${JSON.stringify(key)}]`;+}++function arraySegment(index) {+ return `[${index}]`;+}++function compactObject(obj) {+ return Object.fromEntries(+ Object.entries(obj).filter(([, value]) => value !== undefined)+ );+}++function schemaTypeForValue(value) {+ if (typeof value === "number" && Number.isInteger(value)) {+ return "integer";+ }++ return classifyValue(value);+}++function typeList(schema) {+ const types = Array.isArray(schema.type)+ ? schema.type.map(String)+ : schema.type+ ? [String(schema.type)]+ : [];+ if (types.length) {+ return types;+ }++ if (Object.hasOwn(schema, "const")) {+ return [schemaTypeForValue(schema.const)];+ }++ if (schema.properties) {+ return ["object"];+ }++ if (schema.items) {+ return ["array"];+ }++ return [];+}++function asSchemaObject(schema) {+ return schema && typeof schema === "object" && !Array.isArray(schema)+ ? schema+ : {};+}++function effectiveSchema(schema) {+ schema = asSchemaObject(schema);+ if (!Array.isArray(schema.anyOf)) {+ return schema;+ }++ const { anyOf, ...rest } = schema;+ return anyOf+ .map(effectiveSchema)+ .reduce((combined, branch) => displayUnion(combined, branch), rest);+}++function displayUnion(left, right) {+ if (!Object.keys(left).filter((key) => key !== "$schema").length) {+ return right;+ }++ const result = {};+ const types = [...new Set([...typeList(left), ...typeList(right)])];+ if (types.length) {+ result.type = types;+ }++ for (const key of ["const", "format", "description"]) {+ if (Object.hasOwn(left, key) && left[key] === right[key]) {+ result[key] = left[key];+ }+ }++ if (left.properties || right.properties) {+ result.properties = { ...(left.properties || {}) };+ for (const [name, propertySchema] of Object.entries(+ right.properties || {}+ )) {+ result.properties[name] = Object.hasOwn(result.properties, name)+ ? displayUnion(+ effectiveSchema(result.properties[name]),+ effectiveSchema(propertySchema)+ )+ : propertySchema;+ }+ }++ if (left.items || right.items) {+ result.items = displayUnion(+ effectiveSchema(left.items),+ effectiveSchema(right.items)+ );+ }++ return result;+}++function schemaMetadata(schema) {+ const types = typeList(schema);+ const nullable =+ types.includes("null") && types.some((type) => type !== "null");++ const nonNullTypes = [...new Set(types.filter((type) => type !== "null"))];+ if (nonNullTypes.includes("integer") && nonNullTypes.includes("number")) {+ nonNullTypes.splice(nonNullTypes.indexOf("integer"), 1);+ }++ let type;+ if (nonNullTypes.length > 1) {+ type = "unknown";+ } else {+ type = nonNullTypes[0] || (types.includes("null") ? "null" : "unknown");+ }++ return compactObject({+ type,+ value: Object.hasOwn(schema, "const") ? schema.const : undefined,+ format: schema.format,+ nullable: nullable || undefined,+ description: schema.description,+ });+}++function schemaField(schema, key, id) {+ const definition = effectiveSchema(schema);+ const metadata = schemaMetadata(definition);+ const field = { key, id, ...metadata };++ if (metadata.type === "object") {+ field.children = schemaPropertyFields(definition.properties, id);+ } else if (+ metadata.type === "array" &&+ definition.items &&+ typeof definition.items === "object" &&+ !Array.isArray(definition.items)+ ) {+ field.children = [+ schemaField(definition.items, "0", `${id}${arraySegment(0)}`),+ ];+ }++ return field;+}++function schemaPropertyFields(properties, parentId) {+ if (!properties || typeof properties !== "object") {+ return [];+ }++ return Object.entries(properties).map(([key, propertySchema]) =>+ schemaField(propertySchema, key, `${parentId}${propertySegment(key)}`)+ );+}++export function fieldsForSchema(schema = {}, { prefix = "$json" } = {}) {+ return schemaPropertyFields(effectiveSchema(schema).properties, prefix);+}++function representativeValue(values) {+ const presentValue = values.find(+ (value) => value !== undefined && value !== null+ );+ if (presentValue !== undefined) {+ return presentValue;+ }++ return values.includes(null) ? null : undefined;+}++function childValuesForObject(values, childKey) {+ return values.map((value) =>+ value && typeof value === "object" && !Array.isArray(value)+ ? value[childKey]+ : undefined+ );+}++function childValuesForArray(values, index) {+ return values.map((value) =>+ Array.isArray(value) ? value[index] : undefined+ );+}++function fieldFromValues(values, key, path) {+ const value = representativeValue(values);+ const type = classifyValue(value);+ const field = compactObject({+ key,+ id: path,+ type,+ value,+ });++ if (type === "object") {+ const childKeys = new Set();+ for (const candidate of values) {+ if (+ candidate &&+ typeof candidate === "object" &&+ !Array.isArray(candidate)+ ) {+ Object.keys(candidate).forEach((childKey) => childKeys.add(childKey));+ }+ }+ field.children = [...childKeys].map((childKey) =>+ fieldFromValues(+ childValuesForObject(values, childKey),+ childKey,+ `${path}${propertySegment(childKey)}`+ )+ );+ }++ if (type === "array") {+ const childIndexes = new Set();+ for (const candidate of values) {+ if (Array.isArray(candidate)) {+ candidate.forEach((_, index) => childIndexes.add(index));+ }+ }+ field.children = [...childIndexes].map((index) =>+ fieldFromValues(+ childValuesForArray(values, index),+ index.toString(),+ `${path}${arraySegment(index)}`+ )+ );+ }++ return field;+}++export function schemaFieldsForItems(items = [], { prefix = "$json" } = {}) {+ const jsonItems = items+ .map((item) => item?.json)+ .filter((json) => json && typeof json === "object" && !Array.isArray(json));++ const keys = new Set();+ jsonItems.forEach((json) =>+ Object.keys(json).forEach((key) => keys.add(key))+ );++ const jsonFields = [...keys].map((key) =>+ fieldFromValues(+ jsonItems.map((json) => json[key]),+ key,+ `${prefix}${propertySegment(key)}`+ )+ );++ return jsonFields;+}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-graph.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-graph.jsnew file mode 100644index 00000000000..f151c0109dd--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/schema-graph.js@@ -0,0 +1,392 @@+import {+ normalizeSourceOutputIndex,+ normalizeTargetInputIndex,+} from "./graph-constants";+import { resolveNodeTypeVersion, typeVersionForNode } from "./node-types";+import { fieldVisible } from "./property-engine";++const DRAFT_URI = "https://json-schema.org/draft/2020-12/schema";++function isUnknown(schema) {+ return !schema || !Object.keys(schema).length;+}++function isAnyOfWrapper(schema) {+ const keys = Object.keys(schema).filter((key) => key !== "$schema");+ return keys.length === 1 && keys[0] === "anyOf";+}++function anyOfBranches(schema) {+ return isAnyOfWrapper(schema) ? schema.anyOf : [schema];+}++function schemasEqual(left, right) {+ return JSON.stringify(left) === JSON.stringify(right);+}++function unionSchemas(schemas) {+ if (!schemas.length || schemas.some(isUnknown)) {+ return {};+ }++ const branches = [];+ for (const schema of schemas) {+ for (const branch of anyOfBranches(schema)) {+ if (!branches.some((existing) => schemasEqual(existing, branch))) {+ branches.push(branch);+ }+ }+ }++ return branches.length === 1+ ? branches[0]+ : { $schema: DRAFT_URI, anyOf: branches };+}++function isObjectSchema(schema) {+ const types = Array.isArray(schema.type)+ ? schema.type+ : schema.type+ ? [schema.type]+ : [];+ return types.includes("object");+}++function overlaySchemas(inputSchema, declaredSchema) {+ if (isUnknown(inputSchema)) {+ return declaredSchema;+ }++ if (isUnknown(declaredSchema)) {+ return inputSchema;+ }++ if (isAnyOfWrapper(inputSchema)) {+ return unionSchemas(+ inputSchema.anyOf.map((branch) => overlaySchemas(branch, declaredSchema))+ );+ }++ const merged = { ...inputSchema, ...declaredSchema };+ if (isObjectSchema(inputSchema) && isObjectSchema(declaredSchema)) {+ merged.properties = {+ ...(inputSchema.properties || {}),+ ...(declaredSchema.properties || {}),+ };++ const required = [+ ...new Set([+ ...(inputSchema.required || []),+ ...(declaredSchema.required || []),+ ]),+ ];+ if (required.length) {+ merged.required = required;+ } else {+ delete merged.required;+ }+ }++ return merged;+}++function resolvedOutputSchema(contract, inputSchema = {}) {+ switch (contract.mode) {+ case "passthrough":+ return inputSchema;+ case "union":+ return unionSchemas([inputSchema, contract.schema]);+ case "merge":+ return overlaySchemas(inputSchema, contract.schema);+ default:+ return contract.schema;+ }+}++function contractDefinition(contract = {}) {+ return {+ mode: contract.mode ?? "replace",+ schema:+ contract.schema &&+ typeof contract.schema === "object" &&+ !Array.isArray(contract.schema)+ ? contract.schema+ : {},+ };+}++function activeOutputContract(contract, configuration) {+ const variant = (contract.variants || []).find((candidate) =>+ fieldVisible({ display_options: candidate.display_options }, configuration)+ );+ if (variant) {+ return variant;+ }++ return fieldVisible(+ { display_options: contract.display_options },+ configuration+ )+ ? contract+ : {};+}++function nodeTypeDefinitionForNode(node, graph) {+ const definition = (graph?.nodeTypes || []).find(+ (candidate) =>+ candidate.name === node?.type || candidate.identifier === node?.type+ );+ if (!definition) {+ return null;+ }++ return resolveNodeTypeVersion(definition, typeVersionForNode(node));+}++function ownOutputContracts(node, graph, configuration) {+ const definition = nodeTypeDefinitionForNode(node, graph);+ if (!definition) {+ return [{ mode: "replace", schema: {} }];+ }++ const currentConfiguration = configuration ?? node.configuration ?? {};+ const serializedContracts = definition.output_contracts;+ const contracts = Array.isArray(serializedContracts)+ ? serializedContracts+ : [];+ const outputCount =+ contracts.length ||+ (definition.outputs || definition.ports || [null]).length;++ return Array.from({ length: outputCount }, (_, index) =>+ contractDefinition(+ activeOutputContract(contracts[index] || {}, currentConfiguration)+ )+ );+}++function nodeKey(node) {+ return node?.clientId ?? node?.id ?? node;+}++function connectionOrder(left, right) {+ return (+ normalizeTargetInputIndex(left) - normalizeTargetInputIndex(right) ||+ normalizeSourceOutputIndex(left) - normalizeSourceOutputIndex(right) ||+ String(left.sourceClientId).localeCompare(String(right.sourceClientId))+ );+}++export function resolveDeclaredOutputSchemas(+ graph,+ { configurationOverrides = new Map(), visited = new Set() } = {}+) {+ const nodes = (graph?.nodes || []).filter(+ (candidate) => !visited.has(nodeKey(candidate))+ );+ const nodesById = new Map(+ nodes.map((candidate) => [nodeKey(candidate), candidate])+ );++ const incomingByTarget = new Map();+ for (const connection of graph?.connections || []) {+ if (+ connection.sourceClientId === connection.targetClientId ||+ visited.has(connection.sourceClientId) ||+ !nodesById.has(connection.sourceClientId) ||+ !nodesById.has(connection.targetClientId)+ ) {+ continue;+ }++ const incoming = incomingByTarget.get(connection.targetClientId) || [];+ incoming.push(connection);+ incomingByTarget.set(connection.targetClientId, incoming);+ }+ for (const incoming of incomingByTarget.values()) {+ incoming.sort(connectionOrder);+ }++ const contractsByKey = new Map(+ nodes.map((candidate) => [+ nodeKey(candidate),+ ownOutputContracts(+ candidate,+ graph,+ configurationOverrides.get(nodeKey(candidate))+ ),+ ])+ );++ const outputSchemas = new Map();++ function inputSchemaFor(key) {+ const connections = incomingByTarget.get(key) || [];+ if (!connections.length) {+ return {};+ }++ const schemas = [];+ for (const connection of connections) {+ const sourceOutputs = outputSchemas.get(connection.sourceClientId);+ if (!sourceOutputs) {+ continue;+ }++ schemas.push(sourceOutputs[normalizeSourceOutputIndex(connection)] || {});+ }++ return schemas.length ? unionSchemas(schemas) : undefined;+ }++ function sweepUntilStable() {+ let changed = true;+ let sweeps = 0;++ while (changed) {+ if (++sweeps > nodes.length + 2) {+ throw new Error("Output schema graph did not converge");+ }++ changed = false;+ for (const candidate of nodes) {+ const key = nodeKey(candidate);+ const contracts = contractsByKey.get(key);+ let inputSchema = {};++ if (contracts.some(({ mode }) => mode !== "replace")) {+ inputSchema = inputSchemaFor(key);+ if (inputSchema === undefined) {+ continue;+ }+ }++ const resolved = contracts.map((contract) =>+ resolvedOutputSchema(contract, inputSchema)+ );+ if (+ !outputSchemas.has(key) ||+ !schemasEqual(outputSchemas.get(key), resolved)+ ) {+ changed = true;+ outputSchemas.set(key, resolved);+ }+ }+ }+ }++ sweepUntilStable();++ let promoted = false;+ for (const candidate of nodes) {+ const key = nodeKey(candidate);+ if (!outputSchemas.has(key)) {+ promoted = true;+ outputSchemas.set(+ key,+ contractsByKey.get(key).map(() => ({}))+ );+ }+ }+ if (promoted) {+ sweepUntilStable();+ }++ return outputSchemas;+}++export function outputSchemaForNode(+ node,+ graph,+ { configuration, outputIndex = 0, outputSchemas, visited = new Set() } = {}+) {+ if (!node) {+ return {};+ }++ const targetNodeKey = nodeKey(node);+ if (visited.has(targetNodeKey)) {+ return {};+ }++ if (!outputSchemas) {+ const nodes = graph?.nodes || [];+ const resolutionGraph = nodes.some(+ (candidate) => nodeKey(candidate) === targetNodeKey+ )+ ? graph+ : { ...graph, nodes: [...nodes, node] };+ const configurationOverrides = new Map();+ if (configuration !== undefined) {+ configurationOverrides.set(targetNodeKey, configuration);+ }+ outputSchemas = resolveDeclaredOutputSchemas(resolutionGraph, {+ configurationOverrides,+ visited,+ });+ }++ return outputSchemas.get(targetNodeKey)?.[outputIndex] || {};+}++export function inputConnectionsForNode(node, graph, visited = new Set()) {+ if (!node) {+ return [];+ }++ return (graph.connections || [])+ .filter(+ (connection) =>+ connection.targetClientId === node.clientId &&+ connection.sourceClientId !== node.clientId &&+ !visited.has(connection.sourceClientId)+ )+ .sort(connectionOrder);+}++export function previousNodeForConnection(connection, graph) {+ if (!connection) {+ return null;+ }++ return (+ (graph.nodes || []).find(+ (node) => node.clientId === connection.sourceClientId+ ) || null+ );+}++export function ancestorOutputNodes(node, graph) {+ const ancestors = [];+ const visitedNodes = new Set(node ? [node.clientId] : []);+ const seenAncestors = new Set();+ const pendingConnections = inputConnectionsForNode(node, graph);++ while (pendingConnections.length) {+ const connection = pendingConnections.shift();+ const previous = previousNodeForConnection(connection, graph);+ if (!previous) {+ continue;+ }++ const outputIndex = normalizeSourceOutputIndex(connection);+ const key = `${previous.clientId}:${outputIndex}`;+ if (!seenAncestors.has(key)) {+ seenAncestors.add(key);+ ancestors.push({+ node: previous,+ outputIndex,+ });+ }++ if (visitedNodes.has(previous.clientId)) {+ continue;+ }+ visitedNodes.add(previous.clientId);+ pendingConnections.push(+ ...inputConnectionsForNode(previous, graph, visitedNodes)+ );+ }++ return ancestors;+}diff --git a/plugins/discourse-workflows/app/jobs/regular/discourse_workflows/author_with_ai.rb b/plugins/discourse-workflows/app/jobs/regular/discourse_workflows/author_with_ai.rbindex a903c2270e2..074d689bae0 100644--- a/plugins/discourse-workflows/app/jobs/regular/discourse_workflows/author_with_ai.rb+++ b/plugins/discourse-workflows/app/jobs/regular/discourse_workflows/author_with_ai.rb@@ -12,7 +12,7 @@ module Jobs"For generic requests like 'when someone posts' or 'when anyone posts', trigger:post_created covers all regular posts, including first posts and replies. Do not ask to distinguish replies from topic starters unless the request explicitly says replies only or new topics only.","trigger:topic_closed exposes only the closed topic under topic.*. When a closed-topic workflow needs a first-post link, add action:topic with operation get and topic_id ={{ $json.topic.id }} immediately after the trigger. Use the exact fields returned by workflow_validate_patch for any first-post author data; do not assume post.trust_level is available.","Do not ask whether trust level is available for trigger:post_created or trigger:post_edited; it is available as user.trust_level.",- "Do not generate fallback chains for undocumented author aliases; use the exact post.* fields from the node catalog output_schema.",+ "Do not generate fallback chains for undocumented author aliases; use the exact post.* fields from the node catalog output_contracts.","trigger:user_added_to_group and trigger:user_removed_from_group expose the affected user under user.*, the selected group under group.*, and event metadata under membership.*. Use user.username for the affected username and membership.action to distinguish added vs removed if needed.","For named group membership checks, use workflow_resolve_entity to resolve the group, then use action:group with operation check_membership, group_id set to the resolved group id, and username ={{ $json.user.username }} when the input schema includes user.username, otherwise use the exact username field from the current input schema. It adds group_membership.in_group while preserving the original item fields. Do not use a Code node for simple group membership.","For personal messages, private messages, DMs, direct messages, or PM notifications, use action:send_personal_message with recipient_usernames or recipient_group_names as arrays, title, raw, and sender_username. Resolve named users with workflow_resolve_entity(kind: user), and named groups with workflow_resolve_entity(kind: group).",@@ -110,13 +110,13 @@ module Jobsdef authoring_context_instructionscontext_tools = {workflow_node_catalog:- "Call this with targeted queries for node parameters, output schemas, capabilities, and examples.",+ "Call this with targeted queries for node parameters, output contracts, capabilities, and examples.",workflow_ai_agent_catalog:"Call this before adding action:ai_agent nodes to find existing enabled AI agents to reuse. If none fit, propose create_ai_agent with name, description, and system_prompt.",workflow_graph_context:"Call this with workflow_id when you need the current graph nodes and connections.",workflow_validate_patch:- "Call this to dry-run candidate operations and inspect inferred node_schemas.",+ "Call this to dry-run candidate operations and inspect inferred node_fields.",workflow_script_context:"Call this before writing Code node JavaScript to inspect the runtime API and mode rules.",workflow_validate_script:diff --git a/plugins/discourse-workflows/app/services/discourse_workflows/node_type/list.rb b/plugins/discourse-workflows/app/services/discourse_workflows/node_type/list.rbindex 261c20c3989..801597918a1 100644--- a/plugins/discourse-workflows/app/services/discourse_workflows/node_type/list.rb+++ b/plugins/discourse-workflows/app/services/discourse_workflows/node_type/list.rb@@ -18,7 +18,6 @@ module DiscourseWorkflows.uniq(&:identifier).filter_map do |klass|identifier = klass.identifier- next unless klass.palette_visible?NodeTypeSerializer.new(identifier: identifier,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rbindex a87d50ae605..1f7bfd6ca5f 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb@@ -4,146 +4,6 @@ module DiscourseWorkflowsmodule Aimodule Toolsclass WorkflowNodeCatalog < Base- TOPIC_LIST_ITEM_SCHEMA = {- "topic" => "TopicListItemSerializer payload",- "topic.id" => "integer",- "topic.title" => "string",- "topic.fancy_title" => "string",- "topic.slug" => "string",- "topic.posts_count" => "integer",- "topic.category_id" => "integer",- "topic.tags" => "array<string>",- "topic.first_post_id" => "integer",- "topic.closed" => "boolean",- "topic.archived" => "boolean",- "topic.created_at" => "datetime",- "topic.last_posted_at" => "datetime",- "topic.bumped_at" => "datetime",- }.freeze-- POST_SCHEMA = {- "post" => "DiscourseWorkflows::PostSerializer payload",- "post.id" => "integer",- "post.raw" => "string",- "post.post_number" => "integer",- "post.reply_to_post_number" => "integer|null",- "post.topic_id" => "integer",- "post.topic_slug" => "string",- "post.topic_title" => "string",- "post.post_url" => "string",- "post.category_id" => "integer",- "post.category_name" => "string|null",- "post.user_id" => "integer",- "post.username" => "string",- "post.created_at" => "datetime",- "post.updated_at" => "datetime",- "post.excerpt" => "string",- "post.like_count" => "integer",- "post.reply_count" => "integer",- "post.score" => "number|null",- "post.tags" => "array<string>",- "post.upload_ids" => "array<integer>",- }.freeze-- WEBHOOK_POST_SCHEMA =- POST_SCHEMA.except(- "post.category_name",- "post.excerpt",- "post.like_count",- "post.tags",- "post.upload_ids",- ).merge("post" => "WebHookPostSerializer payload", "post.category_slug" => "string")-- USER_SCHEMA = {- "user" => "Basic safe user attributes",- "user.id" => "integer",- "user.username" => "string",- "user.name" => "string|null",- "user.trust_level" => "integer",- "user.trust_level_name" => "string",- "user.admin" => "boolean",- "user.moderator" => "boolean",- "user.staff" => "boolean",- }.freeze-- USER_ACTION_SCHEMA =- USER_SCHEMA.merge(- "user" => "Discourse user lookup/update payload",- "user.title" => "string|null",- "user.bio_raw" => "string|null",- "user.manual_locked_trust_level" => "integer|null",- "user.trust_level_locked" => "boolean",- "user.user_fields" => "object",- "user.groups" => "array<object>",- "user.groups[].id" => "integer",- "user.groups[].name" => "string",- "user.groups[].full_name" => "string|null",- "user.groups[].automatic" => "boolean",- ).freeze-- GROUP_MEMBERSHIP_SCHEMA = {- "group_membership" => "Group membership check result",- "group_membership.group_id" => "integer",- "group_membership.group_name" => "string",- "group_membership.user_id" => "integer",- "group_membership.username" => "string",- "group_membership.in_group" => "boolean",- }.freeze-- GROUP_SCHEMA = {- "group" => "Group involved in the membership event",- "group.id" => "integer",- "group.name" => "string",- "group.full_name" => "string|null",- "group.automatic" => "boolean",- }.freeze-- GROUP_MEMBERSHIP_EVENT_SCHEMA = {- "membership" => "Group membership event metadata",- "membership.automatic" => "boolean|null",- }.freeze-- USER_ADDED_TO_GROUP_SCHEMA =- USER_SCHEMA- .merge(GROUP_SCHEMA)- .merge(GROUP_MEMBERSHIP_EVENT_SCHEMA)- .merge("membership.action" => "\"added\"")- .freeze-- USER_REMOVED_FROM_GROUP_SCHEMA =- USER_SCHEMA- .merge(GROUP_SCHEMA)- .merge(GROUP_MEMBERSHIP_EVENT_SCHEMA)- .merge("membership.action" => "\"removed\"")- .freeze-- OUTPUT_SCHEMAS = {- "trigger:manual" => {- },- "trigger:topic_admin_button" => TOPIC_LIST_ITEM_SCHEMA,- "trigger:topic_created" => TOPIC_LIST_ITEM_SCHEMA.merge(POST_SCHEMA),- "trigger:post_created" => POST_SCHEMA.merge(TOPIC_LIST_ITEM_SCHEMA).merge(USER_SCHEMA),- "trigger:post_edited" => POST_SCHEMA.merge(TOPIC_LIST_ITEM_SCHEMA).merge(USER_SCHEMA),- "trigger:topic_closed" => TOPIC_LIST_ITEM_SCHEMA,- "trigger:user_added_to_group" => USER_ADDED_TO_GROUP_SCHEMA,- "trigger:user_removed_from_group" => USER_REMOVED_FROM_GROUP_SCHEMA,- "action:topic" => TOPIC_LIST_ITEM_SCHEMA.merge(WEBHOOK_POST_SCHEMA),- "action:topic_tags" => {- "topic_id" => "integer",- "tag_names" => "array<string>",- },- "action:post" => POST_SCHEMA,- "action:user" => USER_ACTION_SCHEMA,- "action:send_personal_message" => TOPIC_LIST_ITEM_SCHEMA.merge(POST_SCHEMA),- "action:send_chat_message" => {- "channel_id" => "integer",- "message" => "string",- },- "action:ai_agent" => {- "result" => "string",- },- }.freeze-EXAMPLES = {"action:code" => [{@@ -343,7 +203,7 @@ module DiscourseWorkflows{name: name,description:- "Lists available Discourse workflow node types with versions, parameters, capabilities, output schemas, and examples.",+ "Lists available Discourse workflow node types with versions, parameters, capabilities, output contracts, and examples.",parameters: [{name: "query",@@ -365,16 +225,6 @@ module DiscourseWorkflows"workflow_node_catalog"end- def self.output_schema_for(identifier, parameters: {}, input_schema: {})- parameters = parameters.respond_to?(:to_h) ? parameters.to_h.with_indifferent_access : {}-- if identifier.to_s == "action:group" && parameters[:operation].to_s == "check_membership"- return input_schema.merge(GROUP_MEMBERSHIP_SCHEMA)- end-- OUTPUT_SCHEMAS.fetch(identifier.to_s, {})- end-def invokereturn not_allowed_response if !ensure_can_manage_workflows!@@ -427,11 +277,28 @@ module DiscourseWorkflowsproperties: properties,credentials: json_safe(node_class.credentials),capabilities: json_safe(description[:capabilities] || {}),- output_schema: self.class.output_schema_for(identifier),+ output_contracts: serialized_output_contracts(node_class),}payload[:examples] = EXAMPLES[identifier] if include_examples && EXAMPLES.key?(identifier)payloadend++ def serialized_output_contracts(node_class)+ node_class.output_contracts.map do |contract|+ serialized_output_contract(contract).merge(+ variants:+ contract.fetch(:variants).map { |variant| serialized_output_contract(variant) },+ )+ end+ end++ def serialized_output_contract(contract)+ {+ fields: DiscourseAi::WorkflowSchemaFields.convert(contract.fetch(:schema)),+ mode: contract.fetch(:mode).to_s,+ display_options: json_safe(contract.fetch(:display_options)),+ }+ endendendenddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_script_context.rb b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_script_context.rbindex 42169f3c60a..001a3c18a18 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_script_context.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_script_context.rb@@ -104,7 +104,7 @@ module DiscourseWorkflowsreturn error_response("Workflow not found")end- @workflow_for_schema = workflow+ @workflow_for_shape = workflownodes = workflow&.nodes || []target_node = find_node(nodes, parameters[:target_node_id])upstream_node = find_node(nodes, parameters[:upstream_node_id])@@ -116,7 +116,7 @@ module DiscourseWorkflowsavailable_variables: AVAILABLE_VARIABLES,return_contract: RETURN_CONTRACT,mode_restrictions: MODE_RESTRICTIONS,- upstream_schema: node_schema(upstream_node),+ upstream_fields: node_fields(upstream_node),downstream_requirements: downstream_requirements(downstream_node),sample_input_items: sample_input_items(workflow, upstream_node),existing_code: existing_code(target_node),@@ -149,24 +149,36 @@ module DiscourseWorkflows}end- def node_schema(node)+ def node_fields(node)return nil if node.blank?+ schemas = infer_schema_from_pin_data(node)+ schemas =+ workflow_schema_resolution[:output_schemas][node["id"].to_s] || [] if schemas.nil?+ output_fields = schemas.map { |schema| DiscourseAi::WorkflowSchemaFields.convert(schema) }+{node_id: node["id"],node_name: node["name"],node_type: node["type"],- fields:- DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog::OUTPUT_SCHEMAS.fetch(- node["type"],- infer_schema_from_pin_data(node),- ),+ output_fields: output_fields,}end+ def workflow_schema_resolution+ @workflow_schema_resolution ||=+ DiscourseWorkflows::Schema.resolve_graph(+ @workflow_for_shape&.nodes,+ @workflow_for_shape&.connections,+ )+ end+def infer_schema_from_pin_data(node)- sample = @workflow_for_schema&.node_pin_data(node["name"])&.first- flatten_schema(sample&.dig("json") || {})+ pin_data = @workflow_for_shape&.node_pin_data(node["name"])+ return nil if pin_data.blank?++ sample = pin_data.first+ [DiscourseWorkflows::Schema.infer(sample&.dig("json") || {})]enddef downstream_requirements(node)@@ -202,29 +214,6 @@ module DiscourseWorkflowsDiscourseWorkflows::NodeData.parameters(node)["code"]end-- def flatten_schema(value, prefix = nil, result = {})- case value- when Hash- value.each do |key, child|- child_prefix = [prefix, key].compact.join(".")- flatten_schema(child, child_prefix, result)- end- when Array- result[prefix] = "array"- when Integer- result[prefix] = "integer"- when Float- result[prefix] = "number"- when TrueClass, FalseClass- result[prefix] = "boolean"- when NilClass- result[prefix] = "null"- else- result[prefix] = value.class.name.downcase- end- result- endendendenddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_validate_patch.rb b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_validate_patch.rbindex 316d826a82e..7c603bca5f1 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_validate_patch.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_validate_patch.rb@@ -8,7 +8,7 @@ module DiscourseWorkflows{name: name,description:- "Dry-runs a workflow patch and returns validation errors, normalized graph data, inferred node input/output schemas, proposed created resources, and a diff summary without saving anything.",+ "Dry-runs a workflow patch and returns validation errors, normalized graph data, inferred node input/output fields, proposed created resources, and a diff summary without saving anything.",json_schema: {type: "object",additionalProperties: false,@@ -52,11 +52,11 @@ module DiscourseWorkflows)if result[:valid]- schemas = node_schemas(result[:nodes], result[:connections])+ node_fields = resolved_node_fields(result[:nodes], result[:connections])graph_errors = connection_validation_errors(result[:nodes], result[:connections])- expression_errors = expression_validation_errors(result[:nodes], schemas)+ expression_errors = expression_validation_errors(result[:nodes], node_fields)else- schemas = []+ node_fields = []graph_errors = []expression_errors = []end@@ -72,7 +72,7 @@ module DiscourseWorkflowsexpression_errors: expression_errors,normalized_graph:result[:valid] ? { nodes: result[:nodes], connections: result[:connections] } : nil,- node_schemas: schemas,+ node_fields: node_fields,diff: result[:diff],created_resources: Array.wrap(result[:created_resources]),}@@ -80,43 +80,24 @@ module DiscourseWorkflowsprivate- PASS_THROUGH_NODE_TYPES = %w[condition:filter condition:if action:limit flow:wait].freezeCONDITION_NODE_TYPES = %w[condition:filter condition:if].freeze- JSON_REFERENCE_REGEX = /\$json(?:\.[A-Za-z_][A-Za-z0-9_]*)+/+ JSON_REFERENCE_REGEX =+ /+ \$json+ (?:+ \.[A-Za-z_$][A-Za-z0-9_$]*+ |+ \[(?:\d+|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\]+ )++ /xMAX_AVAILABLE_PATHS = 12- FIXED_OUTPUT_SCHEMAS = {- "action:send_chat_message" => {- "channel_id" => "integer",- "message" => "string",- },- }.freeze-- def node_schemas(nodes, connections)- connection_records =- DiscourseWorkflows::WorkflowDocument.connection_records(nodes, connections)- output_schemas = {}- input_schemas = {}-- (nodes.length + 1).times do- changed = false-- nodes.each do |node|- node_id = node["id"].to_s- next_input_schema = input_schema_for(node_id, connection_records, output_schemas)- next_output_schema = output_schema_for(node, next_input_schema)-- if input_schemas[node_id] != next_input_schema ||- output_schemas[node_id] != next_output_schema- input_schemas[node_id] = next_input_schema- output_schemas[node_id] = next_output_schema- changed = true- end- end-- break if !changed- end+ def resolved_node_fields(nodes, connections)+ resolution = DiscourseWorkflows::Schema.resolve_graph(nodes, connections)+ connection_records = resolution[:connection_records]+ input_schemas = resolution[:input_schemas]+ output_schemas = resolution[:output_schemas]nodes.map do |node|node_id = node["id"].to_s@@ -124,35 +105,13 @@ module DiscourseWorkflowsnode_id: node_id,node_name: node["name"],node_type: node["type"],- input_schema: expression_schema(input_schemas[node_id] || {}),- output_schema: expression_schema(output_schemas[node_id] || {}),+ input_fields: expression_fields(input_schemas[node_id] || []),+ output_fields: expression_fields(output_schemas[node_id] || []),input_sources: input_sources(node_id, nodes, connection_records, output_schemas),}endend- def input_schema_for(node_id, connection_records, output_schemas)- incoming = incoming_connections(node_id, connection_records)- return {} if incoming.blank?-- incoming.each_with_object({}) do |connection, result|- result.merge!(output_schemas[connection["source_node_id"].to_s] || {})- end- end-- def output_schema_for(node, input_schema)- catalog_schema =- DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog.output_schema_for(- node["type"],- parameters: node["parameters"] || {},- input_schema: input_schema,- )- return catalog_schema if catalog_schema.present?- return input_schema if PASS_THROUGH_NODE_TYPES.include?(node["type"].to_s)-- FIXED_OUTPUT_SCHEMAS.fetch(node["type"].to_s, {})- end-def input_sources(node_id, nodes, connection_records, output_schemas)nodes_by_id = nodes.index_by { |node| node["id"].to_s }incoming_connections(node_id, connection_records).map do |connection|@@ -163,7 +122,13 @@ module DiscourseWorkflowssource_node_type: source_node&.dig("type"),output_index: connection["source_output_index"],input_index: connection["target_input_index"],- schema: expression_schema(output_schemas[connection["source_node_id"].to_s] || {}),+ fields:+ expression_fields_for_schema(+ output_schemas.fetch(connection["source_node_id"].to_s, []).fetch(+ connection["source_output_index"].to_i,+ {},+ ),+ ),}endend@@ -202,21 +167,31 @@ module DiscourseWorkflowsendend- def expression_schema(schema)- schema.transform_keys { |key| key.to_s.start_with?("$json") ? key.to_s : "$json.#{key}" }+ def expression_fields_for_schema(schema)+ DiscourseAi::WorkflowSchemaFields+ .convert(schema)+ .transform_keys { |key| expression_path(key) }end- def expression_validation_errors(nodes, schemas)- schemas_by_node_id = schemas.index_by { |schema| schema[:node_id].to_s }+ def expression_fields(schemas)+ schemas.map { |schema| expression_fields_for_schema(schema) }+ end++ def expression_path(path)+ path.start_with?("[") ? "$json#{path}" : "$json.#{path}"+ end++ def expression_validation_errors(nodes, node_fields)+ fields_by_node_id = node_fields.index_by { |fields| fields[:node_id].to_s }nodes.flat_map do |node|- schema = schemas_by_node_id[node["id"].to_s] || {}- input_schema = schema[:input_schema] || {}- expression_errors_for_node(node, input_schema) + condition_configuration_errors(node)+ fields = fields_by_node_id[node["id"].to_s] || {}+ input_fields = Array(fields[:input_fields]).reduce({}, &:merge)+ expression_errors_for_node(node, input_fields) + condition_configuration_errors(node)endend- def expression_errors_for_node(node, input_schema)+ def expression_errors_for_node(node, input_fields)parameter_values(node["parameters"] || {}).flat_map do |path, value|next [] if !value.is_a?(String)@@ -229,7 +204,7 @@ module DiscourseWorkflowserrors << "#{node_label(node)} parameter #{path} references $json in an expression string without {{ }}. Use ={{ $json.field }} for whole-field values or =Text {{ $json.field }} for template strings."end- errors + unavailable_json_path_errors(node, path, value, input_schema)+ errors + unavailable_json_path_errors(node, path, value, input_fields)endend@@ -258,9 +233,26 @@ module DiscourseWorkflowserrors << "#{node_label(node)} condition #{condition_index} must set operator.operation."end- if !operator[:singleValue] && !condition.key?(:rightValue)+ operator_type = operator[:type].to_s+ operation = operator[:operation].to_s+ if operator[:type].present? &&+ !DiscourseWorkflows::Executor::FilterParameter.supported_types.include?(+ operator_type,+ )+ errors << "#{node_label(node)} condition #{condition_index} operator.type #{operator_type.inspect} is unsupported."+ elsif operator[:operation].present? &&+ !DiscourseWorkflows::Executor::FilterParameter.supported_operation?(+ operator_type,+ operation,+ )+ errors << "#{node_label(node)} condition #{condition_index} operator.operation #{operation.inspect} is invalid for #{operator_type.presence || "this type"}."+ end++ needs_right_value =+ DiscourseWorkflows::Executor::FilterParameter.operation_needs_value?(operation)+ if needs_right_value && !condition.key?(:rightValue)hint = condition.key?(:right) ? " Use rightValue instead of right." : ""- errors << "#{node_label(node)} condition #{condition_index} must set rightValue for #{operator[:operation].presence || "this"} comparisons.#{hint}"+ errors << "#{node_label(node)} condition #{condition_index} must set rightValue for #{operation} comparisons.#{hint}"elsif condition.key?(:rightValue) && invalid_condition_value?(condition[:rightValue])errors << "#{node_label(node)} condition #{condition_index} rightValue must be a scalar or expression string, not an object."end@@ -296,33 +288,41 @@ module DiscourseWorkflowsvalue.start_with?("=") && value.include?("$json") && !value.include?("{{")end- def unavailable_json_path_errors(node, parameter_path, value, input_schema)+ def unavailable_json_path_errors(node, parameter_path, value, input_fields)references = value.scan(JSON_REFERENCE_REGEX).uniq- return [] if references.blank? || input_schema.blank?+ return [] if references.blank? || input_fields.blank?references.filter_map do |reference|- next if schema_path_available?(reference, input_schema)+ next if field_path_available?(reference, input_fields)- "#{node_label(node)} parameter #{parameter_path} references #{reference}, but that path is not available in this node's input schema. Available paths: #{available_paths_summary(input_schema)}."+ "#{node_label(node)} parameter #{parameter_path} references #{reference}, but that path is not available in this node's input fields. Available paths: #{available_paths_summary(input_fields)}."endend- def schema_path_available?(reference, input_schema)- schema_paths = input_schema.keys.map(&:to_s)- return true if schema_paths.include?(reference)- return true if schema_paths.any? { |path| path.start_with?("#{reference}.") }-- segments = reference.split(".")- while segments.length > 2- segments.pop- return true if schema_paths.include?(segments.join("."))+ def field_path_available?(reference, input_fields)+ reference = normalize_json_reference(reference)+ input_fields.keys.any? do |path|+ path = normalize_json_reference(path.to_s)+ path == reference || descendant_path?(path, reference) ||+ descendant_path?(reference, path)end+ end++ def normalize_json_reference(reference)+ reference+ .gsub(/\[\d+\]/, "[]")+ .gsub(/\['((?:\\.|[^'\\])*)'\]/) do+ segment = Regexp.last_match(1).gsub(/\\(['\\])/, "\\1")+ "[#{JSON.generate(segment)}]"+ end+ end- false+ def descendant_path?(path, parent)+ path.start_with?("#{parent}.") || path.start_with?("#{parent}[")end- def available_paths_summary(input_schema)- paths = input_schema.keys.map(&:to_s).sort+ def available_paths_summary(input_fields)+ paths = input_fields.keys.map(&:to_s).sortsummary = paths.first(MAX_AVAILABLE_PATHS).join(", ")summary += ", ..." if paths.length > MAX_AVAILABLE_PATHSsummary.presence || "none"diff --git a/plugins/discourse-workflows/lib/discourse_workflows/ai_workflow_author.rb b/plugins/discourse-workflows/lib/discourse_workflows/ai_workflow_author.rbindex 362c0b406c5..6bb879f7d5f 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/ai_workflow_author.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/ai_workflow_author.rb@@ -58,9 +58,9 @@ module DiscourseWorkflows- When proposing a new AI agent, include a create_ai_agent operation before the action:ai_agent node that uses it. Reference the proposed agent with agent_id: { "$ref": "agent-client-id" } and set agent_name to the proposed agent name.- Include created AI agents in proposal assumptions or risks so admins know the draft creates a reusable agent record.- Use search_chat_channels before asking the admin to choose a chat channel or before setting action:send_chat_message channel_id. Never invent chat channel names, IDs, or clarification options. If search_chat_channels returns matches, ask using those exact channel names/IDs or use the named match. If it returns no matches, ask for a custom channel name/ID instead of suggesting made-up channels.- - Use workflow_validate_patch as a dry-run planning tool when drafting workflow changes. It does not save anything. For non-trivial workflows, query relevant node types with workflow_node_catalog, then call workflow_validate_patch after adding or connecting candidate nodes to inspect node_schemas for exact input/output field paths, then continue from those schemas.+ - Use workflow_validate_patch as a dry-run planning tool when drafting workflow changes. It does not save anything. For non-trivial workflows, query relevant node types with workflow_node_catalog, then call workflow_validate_patch after adding or connecting candidate nodes to inspect node_fields for exact input/output paths, then continue from those fields.- If workflow_validate_patch returns expression_errors or schema-path errors, repair the operations and call workflow_validate_patch again before returning a final proposal.- - Action nodes may replace the current item JSON. Always use the downstream node's input_schema from workflow_validate_patch rather than assuming trigger fields are still available after an action node.+ - Action nodes may replace the current item JSON. Always use the downstream node's input_fields from workflow_validate_patch rather than assuming trigger fields are still available after an action node.- When a downstream node needs fields from an earlier node after an action replaced the current item JSON, prefer previous-node expressions such as ={{ $("When a post is created").item.json.post.post_url }} or template references such as {{ $("When a post is created").item.json.post.username }}. Do not add a Code node only to copy trigger fields forward.- Before proposing a Code node, call workflow_script_context for the runtime API and call workflow_validate_script with the exact mode and code. If validation fails, repair the JavaScript and validate it again before returning a final proposal.- Do not stop after validating a partial graph; continue drafting until the complete workflow is represented in operations.@@ -90,11 +90,11 @@ module DiscourseWorkflows- For requests phrased as "when someone posts" or "when anyone posts", use trigger:post_created for all regular posts, including first posts and replies, unless the admin explicitly asks for only new topics or only replies. Do not ask to distinguish replies vs topic starters for a generic "posts" request.- For group membership checks, resolve the named group with workflow_resolve_entity(kind: "group", ...), then use action:group with operation "check_membership", group_id set to the resolved group id, and username ={{ $json.user.username }} when the input schema includes user.username, otherwise use the exact username field from the current input schema. The node adds $json.group_membership.in_group and keeps the original item fields. If the workflow needs different member and non-member paths, add condition:if after the group node and compare $json.group_membership.in_group to true or false.- For personal messages, private messages, DMs, direct messages, or PM-style notifications, use action:send_personal_message. Resolve named user recipients with workflow_resolve_entity(kind: "user") and set recipient_usernames to an array containing the resolved username. Resolve named group recipients with workflow_resolve_entity(kind: "group") and set recipient_group_names to an array containing the resolved group name, not the group id. Use leading-= template strings for title/raw when including dynamic post or topic links.- - When using an output_schema field, use the exact documented path (for example $json.user.trust_level, $json.user.username, $json.post.raw, or $json.post.post_url). Do not generate fallback chains for undocumented aliases such as $json.user.trustLevel or $json.trust_level.+ - When using an output_contracts schema, use the exact documented path (for example $json.user.trust_level, $json.user.username, $json.post.raw, or $json.post.post_url). Do not generate fallback chains for undocumented aliases such as $json.user.trustLevel or $json.trust_level.- Dynamic parameter values must start with =. Use ={{ $json.topic.id }} for a whole-field expression, and use template strings such as =Archived topic: {{ $json.topic.title }} (/t/{{ $json.topic.slug }}/{{ $json.topic.id }}) when mixing text and expressions.- Do not write bare {{ $json.field }} templates without the leading =; without = they are treated as literal text.- - For topic links from topic payloads, prefer /t/{{ $json.topic.slug }}/{{ $json.topic.id }} in a leading-= template string. Only use $json.post.post_url when the current node input_schema includes $json.post.post_url.- - Discourse trust levels are automatic groups named trust_level_0 through trust_level_4. Membership is cumulative: the trust_level_N group contains every user whose trust level is N or higher. When a workflow needs a trust-level check but the current input_schema has no trust_level field (for example after trigger:topic_closed or action:topic get, which expose post.username but not the author trust level), resolve the relevant trust_level_N group with workflow_resolve_entity and use action:group with operation "check_membership", the resolved group_id, and the available username field (such as $json.post.username) instead of asking for clarification or adding a Code node. For "TL1 or lower", check membership in trust_level_2 and branch on $json.group_membership.in_group being false; for "TL2 or higher", branch on it being true.+ - For topic links from topic payloads, prefer /t/{{ $json.topic.slug }}/{{ $json.topic.id }} in a leading-= template string. Only use $json.post.post_url when the current node input_fields includes $json.post.post_url.+ - Discourse trust levels are automatic groups named trust_level_0 through trust_level_4. Membership is cumulative: the trust_level_N group contains every user whose trust level is N or higher. When a workflow needs a trust-level check but the current input_fields has no trust_level field (for example after trigger:topic_closed or action:topic get, which expose post.username but not the author trust level), resolve the relevant trust_level_N group with workflow_resolve_entity and use action:group with operation "check_membership", the resolved group_id, and the available username field (such as $json.post.username) instead of asking for clarification or adding a Code node. For "TL1 or lower", check membership in trust_level_2 and branch on $json.group_membership.in_group being false; for "TL2 or higher", branch on it being true.- Do not assume $json.post.trust_level exists. The post payload never includes trust level; trust level is only available as $json.user.trust_level on triggers that expose a user object (such as trigger:post_created). For topic-only payloads, use the trust_level_N group membership approach above.- Do not ask whether the first post or topic author trust level is available until you have checked the current node schemas with workflow_validate_patch.- In condition nodes, each condition must use leftValue, operator, and rightValue keys. Do not use left/right keys. Use operator.type "number" for integer/number fields, "string" for string fields, and "boolean" for boolean fields.diff --git a/plugins/discourse-workflows/lib/discourse_workflows/executor/filter_parameter.rb b/plugins/discourse-workflows/lib/discourse_workflows/executor/filter_parameter.rbindex 1927a446a77..fc75e8a0593 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/executor/filter_parameter.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/executor/filter_parameter.rb@@ -3,13 +3,46 @@module DiscourseWorkflowsclass Executormodule FilterParameter+ OPERATION_DEFINITIONS = {+ "equals" => { types: %w[string number boolean].freeze, needs_value: true }.freeze,+ "notEquals" => { types: %w[string number boolean].freeze, needs_value: true }.freeze,+ "contains" => { types: %w[string array].freeze, needs_value: true }.freeze,+ "notContains" => { types: %w[string array].freeze, needs_value: true }.freeze,+ "empty" => { types: %w[string array].freeze, needs_value: false }.freeze,+ "notEmpty" => { types: %w[string array].freeze, needs_value: false }.freeze,+ "gt" => { types: %w[number].freeze, needs_value: true }.freeze,+ "lt" => { types: %w[number].freeze, needs_value: true }.freeze,+ "gte" => { types: %w[number].freeze, needs_value: true }.freeze,+ "lte" => { types: %w[number].freeze, needs_value: true }.freeze,+ "true" => { types: %w[boolean].freeze, needs_value: false }.freeze,+ "false" => { types: %w[boolean].freeze, needs_value: false }.freeze,+ }.freeze+ def self.supported_types+ OPERATION_DEFINITIONS.values.flat_map { |definition| definition.fetch(:types) }.uniq+ end++ def self.supported_operations(type)+ OPERATION_DEFINITIONS.filter_map do |operation, definition|+ operation if definition.fetch(:types).include?(type.to_s)+ end+ end++ def self.supported_operation?(type, operation)+ OPERATION_DEFINITIONS.fetch(operation.to_s, {}).fetch(:types, []).include?(type.to_s)+ end++ def self.operation_needs_value?(operation)+ OPERATION_DEFINITIONS.dig(operation.to_s, :needs_value)+ end+def self.execute_filter(conditions, combinator, options, resolver)- details = conditions.map { |c| execute_filter_condition(c, options, resolver) }+ details =+ conditions.map { |condition| execute_filter_condition(condition, options, resolver) }passed =if combinator == "or"- details.any? { |d| d["passed"] }+ details.any? { |detail| detail["passed"] }else- details.all? { |d| d["passed"] }+ details.all? { |detail| detail["passed"] }end{ "passed" => passed, "details" => details }@@ -21,7 +54,7 @@ module DiscourseWorkflowsoperator = condition.fetch("operator") { {} }type = operator.fetch("type") { "string" }operation = operator["operation"]- right = resolver.resolve(condition["rightValue"]) unless operator["singleValue"]+ right = resolver.resolve(condition["rightValue"]) if operation_needs_value?(operation)passed = evaluate_type(type, left, right, operation, options){@@ -35,6 +68,8 @@ module DiscourseWorkflowsenddef self.evaluate_type(type, left, right, operation, options)+ return false unless supported_operation?(type, operation)+case typewhen "string"evaluate_string(left, right, operation, options)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rbindex abc5895c9a8..ab337a8ab72 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb@@ -20,6 +20,7 @@ module DiscourseWorkflowsmax_nodes: nil,capabilities: {},+ output_contracts: [],palette_visible: true,available: true,}.freeze@@ -43,6 +44,7 @@ module DiscourseWorkflowsdef self.description(value = nil)if value+ @output_contracts = nil@description = DESCRIPTION_DEFAULTS.deep_merge(value.deep_symbolize_keys).freezeelse@description || DESCRIPTION_DEFAULTS@@ -113,6 +115,49 @@ module DiscourseWorkflowspropertiesend+ def self.output_schemas(configuration = {}, input_schemas: [])+ input_schema = Schema.union(*input_schemas.compact)++ active_output_contracts(configuration).map do |contract|+ Schema.resolve(+ contract.fetch(:schema),+ mode: contract.fetch(:mode),+ input_schema: input_schema,+ )+ end+ end++ def self.output_contracts+ @output_contracts ||=+ begin+ declarations = Array(description.fetch(:output_contracts))+ declarations = Array.new(ports.length) { {} } if declarations.empty?++ if declarations.length != ports.length+ raise ArgumentError,+ "#{identifier} declares #{declarations.length} output contracts for #{ports.length} outputs"+ end++ declarations.map { |contract| normalize_output_contract(contract) }+ end+ end++ EMPTY_OUTPUT_CONTRACT = { schema: {}, mode: :replace, display_options: {} }.freeze++ def self.active_output_contracts(configuration = {})+ output_contracts.map do |contract|+ active =+ contract+ .fetch(:variants)+ .find { |variant| Schema.visible?(variant.fetch(:display_options), configuration) }+ active ||= contract.except(:variants) if Schema.visible?(+ contract.fetch(:display_options),+ configuration,+ )+ active || EMPTY_OUTPUT_CONTRACT+ end+ end+def self.event_nameArray(description[:events]).firstend@@ -144,6 +189,31 @@ module DiscourseWorkflowsdescription.dig(:capabilities, key) == trueend+ def self.normalize_output_contract(contract)+ contract = contract.deep_symbolize_keys+ normalize_contract_fields(contract).merge(+ variants:+ Array(contract[:variants]).map do |variant|+ normalize_contract_fields(variant.deep_symbolize_keys)+ end,+ )+ end+ private_class_method :normalize_output_contract++ def self.normalize_contract_fields(contract)+ mode = contract.fetch(:mode, :replace).to_sym+ if Schema::MODES.exclude?(mode)+ raise ArgumentError, "Unknown output schema mode: #{mode.inspect}"+ end++ {+ schema: Schema.normalize(contract.fetch(:schema, {})),+ mode: mode,+ display_options: contract.fetch(:display_options, {}),+ }+ end+ private_class_method :normalize_contract_fields+def self.normalize_tag_names(value)Array.wrap(value)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_type_serializer.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_type_serializer.rbindex e53acbe885e..dfdd2e3df67 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_type_serializer.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_type_serializer.rb@@ -64,6 +64,8 @@ module DiscourseWorkflowscapabilities: klass.capabilities,ports: klass.ports,operations: klass.operations,+ output_contracts: serializable_output_contracts(klass),+ palette_visible: klass.palette_visible?,available: klass.available?,unavailable_reason_key: (klass.unavailable_reason_key unless klass.available?),metadata: metadata.presence,@@ -74,6 +76,26 @@ module DiscourseWorkflowsklass.webhooks.map { |webhook| webhook.except(:handler) }end+ def serializable_output_contracts(klass)+ contracts = klass.output_contracts+ if contracts.all? { |contract|+ contract[:schema].empty? && contract[:mode] == :replace && contract[:variants].empty?+ }+ return+ end++ contracts.map { |contract| serializable_output_contract(contract) }+ end++ def serializable_output_contract(contract)+ contract.slice(:schema, :mode, :display_options).merge(+ variants:+ contract+ .fetch(:variants)+ .map { |variant| variant.slice(:schema, :mode, :display_options) },+ )+ end+def load_options_metadata(klass, properties)return {} unless klass.respond_to?(:load_options_context)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/badge/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/badge/v1.rbindex baa83acd1e7..01fe0208e6e 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/badge/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/badge/v1.rb@@ -5,6 +5,24 @@ module DiscourseWorkflowsmodule Badgeclass V1 < NodeTypeOPERATIONS = %w[grant revoke].freeze+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "user_id" => {+ "type" => "integer",+ },+ "username" => {+ "type" => "string",+ },+ "badge_id" => {+ "type" => "integer",+ },+ "badge_name" => {+ "type" => "string",+ },+ },+ }.freezedescription(name: "action:badge",@@ -17,6 +35,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/filter/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/filter/v1.rbindex 7b253158ac8..8813306cd06 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/filter/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/filter/v1.rb@@ -18,6 +18,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [{ mode: :passthrough }, { mode: :passthrough }],properties: {combinator: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/group/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/group/v1.rbindex c49a98f922e..3805623241d 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/group/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/group/v1.rb@@ -17,6 +17,30 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [+ {+ variants: [+ {+ schema: Schema.merge(Schema::GROUP_SCHEMA, Schema::BASIC_USER_SCHEMA),+ display_options: {+ show: {+ operation: %w[add remove],+ },+ },+ },+ { schema: Schema::GROUP_SCHEMA, display_options: { show: { operation: ["get"] } } },+ {+ schema: Schema::GROUP_MEMBERSHIP_SCHEMA,+ mode: :merge,+ display_options: {+ show: {+ operation: ["check_membership"],+ },+ },+ },+ ],+ },+ ],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/if/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/if/v1.rbindex 2010b869e5e..67a882ed623 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/if/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/if/v1.rb@@ -18,6 +18,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [{ mode: :passthrough }, { mode: :passthrough }],properties: {combinator: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/limit/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/limit/v1.rbindex 51048701849..0c606a3c355 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/limit/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/limit/v1.rb@@ -15,6 +15,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "all_items",},+ output_contracts: [{ mode: :passthrough }],properties: {max_items: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/log/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/log/v1.rbindex 57d582c732d..36e5ece4220 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/log/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/log/v1.rb@@ -24,6 +24,7 @@ module DiscourseWorkflows},},},+ output_contracts: [{ mode: :passthrough }],properties: {mode: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/loop_over_items/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/loop_over_items/v1.rbindex b1a14e73e5f..9c1a7ad1593 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/loop_over_items/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/loop_over_items/v1.rb@@ -12,6 +12,7 @@ module DiscourseWorkflowscolor: "brown",},palette_visible: false,+ output_contracts: [{ mode: :passthrough }, { mode: :passthrough }],inputs: [{ key: "main", type: "main", required: true, multiple: true }],outputs: [{ key: "done", label_key: "discourse_workflows.branch.done" },diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/markdown_table/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/markdown_table/v1.rbindex 9e280382c73..90c87f77e88 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/markdown_table/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/markdown_table/v1.rb@@ -5,6 +5,15 @@ module DiscourseWorkflowsmodule MarkdownTableclass V1 < NodeTypeMAPPING_MODES = %w[manual auto].freeze+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "markdown" => {+ "type" => "string",+ },+ },+ }.freezedescription(name: "action:markdown_table",@@ -17,6 +26,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "all_items",},+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {mapping_mode: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/merge/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/merge/v1.rbindex 7aa1b7021a1..9ea6d0ab12a 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/merge/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/merge/v1.rb@@ -14,6 +14,23 @@ module DiscourseWorkflowscapabilities: {run_scope: "all_items",},+ output_contracts: [+ {+ mode: :passthrough,+ variants: [+ {+ display_options: {+ show: {+ mode: ["combine"],+ },+ hide: {+ resolve_clash: %w[prefer_first prefer_last],+ },+ },+ },+ ],+ },+ ],inputs: [{ key: "main", type: "main", display_name: "Input", required: false, multiple: true },],diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post/v1.rbindex 37482011fef..6faa539e0f5 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post/v1.rb@@ -52,6 +52,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [{ schema: Schema::POST_SCHEMA }],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_created/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_created/v1.rbindex 884aab255b2..07d4737988f 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_created/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_created/v1.rb@@ -15,6 +15,16 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:post_created],+ output_contracts: [+ {+ schema:+ Schema.merge(+ Schema::POST_SCHEMA,+ Schema::TOPIC_LIST_ITEM_SCHEMA,+ Schema::USER_SCHEMA,+ ),+ },+ ],properties: {topic_type: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_edited/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_edited/v1.rbindex 493ec23ac01..5da23261128 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_edited/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_edited/v1.rb@@ -15,6 +15,16 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:post_edited],+ output_contracts: [+ {+ schema:+ Schema.merge(+ Schema::POST_SCHEMA,+ Schema::TOPIC_LIST_ITEM_SCHEMA,+ Schema::USER_SCHEMA,+ ),+ },+ ],properties: {post_scope: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_moved/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_moved/v1.rbindex fcc39952626..d1bf79a250a 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_moved/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/post_moved/v1.rb@@ -4,6 +4,20 @@ module DiscourseWorkflowsmodule Nodesmodule PostMovedclass V1 < NodeType+ OUTPUT_SCHEMA =+ Schema.merge(+ Schema::POST_SCHEMA,+ Schema::TOPIC_LIST_ITEM_SCHEMA,+ {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "original_topic" =>+ Schema::TOPIC_LIST_ITEM_SCHEMA.fetch("properties").fetch("topic"),+ },+ },+ ).freeze+description(name: "trigger:post_moved",version: "1.0",@@ -13,6 +27,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:post_moved],+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {category_id: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/respond_to_webhook/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/respond_to_webhook/v1.rbindex c3ee99eaaa8..e10a79b76ba 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/respond_to_webhook/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/respond_to_webhook/v1.rb@@ -22,6 +22,7 @@ module DiscourseWorkflowsicon: "reply",color: "purple",},+ output_contracts: [{ mode: :passthrough }],properties: {response_type: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/reviewable_approved/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/reviewable_approved/v1.rbindex 1fb35fd18eb..3b188244c3e 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/reviewable_approved/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/reviewable_approved/v1.rb@@ -4,6 +4,46 @@ module DiscourseWorkflowsmodule Nodesmodule ReviewableApprovedclass V1 < NodeType+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "reviewable" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ "type" => {+ "type" => "string",+ },+ "status" => {+ "type" => "string",+ },+ "target_type" => {+ "type" => %w[string null],+ },+ "target_id" => {+ "type" => %w[integer null],+ },+ "topic_id" => {+ "type" => %w[integer null],+ },+ "category_id" => {+ "type" => %w[integer null],+ },+ "score" => {+ "type" => "number",+ },+ "created_at" => {+ "type" => %w[string null],+ "format" => "date-time",+ },+ },+ },+ },+ }.freeze+description(name: "trigger:reviewable_approved",version: "1.0",@@ -13,6 +53,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:reviewable_transitioned_to],+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: -> do{reviewable_types: {diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/schedule/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/schedule/v1.rbindex 89306b49cd8..7c642c76df4 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/schedule/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/schedule/v1.rb@@ -6,6 +6,28 @@ module DiscourseWorkflowsclass V1 < NodeTypeHOUR_OPTIONS = (0..23).to_a.freezeWEEKDAY_OPTIONS = [1, 2, 3, 4, 5, 6, 0].freeze+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "timestamp" => {+ "type" => "string",+ "format" => "date-time",+ },+ **%w[+ readable_date+ readable_time+ day_of_week+ year+ month+ day_of_month+ hour+ minute+ second+ timezone+ ].index_with { { "type" => "string" } },+ },+ }.freezedescription(name: "trigger:schedule",@@ -14,6 +36,7 @@ module DiscourseWorkflowsicon: "calendar-days",color: "orange",},+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {rule: {type: :fixed_collection,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/send_personal_message/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/send_personal_message/v1.rbindex 2311e45f46a..f65cbe99034 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/send_personal_message/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/send_personal_message/v1.rb@@ -15,6 +15,9 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [+ { schema: Schema.merge(Schema::TOPIC_LIST_ITEM_SCHEMA, Schema::POST_SCHEMA) },+ ],properties: {recipient_usernames: {type: :array,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/sort/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/sort/v1.rbindex 5967462657a..628fe895eeb 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/sort/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/sort/v1.rb@@ -17,6 +17,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "all_items",},+ output_contracts: [{ mode: :passthrough }],properties: {type: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/stale_topic/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/stale_topic/v1.rbindex 4798993f4d0..b0d22950022 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/stale_topic/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/stale_topic/v1.rb@@ -12,6 +12,7 @@ module DiscourseWorkflowscolor: "deep-orange",},group: "discourse_triggers",+ output_contracts: [{ schema: Schema::TOPIC_LIST_ITEM_SCHEMA }],properties: {hours: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/template/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/template/v1.rbindex 7a66b011cc0..5ef9d876122 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/template/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/template/v1.rb@@ -15,6 +15,15 @@ module DiscourseWorkflowsRUN_ONCE_FOR_ALL_ITEMS = "runOnceForAllItems"RUN_ONCE_FOR_EACH_ITEM = "runOnceForEachItem"+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "template" => {+ "type" => "string",+ },+ },+ }.freezedescription(name: "action:template",@@ -33,6 +42,7 @@ module DiscourseWorkflows},},},+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {mode: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic/v1.rbindex 630d65bd015..876656e7fec 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic/v1.rb@@ -9,6 +9,19 @@ module DiscourseWorkflowsDEFAULT_LIMIT = 30CUSTOM_FIELD_OPTIONS_LIMIT = 100+ TOPIC_POST_SCHEMA =+ Schema.entity(+ "post",+ Schema::POST_PROPERTIES.except(+ "category_name",+ "excerpt",+ "like_count",+ "tags",+ "upload_ids",+ ).merge("category_slug" => { "type" => "string" }),+ "WebHookPostSerializer payload",+ )+description(name: "action:topic",version: "1.0",@@ -20,6 +33,9 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [+ { schema: Schema.merge(Schema::TOPIC_LIST_ITEM_SCHEMA, TOPIC_POST_SCHEMA) },+ ],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_admin_button/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_admin_button/v1.rbindex 2ad011cf20f..f1bb35afda9 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_admin_button/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_admin_button/v1.rb@@ -26,6 +26,7 @@ module DiscourseWorkflowsmanually_triggerable: true,provides_current_user: true,},+ output_contracts: [{ schema: Schema::TOPIC_LIST_ITEM_SCHEMA }],)def initialize(topic)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_category_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_category_changed/v1.rbindex 3ed15fb0ccf..bbf55f31c76 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_category_changed/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_category_changed/v1.rb@@ -4,6 +4,20 @@ module DiscourseWorkflowsmodule Nodesmodule TopicCategoryChangedclass V1 < NodeType+ OUTPUT_SCHEMA =+ Schema.merge(+ Schema::TOPIC_LIST_ITEM_SCHEMA,+ {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "old_category_id" => {+ "type" => "integer",+ },+ },+ },+ ).freeze+description(name: "trigger:topic_category_changed",version: "1.0",@@ -13,6 +27,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:topic_category_changed],+ output_contracts: [{ schema: OUTPUT_SCHEMA }],)def initialize(topic, old_category)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_closed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_closed/v1.rbindex 567f8a994f5..4a494c357f5 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_closed/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_closed/v1.rb@@ -13,6 +13,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:topic_status_updated],+ output_contracts: [{ schema: Schema::TOPIC_LIST_ITEM_SCHEMA }],properties: {category_id: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_created/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_created/v1.rbindex 5d0252cb893..7f0a5529f34 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_created/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_created/v1.rb@@ -15,6 +15,9 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:topic_created],+ output_contracts: [+ { schema: Schema.merge(Schema::TOPIC_LIST_ITEM_SCHEMA, Schema::POST_SCHEMA) },+ ],properties: {topic_type: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tag_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tag_changed/v1.rbindex fc36dd58ed7..ab211c971d9 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tag_changed/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tag_changed/v1.rb@@ -4,6 +4,18 @@ module DiscourseWorkflowsmodule Nodesmodule TopicTagChangedclass V1 < NodeType+ TAG_LIST_SCHEMA = { "type" => "array", "items" => { "type" => "string" } }.freeze+ OUTPUT_SCHEMA =+ Schema.merge(+ Schema::TOPIC_LIST_ITEM_SCHEMA,+ {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" =>+ %w[old_tags new_tags added_tags removed_tags].index_with { TAG_LIST_SCHEMA },+ },+ ).freeze+description(name: "trigger:topic_tag_changed",version: "1.0",@@ -13,6 +25,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:topic_tags_changed],+ output_contracts: [{ schema: OUTPUT_SCHEMA }],properties: {category_id: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tags/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tags/v1.rbindex 7cabd5d7b32..57bb34000ad 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tags/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/topic_tags/v1.rb@@ -17,6 +17,25 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [+ {+ schema: {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "topic_id" => {+ "type" => "integer",+ },+ "tag_names" => {+ "type" => "array",+ "items" => {+ "type" => "string",+ },+ },+ },+ },+ },+ ],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user/v1.rbindex eec9c6e2cf7..a1f3107f974 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user/v1.rb@@ -24,6 +24,7 @@ module DiscourseWorkflowscapabilities: {run_scope: "per_item",},+ output_contracts: [{ schema: Schema::USER_ACTION_SCHEMA }],properties: {operation: {type: :options,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_added_to_group/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_added_to_group/v1.rbindex f3c51431ce2..0872655c0e2 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_added_to_group/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_added_to_group/v1.rb@@ -13,6 +13,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:user_added_to_group],+ output_contracts: [{ schema: Schema::USER_ADDED_TO_GROUP_SCHEMA }],properties: {group_id: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_removed_from_group/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_removed_from_group/v1.rbindex 8037017c10d..0187d812036 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_removed_from_group/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_removed_from_group/v1.rb@@ -13,6 +13,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:user_removed_from_group],+ output_contracts: [{ schema: Schema::USER_REMOVED_FROM_GROUP_SCHEMA }],properties: {group_id: {type: :integer,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_search/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_search/v1.rbindex 8f91dda3621..b06a45777af 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_search/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_search/v1.rb@@ -4,6 +4,16 @@ module DiscourseWorkflowsmodule Nodesmodule UserSearchclass V1 < NodeType+ OUTPUT_SCHEMA = {+ "$schema" => Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "query" => {+ "type" => "string",+ },+ },+ }.freeze+description(name: "trigger:user_search",version: "1.0",@@ -13,6 +23,7 @@ module DiscourseWorkflows},group: "discourse_triggers",events: [:user_search],+ output_contracts: [{ schema: OUTPUT_SCHEMA }],)def initialize(query, *)diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/wait/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/wait/v1.rbindex 86f6a04c246..74755131d70 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/wait/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/wait/v1.rb@@ -14,6 +14,32 @@ module DiscourseWorkflowscolor: "salmon",},outputs: %w[main],+ output_contracts: [+ {+ mode: :passthrough,+ variants: [+ {+ schema: Schema::WEBHOOK_REQUEST_SCHEMA,+ mode: :union,+ display_options: {+ show: {+ resume: ["webhook"],+ limit_wait_time: [true],+ timeout_amount: [{ condition: { exists: true } }],+ },+ },+ },+ {+ schema: Schema::WEBHOOK_REQUEST_SCHEMA,+ display_options: {+ show: {+ resume: ["webhook"],+ },+ },+ },+ ],+ },+ ],properties:lambda dowebhook_fields =diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/webhook/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/webhook/v1.rbindex 3de9f5ac853..04953154d6c 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/nodes/webhook/v1.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/webhook/v1.rb@@ -11,6 +11,7 @@ module DiscourseWorkflowsicon: "globe",color: "purple",},+ output_contracts: [{ schema: Schema::WEBHOOK_REQUEST_SCHEMA }],properties: {url_preview: {type: :custom,diff --git a/plugins/discourse-workflows/lib/discourse_workflows/schema.rb b/plugins/discourse-workflows/lib/discourse_workflows/schema.rbnew file mode 100644index 00000000000..890314bc655--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/schema.rb@@ -0,0 +1,420 @@+# frozen_string_literal: true++require "json_schemer"+require_relative "schema/graph_resolver"++module DiscourseWorkflows+ module Schema+ DRAFT_URI = "https://json-schema.org/draft/2020-12/schema"+ MODES = %i[replace passthrough merge union].freeze++ def self.entity(name, properties, description)+ {+ "$schema" => DRAFT_URI,+ "type" => "object",+ "properties" => {+ name => {+ "type" => "object",+ "description" => description,+ "properties" => properties,+ },+ },+ }.freeze+ end++ def self.document(properties)+ { "$schema" => DRAFT_URI, "type" => "object", "properties" => properties }.freeze+ end++ TOPIC_PROPERTIES = JSON.parse(<<~JSON).freeze+ {+ "id": { "type": "integer" },+ "title": { "type": "string" },+ "fancy_title": { "type": "string" },+ "slug": { "type": "string" },+ "posts_count": { "type": "integer" },+ "category_id": { "type": ["integer", "null"] },+ "tags": {+ "type": "array",+ "items": {+ "type": "object",+ "properties": {+ "id": { "type": "integer" },+ "name": { "type": "string" },+ "slug": { "type": "string" }+ }+ }+ },+ "first_post_id": { "type": "integer" },+ "closed": { "type": "boolean" },+ "archived": { "type": "boolean" },+ "created_at": { "type": "string", "format": "date-time" },+ "last_posted_at": { "type": ["string", "null"], "format": "date-time" },+ "bumped_at": { "type": ["string", "null"], "format": "date-time" }+ }+ JSON++ POST_PROPERTIES = JSON.parse(<<~JSON).freeze+ {+ "id": { "type": "integer" },+ "raw": { "type": "string" },+ "raw_truncated": { "type": "boolean" },+ "raw_original_length": { "type": "integer" },+ "cooked": { "type": "string" },+ "cooked_truncated": { "type": "boolean" },+ "cooked_original_length": { "type": "integer" },+ "post_number": { "type": "integer" },+ "post_type": { "type": "integer" },+ "reply_to_post_number": { "type": ["integer", "null"] },+ "topic_id": { "type": "integer" },+ "topic_slug": { "type": "string" },+ "topic_title": { "type": "string" },+ "post_url": { "type": "string" },+ "category_id": { "type": ["integer", "null"] },+ "category_name": { "type": ["string", "null"] },+ "user_id": { "type": "integer" },+ "username": { "type": "string" },+ "created_at": { "type": "string", "format": "date-time" },+ "updated_at": { "type": "string", "format": "date-time" },+ "excerpt": { "type": "string" },+ "like_count": { "type": "integer" },+ "reply_count": { "type": "integer" },+ "score": { "type": ["number", "null"] },+ "tags": { "type": "array", "items": { "type": "string" } },+ "upload_ids": { "type": "array", "items": { "type": "integer" } }+ }+ JSON++ BASIC_USER_PROPERTIES = JSON.parse(<<~JSON).freeze+ {+ "id": { "type": "integer" },+ "username": { "type": "string" },+ "name": { "type": ["string", "null"] },+ "avatar_template": { "type": "string" }+ }+ JSON++ USER_PROPERTIES = JSON.parse(<<~JSON).freeze+ {+ "id": { "type": "integer" },+ "username": { "type": "string" },+ "name": { "type": ["string", "null"] },+ "trust_level": { "type": "integer" },+ "trust_level_name": { "type": "string" },+ "admin": { "type": "boolean" },+ "moderator": { "type": "boolean" },+ "staff": { "type": "boolean" }+ }+ JSON++ BASIC_GROUP_PROPERTIES = JSON.parse(<<~JSON).freeze+ {+ "id": { "type": "integer" },+ "name": { "type": "string" },+ "full_name": { "type": ["string", "null"] },+ "automatic": { "type": "boolean" }+ }+ JSON++ GROUP_PROPERTIES = BASIC_GROUP_PROPERTIES.merge(JSON.parse(<<~JSON)).freeze+ {+ "user_count": { "type": "integer" },+ "title": { "type": ["string", "null"] },+ "visibility_level": { "type": "integer" },+ "members_visibility_level": { "type": "integer" },+ "mentionable_level": { "type": "integer" },+ "messageable_level": { "type": "integer" },+ "primary_group": { "type": "boolean" },+ "grant_trust_level": { "type": ["integer", "null"] },+ "public_admission": { "type": "boolean" },+ "public_exit": { "type": "boolean" },+ "allow_membership_requests": { "type": "boolean" },+ "default_notification_level": { "type": "integer" },+ "membership_request_template": { "type": ["string", "null"] },+ "can_see_members": { "type": "boolean" },+ "publish_read_state": { "type": "boolean" },+ "flair_url": { "type": ["string", "null"] },+ "flair_bg_color": { "type": ["string", "null"] },+ "flair_color": { "type": ["string", "null"] },+ "bio_cooked": { "type": ["string", "null"] },+ "bio_excerpt": { "type": ["string", "null"] }+ }+ JSON++ TOPIC_LIST_ITEM_SCHEMA = entity("topic", TOPIC_PROPERTIES, "TopicListItemSerializer payload")+ POST_SCHEMA = entity("post", POST_PROPERTIES, "DiscourseWorkflows::PostSerializer payload")+ BASIC_USER_SCHEMA = entity("user", BASIC_USER_PROPERTIES, "BasicUserSerializer payload")+ USER_SCHEMA = entity("user", USER_PROPERTIES, "Basic safe user attributes")+ USER_ACTION_SCHEMA =+ entity(+ "user",+ USER_PROPERTIES.merge(JSON.parse(<<~JSON)),+ {+ "title": { "type": ["string", "null"] },+ "bio_raw": { "type": ["string", "null"] },+ "manual_locked_trust_level": { "type": ["integer", "null"] },+ "trust_level_locked": { "type": "boolean" },+ "user_fields": { "type": "object" },+ "groups": {+ "type": "array",+ "items": {+ "type": "object",+ "properties": {+ "id": { "type": "integer" },+ "name": { "type": "string" },+ "full_name": { "type": ["string", "null"] },+ "automatic": { "type": "boolean" }+ }+ }+ }+ }+ JSON+ "Discourse user lookup/update payload",+ )+ BASIC_GROUP_SCHEMA =+ entity("group", BASIC_GROUP_PROPERTIES, "Group involved in the membership event")+ GROUP_SCHEMA = entity("group", GROUP_PROPERTIES, "WebHookGroupSerializer payload")+ GROUP_MEMBERSHIP_SCHEMA =+ entity("group_membership", JSON.parse(<<~JSON), "Group membership check result")+ {+ "group_id": { "type": "integer" },+ "group_name": { "type": "string" },+ "user_id": { "type": "integer" },+ "username": { "type": "string" },+ "in_group": { "type": "boolean" }+ }+ JSON+ WEBHOOK_REQUEST_SCHEMA = document(JSON.parse(<<~JSON))+ {+ "body": {},+ "headers": { "type": "object" },+ "params": { "type": "object" },+ "query": { "type": "object" },+ "method": { "type": "string" },+ "webhook_url": { "type": "string" },+ "raw_body": { "type": "string" }+ }+ JSON++ def self.group_membership_event(action)+ document(+ USER_SCHEMA+ .fetch("properties")+ .merge(BASIC_GROUP_SCHEMA.fetch("properties"))+ .merge(+ "membership" => {+ "type" => "object",+ "description" => "Group membership event metadata",+ "properties" => {+ "automatic" => {+ "type" => %w[boolean null],+ },+ "action" => {+ "const" => action,+ },+ },+ },+ ),+ )+ end++ USER_ADDED_TO_GROUP_SCHEMA = group_membership_event("added")+ USER_REMOVED_FROM_GROUP_SCHEMA = group_membership_event("removed")++ class << self+ def normalize(schema)+ return {} if schema.blank?++ raise ArgumentError, "Output schema must be a JSON Schema object" unless schema.is_a?(Hash)++ schema = schema.deep_stringify_keys+ unless schema["$schema"] == DRAFT_URI+ raise ArgumentError, "Output schema must declare JSON Schema Draft 2020-12"+ end+ unless JSONSchemer.valid_schema?(schema)+ raise ArgumentError, "Output schema is not valid JSON Schema Draft 2020-12"+ end++ schema+ end++ def merge(*schemas)+ schemas = schemas.flatten.map { |schema| stringify(schema) }.reject(&:empty?)+ schemas.reduce({}) { |combined, schema| merge_pair(combined, schema) }+ end++ def union(*schemas)+ schemas = schemas.flatten.map { |schema| stringify(schema) }+ return {} if schemas.empty? || schemas.any?(&:empty?)++ branches = schemas.flat_map { |schema| union_branches(schema) }.uniq+ return branches.first if branches.one?++ { "$schema" => DRAFT_URI, "anyOf" => branches }+ end++ def resolve(schema, mode:, input_schema: {})+ mode = mode&.to_sym+ raise ArgumentError, "Unknown output schema mode: #{mode.inspect}" if MODES.exclude?(mode)++ case mode+ when :passthrough+ input_schema+ when :union+ union(input_schema, schema)+ when :merge+ overlay(stringify(input_schema), stringify(schema))+ else+ schema+ end+ end++ def resolve_graph(nodes, connections)+ GraphResolver.call(nodes, connections)+ end++ def infer(value)+ return {} unless value.is_a?(Hash) && value.present?++ infer_value(value)+ end++ def visible?(display_options, configuration)+ display_options = normalize_options(display_options)+ configuration = normalize_options(configuration)+ show_rules = display_options["show"]+ hide_rules = display_options["hide"]++ return false if show_rules.present? && !matches_rules?(show_rules, configuration)+ return false if hide_rules.present? && matches_rules?(hide_rules, configuration)++ true+ end++ private++ def stringify(schema)+ schema.respond_to?(:to_h) ? schema.to_h.deep_stringify_keys : {}+ end++ def overlay(input_schema, declared_schema)+ return declared_schema if input_schema.empty?+ return input_schema if declared_schema.empty?++ if any_of_wrapper?(input_schema)+ return(+ union(+ *input_schema["anyOf"].map { |branch| overlay(stringify(branch), declared_schema) },+ )+ )+ end++ merged = input_schema.merge(declared_schema)+ return merged unless object_schema?(input_schema) && object_schema?(declared_schema)++ merged["properties"] = (input_schema["properties"] || {}).merge(+ declared_schema["properties"] || {},+ )++ required = Array(input_schema["required"]) | Array(declared_schema["required"])+ required.empty? ? merged.delete("required") : merged["required"] = required+ merged+ end++ def merge_pair(left, right)+ merged = left.merge(right)+ return merged unless object_schema?(left) && object_schema?(right)++ merged["properties"] = (left["properties"] || {}).merge(+ right["properties"] || {},+ ) do |_name, left_value, right_value|+ if object_schema?(left_value) && object_schema?(right_value)+ merge_pair(left_value, right_value)+ else+ right_value+ end+ end++ required = Array(left["required"]) | Array(right["required"])+ required.empty? ? merged.delete("required") : merged["required"] = required+ merged+ end++ def object_schema?(schema)+ schema.is_a?(Hash) && Array(schema["type"]).include?("object")+ end++ def union_branches(schema)+ any_of_wrapper?(schema) ? schema["anyOf"] : [schema]+ end++ def any_of_wrapper?(schema)+ (schema.keys - ["$schema"]) == ["anyOf"]+ end++ def infer_value(value)+ case value+ when Hash+ {+ "type" => "object",+ "properties" =>+ value.to_h.transform_keys(&:to_s).transform_values { |child| infer_value(child) },+ }+ when Array+ item_schemas = value.map { |child| infer_value(child) }.uniq+ schema = { "type" => "array" }+ if item_schemas.any?+ schema["items"] = item_schemas.one? ? item_schemas.first : { "anyOf" => item_schemas }+ end+ schema+ when Integer+ { "type" => "integer" }+ when Numeric+ { "type" => "number" }+ when TrueClass, FalseClass+ { "type" => "boolean" }+ when NilClass+ { "type" => "null" }+ else+ { "type" => "string" }+ end+ end++ def normalize_options(options)+ return {} if options.blank?++ options.to_h.deep_stringify_keys+ end++ def matches_rules?(rules, configuration)+ rules.all? do |field_name, expected|+ matches_rule?(expected, configuration[field_name.to_s])+ end+ end++ def matches_rule?(expected, value)+ conditions = expected.is_a?(Array) ? expected : [expected]+ conditions.any? { |condition| matches_condition?(condition, value) }+ end++ def matches_condition?(condition, value)+ operator = condition.is_a?(Hash) ? condition["condition"] : nil+ return condition == value if operator.blank?+ return value != operator["not"] if operator.key?("not")++ if operator.key?("exists")+ return operator["exists"] ? !empty_value?(value) : empty_value?(value)+ end++ false+ end++ def empty_value?(value)+ return true if value.nil? || value == ""+ return value.empty? if value.is_a?(Array)++ false+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/schema/graph_resolver.rb b/plugins/discourse-workflows/lib/discourse_workflows/schema/graph_resolver.rbnew file mode 100644index 00000000000..374393476a1--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/schema/graph_resolver.rb@@ -0,0 +1,156 @@+# frozen_string_literal: true++module DiscourseWorkflows+ module Schema+ class GraphResolver+ def self.call(nodes, connections)+ new(nodes, connections).call+ end++ def initialize(nodes, connections)+ @nodes = Array(nodes)+ @connection_records = WorkflowDocument.connection_records(@nodes, connections)+ @nodes_by_id = @nodes.index_by { |node| NodeData.read(node, "id").to_s }+ @node_classes =+ @nodes_by_id.transform_values do |node|+ Registry.find_node_type(+ NodeData.read(node, "type"),+ version: NodeData.type_version(node),+ )+ end+ @incoming_connections =+ @connection_records+ .reject { |record| record["source_node_id"].to_s == record["target_node_id"].to_s }+ .group_by { |record| record["target_node_id"].to_s }+ @incoming_connections.each_value do |records|+ records.sort_by! do |record|+ [+ record["target_input_index"].to_i,+ record["source_output_index"].to_i,+ record["source_node_id"].to_s,+ ]+ end+ end+ @input_schemas = {}+ @output_schemas = {}+ end++ def call+ sweep_until_stable+ sweep_until_stable if promote_unresolved_outputs+ resolve_remaining_inputs++ {+ input_schemas: @input_schemas,+ output_schemas: @output_schemas,+ connection_records: @connection_records,+ }+ end++ private++ def sweep_until_stable+ changed = true+ sweeps = 0++ while changed+ if (sweeps += 1) > @nodes.length + 2+ raise ArgumentError, "Output schema graph did not converge"+ end++ changed = false+ @nodes_by_id.each_key do |node_id|+ input_schemas, resolved = input_schemas_for(node_id)+ next unless resolved++ output_schemas = output_schemas_for(node_id, input_schemas)+ changed ||= @output_schemas[node_id] != output_schemas+ @input_schemas[node_id] = input_schemas+ @output_schemas[node_id] = output_schemas+ end+ end+ end++ def promote_unresolved_outputs+ unresolved = @nodes_by_id.keys.reject { |node_id| @output_schemas.key?(node_id) }+ unresolved.each do |node_id|+ @output_schemas[node_id] = Array.new(output_count(node_id)) { {} }+ end+ unresolved.any?+ end++ def resolve_remaining_inputs+ @nodes_by_id.each_key do |node_id|+ @input_schemas[node_id] ||= input_schemas_for(node_id).first+ end+ end++ def output_schemas_for(node_id, input_schemas)+ node_class = @node_classes[node_id]+ return [{}] unless node_class++ node_class.output_schemas(+ NodeData.parameters(@nodes_by_id.fetch(node_id)),+ input_schemas: input_schemas,+ )+ end++ def input_schemas_for(node_id)+ connections = Array(@incoming_connections[node_id])+ count = input_count(node_id, connections)+ return Array.new(count), true if connections.empty?++ schemas_by_index =+ Array.new(count) do |input_index|+ schemas =+ connections.filter_map do |connection|+ next if connection["target_input_index"].to_i != input_index++ source_outputs = @output_schemas[connection["source_node_id"].to_s]+ next if source_outputs.nil?++ source_outputs[connection["source_output_index"].to_i] || {}+ end++ Schema.union(*schemas) if schemas.any?+ end++ [+ schemas_by_index,+ schemas_by_index.any? { |schema| !schema.nil? } || replace_only?(node_id),+ ]+ end++ def replace_only?(node_id)+ node_class = @node_classes[node_id]+ return false unless node_class.respond_to?(:active_output_contracts)++ node_class+ .active_output_contracts(NodeData.parameters(@nodes_by_id.fetch(node_id)))+ .all? { |contract| contract.fetch(:mode).to_sym == :replace }+ end++ def output_count(node_id)+ node_class = @node_classes[node_id]+ return 1 unless node_class.respond_to?(:ports)++ node_class.ports(NodeData.parameters(@nodes_by_id.fetch(node_id))).length+ end++ def input_count(node_id, connections)+ node_class = @node_classes[node_id]+ declared_count =+ if node_class.respond_to?(:input_ports)+ node_class.input_ports(NodeData.parameters(@nodes_by_id.fetch(node_id))).length+ else+ 1+ end++ [+ declared_count,+ connections.map { |connection| connection["target_input_index"].to_i + 1 }.max.to_i,+ ].max+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_node_catalog_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_node_catalog_spec.rbindex 4315ec4d5b8..9aff4996df4 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_node_catalog_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_node_catalog_spec.rb@@ -15,12 +15,20 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do).invokeend+ def output_contract(nodes_by_type, type, output_index = 0)+ nodes_by_type.dig(type, :output_contracts, output_index)+ end++ def output_fields(nodes_by_type, type, output_index = 0)+ output_contract(nodes_by_type, type, output_index).fetch(:fields)+ end+it "exposes post author, topic link, and action output fields", :aggregate_failures doresult = invoke_toolnodes_by_type = result[:nodes].index_by { |node| node[:type] }expect(result[:status]).to eq("success")- expect(nodes_by_type.dig("trigger:topic_created", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "trigger:topic_created")).to include("post.user_id" => "integer","post.username" => "string","post.post_number" => "integer",@@ -28,11 +36,11 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do"post.post_url" => "string","post.upload_ids" => "array<integer>",)- expect(nodes_by_type.dig("trigger:topic_created", :output_schema)).not_to include(+ expect(output_fields(nodes_by_type, "trigger:topic_created")).not_to include("post.trust_level","user.trust_level",)- expect(nodes_by_type.dig("trigger:post_created", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "trigger:post_created")).to include("post.user_id" => "integer","post.username" => "string","post.post_number" => "integer",@@ -46,19 +54,19 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do"user.moderator" => "boolean","user.staff" => "boolean",)- expect(nodes_by_type.dig("trigger:post_created", :output_schema)).not_to include(+ expect(output_fields(nodes_by_type, "trigger:post_created")).not_to include("post.trust_level","post.admin","post.moderator","post.staff",)- expect(nodes_by_type.dig("trigger:post_edited", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "trigger:post_edited")).to include("post.id" => "integer","post.raw" => "string","user.trust_level" => "integer","user.trust_level_name" => "string",)- expect(nodes_by_type.dig("trigger:topic_closed", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "trigger:topic_closed")).to include("topic.id" => "integer","topic.title" => "string","topic.slug" => "string",@@ -69,7 +77,7 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do"trigger:user_added_to_group" => "\"added\"","trigger:user_removed_from_group" => "\"removed\"",}.each do |trigger_type, membership_action|- expect(nodes_by_type.dig(trigger_type, :output_schema)).to include(+ expect(output_fields(nodes_by_type, trigger_type)).to include("user.id" => "integer","user.username" => "string","user.trust_level" => "integer",@@ -81,26 +89,26 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do"membership.automatic" => "boolean|null",)end- expect(nodes_by_type.dig("action:topic", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "action:topic")).to include("topic.id" => "integer","topic.slug" => "string","topic.archived" => "boolean","post.post_url" => "string",)- expect(nodes_by_type.dig("action:topic", :output_schema)).not_to include(+ expect(output_fields(nodes_by_type, "action:topic")).not_to include("post.trust_level","post.upload_ids",)- expect(nodes_by_type.dig("action:topic_tags", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "action:topic_tags")).to include("topic_id" => "integer","tag_names" => "array<string>",)- expect(nodes_by_type.dig("action:post", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "action:post")).to include("post.id" => "integer","post.topic_id" => "integer","post.post_url" => "string",)- expect(nodes_by_type.dig("action:user", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "action:user")).to include("user.id" => "integer","user.username" => "string","user.bio_raw" => "string|null",@@ -109,15 +117,73 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowNodeCatalog do"user.trust_level_locked" => "boolean","user.user_fields" => "object","user.groups" => "array<object>",- "user.groups[].name" => "string",+ "user.groups[0].name" => "string",)- expect(nodes_by_type.dig("action:send_personal_message", :output_schema)).to include(+ expect(output_fields(nodes_by_type, "action:send_personal_message")).to include("topic.id" => "integer","topic.slug" => "string","post.id" => "integer","post.post_url" => "string",)- expect(nodes_by_type.dig("action:ai_agent", :output_schema)).to include("result" => "string")+ expect(output_contract(nodes_by_type, "action:group")[:variants]).to include(+ a_hash_including(+ mode: "replace",+ display_options: {+ "show" => {+ "operation" => %w[add remove],+ },+ },+ fields:+ a_hash_including(+ "group.id" => "integer",+ "group.name" => "string",+ "user.username" => "string",+ ),+ ),+ a_hash_including(+ mode: "replace",+ display_options: {+ "show" => {+ "operation" => ["get"],+ },+ },+ fields: a_hash_including("group.id" => "integer", "group.user_count" => "integer"),+ ),+ a_hash_including(+ mode: "merge",+ display_options: {+ "show" => {+ "operation" => ["check_membership"],+ },+ },+ fields: a_hash_including("group_membership.in_group" => "boolean"),+ ),+ )+ expect(output_contract(nodes_by_type, "flow:wait")[:variants]).to include(+ a_hash_including(+ mode: "replace",+ display_options: {+ "show" => {+ "resume" => ["webhook"],+ },+ },+ fields: a_hash_including("method" => "string", "body" => "unknown"),+ ),+ )+ expect(output_fields(nodes_by_type, "trigger:chat_message_created")).to include(+ "message.id" => "integer",+ "channel.id" => "integer",+ "user.id" => "integer",+ "user.username" => "string",+ "user.avatar_template" => "string",+ )+ expect(output_fields(nodes_by_type, "trigger:chat_message_created")).not_to include(+ "user.trust_level",+ "user.admin",+ "user.moderator",+ "user.staff",+ )+ expect(output_fields(nodes_by_type, "action:ai_agent")).to include("result" => "string")endit "matches broad multi-term catalog queries", :aggregate_failures dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_script_context_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_script_context_spec.rbnew file mode 100644index 00000000000..c161e855f55--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_script_context_spec.rb@@ -0,0 +1,96 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowScriptContext do+ fab!(:admin)+ fab!(:workflow) do+ graph =+ build_workflow_graph do |builder|+ builder.node "post-created", "trigger:post_created"+ builder.node "filter", "condition:filter"+ builder.node "code", "action:code"+ builder.connect "post-created", "filter"+ end++ Fabricate(+ :discourse_workflows_workflow,+ created_by: admin,+ **graph,+ pin_data: {+ "Code" => [{ "json" => { "custom" => { "id" => 1 }, "nothing" => nil } }],+ },+ )+ end++ def invoke_tool(upstream_node_id)+ context = DiscourseAi::Agents::BotContext.new(messages: [], user: admin)+ described_class.new(+ { workflow_id: workflow.id, upstream_node_id: upstream_node_id },+ bot_user: Discourse.system_user,+ llm: nil,+ context: context,+ ).invoke+ end++ it "uses the node's declared fields before it has run" do+ result = invoke_tool("post-created")++ expect(result.dig(:upstream_fields, :output_fields, 0)).to include(+ "post.id" => "integer",+ "user.username" => "string",+ )+ expect(result.dig(:upstream_fields, :output_fields, 0)).not_to include("pinned_only")+ end++ it "uses pinned fields before the node's declaration" do+ node_name = workflow.nodes.find { |node| node["id"] == "post-created" }["name"]+ workflow.update_node_pin_data!(node_name, [{ "json" => { "pinned_only" => true } }])++ result = invoke_tool("post-created")++ expect(result.dig(:upstream_fields, :output_fields, 0)).to eq("pinned_only" => "boolean")+ end++ it "keeps empty pinned JSON authoritative over the declaration" do+ node_name = workflow.nodes.find { |node| node["id"] == "post-created" }["name"]+ workflow.update_node_pin_data!(node_name, [{ "json" => {} }])++ result = invoke_tool("post-created")++ expect(result.dig(:upstream_fields, :output_fields)).to eq([{}])+ end++ it "resolves inherited fields for pass-through nodes" do+ result = invoke_tool("filter")++ expect(result.dig(:upstream_fields, :output_fields, 0)).to include(+ "post.id" => "integer",+ "user.username" => "string",+ )+ end++ it "infers fields from pin data when the node has no declaration" do+ result = invoke_tool("code")++ expect(result.dig(:upstream_fields, :output_fields, 0)).to eq(+ "custom" => "object",+ "custom.id" => "integer",+ "nothing" => "null",+ )+ end++ it "preserves unsafe property segments inferred from pin data" do+ workflow.update_node_pin_data!(+ "Code",+ [{ "json" => { "full-name" => "Ada", "a.b" => true, "a" => { "b" => 1 } } }],+ )++ result = invoke_tool("code")++ expect(result.dig(:upstream_fields, :output_fields, 0)).to eq(+ '["full-name"]' => "string",+ '["a.b"]' => "boolean",+ "a" => "object",+ "a.b" => "integer",+ )+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_validate_patch_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_validate_patch_spec.rbindex 9eb62656295..ba491c0c367 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_validate_patch_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/ai/tools/workflow_validate_patch_spec.rb@@ -13,7 +13,7 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do).invokeend- it "returns inferred schemas for a dry-run graph", :aggregate_failures do+ it "returns inferred fields for a dry-run graph", :aggregate_failures dooperations = [{op: "add_node",@@ -62,31 +62,33 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations.map(&:to_json))- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result).to include(status: "success", valid: true, errors: [])- expect(schemas_by_name.dig("When post is created", :output_schema)).to include(+ expect(fields_by_name.dig("When post is created", :output_fields, 0)).to include("$json.user.trust_level" => "integer","$json.user.trust_level_name" => "string","$json.post.raw" => "string","$json.post.post_url" => "string",)- expect(schemas_by_name.dig("When post is created", :output_schema)).not_to include(+ expect(fields_by_name.dig("When post is created", :output_fields, 0)).not_to include("$json.post.trust_level",)- expect(schemas_by_name.dig("Filter TL1 cake posts", :input_schema)).to include(+ expect(fields_by_name.dig("Filter TL1 cake posts", :input_fields, 0)).to include("$json.user.trust_level" => "integer","$json.post.raw" => "string","$json.post.post_url" => "string",)- expect(schemas_by_name.dig("Filter TL1 cake posts", :output_schema)).to include(+ expect(fields_by_name.dig("Filter TL1 cake posts", :output_fields, 0)).to include("$json.user.trust_level" => "integer","$json.post.raw" => "string","$json.post.post_url" => "string",)end- it "validates proposed AI agents and agent output schemas", :aggregate_failures do+ it "validates proposed AI agents and agent output fields", :aggregate_failures do+ SiteSetting.discourse_ai_enabled = true+operations = [{op: "create_ai_agent",@@ -174,7 +176,7 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations)- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result).to include(status: "success", valid: true, errors: [])expect(result[:created_resources]).to contain_exactly(@@ -184,15 +186,15 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do"name" => "Workflow sentiment agent",),)- expect(schemas_by_name.dig("Classify post", :output_schema)).to include(+ expect(fields_by_name.dig("Classify post", :output_fields, 0)).to include("$json.result" => "string",)- expect(schemas_by_name.dig("Log classification", :input_schema)).to include(+ expect(fields_by_name.dig("Log classification", :input_fields, 0)).to include("$json.result" => "string",)end- it "passes schemas through group checks into private messages", :aggregate_failures do+ it "passes fields through group checks into private messages", :aggregate_failures dooperations = [{op: "add_node",@@ -310,26 +312,25 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations)- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result).to include(status: "success", valid: true, errors: [])- expect(schemas_by_name.dig("Keep friend group posts", :input_schema)).to include(+ expect(fields_by_name.dig("Keep friend group posts", :input_fields, 0)).to include("$json.post.username" => "string","$json.post.post_url" => "string","$json.group_membership.in_group" => "boolean",)- expect(schemas_by_name.dig("DM admin", :input_schema)).to include(+ expect(fields_by_name.dig("DM admin", :input_fields, 0)).to include("$json.post.username" => "string","$json.post.post_url" => "string",)- expect(schemas_by_name.dig("DM admin", :output_schema)).to include(+ expect(fields_by_name.dig("DM admin", :output_fields, 0)).to include("$json.topic.id" => "integer","$json.post.post_url" => "string",)end- it "returns action output schemas and rejects unavailable downstream paths",- :aggregate_failures do+ it "returns action output fields and rejects unavailable downstream paths", :aggregate_failures dooperations = [{op: "add_node",@@ -409,17 +410,17 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations)- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result[:valid]).to eq(false)expect(result[:expression_errors]).to contain_exactly(a_string_including("Reply parameter topic_id references $json.topic.id"),)- expect(schemas_by_name.dig("Add tag", :output_schema)).to include(+ expect(fields_by_name.dig("Add tag", :output_fields, 0)).to include("$json.topic_id" => "integer","$json.tag_names" => "array<string>",)- expect(schemas_by_name.dig("Reply", :input_schema)).to include(+ expect(fields_by_name.dig("Reply", :input_fields, 0)).to include("$json.topic_id" => "integer","$json.tag_names" => "array<string>",)@@ -463,9 +464,20 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch dooperator: {operation: "lte",type: "number",+ singleValue: true,},right: 1,},+ {+ leftValue: true,+ operator: {+ operation: "true",+ type: "boolean",+ singleValue: false,+ },+ },+ { leftValue: 1, operator: { operation: "contains", type: "number" }, rightValue: 1 },+ { leftValue: 1, operator: { operation: "equals", type: "integer" }, rightValue: 1 },],},credentials: {@@ -488,6 +500,8 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch doexpect(result[:expression_errors]).to contain_exactly("Bad condition condition 1 must set leftValue. Use leftValue instead of left.","Bad condition condition 1 must set rightValue for lte comparisons. Use rightValue instead of right.",+ 'Bad condition condition 3 operator.operation "contains" is invalid for number.',+ 'Bad condition condition 4 operator.type "integer" is unsupported.',)end@@ -737,26 +751,26 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations)- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result).to include(status: "success", valid: true, errors: [])- expect(schemas_by_name.dig("Topic closed", :output_schema)).not_to include(+ expect(fields_by_name.dig("Topic closed", :output_fields, 0)).not_to include("$json.post.trust_level",)- expect(schemas_by_name.dig("Get closed topic", :output_schema)).to include(+ expect(fields_by_name.dig("Get closed topic", :output_fields, 0)).to include("$json.post.post_url" => "string","$json.post.user_id" => "integer",)- expect(schemas_by_name.dig("Get closed topic", :output_schema)).not_to include(+ expect(fields_by_name.dig("Get closed topic", :output_fields, 0)).not_to include("$json.post.trust_level",)- expect(schemas_by_name.dig("Keep known topic authors", :input_schema)).to include(+ expect(fields_by_name.dig("Keep known topic authors", :input_fields, 0)).to include("$json.post.post_url" => "string","$json.post.user_id" => "integer",)end- it "validates topic-closed schemas and dynamic template prefixes", :aggregate_failures do+ it "validates topic-closed fields and dynamic template prefixes", :aggregate_failures dooperations = [{op: "add_node",@@ -861,19 +875,126 @@ RSpec.describe DiscourseWorkflows::Ai::Tools::WorkflowValidatePatch do]result = invoke_tool(operations)- schemas_by_name = result[:node_schemas].index_by { |schema| schema[:node_name] }+ fields_by_name = result[:node_fields].index_by { |fields| fields[:node_name] }expect(result[:valid]).to eq(false)expect(result[:expression_errors]).to contain_exactly(a_string_including("Notify chat parameter message contains {{ }} expressions"),)- expect(schemas_by_name.dig("Topic closed", :output_schema)).to include(+ expect(fields_by_name.dig("Topic closed", :output_fields, 0)).to include("$json.topic.id" => "integer","$json.topic.slug" => "string",)- expect(schemas_by_name.dig("Notify chat", :input_schema)).to include(+ expect(fields_by_name.dig("Notify chat", :input_fields, 0)).to include("$json.topic.id" => "integer","$json.topic.slug" => "string",)end++ it "supports converted bracket and indexed array paths", :aggregate_failures do+ schema_node =+ Class.new(DiscourseWorkflows::NodeType) do+ description(+ name: "trigger:converted_schema_test",+ output_contracts: [+ {+ schema: {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "full-name" => {+ "type" => "string",+ },+ "a.b" => {+ "type" => "boolean",+ },+ "records" => {+ "type" => "array",+ "items" => {+ "type" => "object",+ "properties" => {+ "x y" => {+ "type" => "integer",+ },+ },+ },+ },+ },+ },+ },+ ],+ )+ end+ DiscoursePluginRegistry.register_discourse_workflows_node(schema_node, Plugin::Instance.new)+ DiscourseWorkflows::Registry.reset_indexes!+ operations = [+ {+ op: "add_node",+ client_id: "converted-output",+ node: {+ type: "trigger:converted_schema_test",+ typeVersion: "1.0",+ name: "Converted output",+ position: {+ x: 0,+ y: 0,+ },+ parameters: {+ },+ credentials: {+ },+ },+ },+ {+ op: "add_node",+ client_id: "consume-output",+ node: {+ type: "action:log",+ typeVersion: "1.0",+ name: "Consume output",+ position: {+ x: 280,+ y: 0,+ },+ parameters: {+ entries: {+ values: [+ { key: "name", value: "={{ $json['full-name'] }}" },+ { key: "literal_dot", value: '={{ $json["a.b"] }}' },+ { key: "array", value: '={{ $json.records[0]["x y"] }}' },+ { key: "missing", value: '={{ $json["missing-key"] }}' },+ ],+ },+ },+ credentials: {+ },+ },+ },+ {+ op: "add_connection",+ from: "converted-output",+ to: "consume-output",+ output_index: 0,+ input_index: 0,+ connection_type: "main",+ },+ ]++ result = invoke_tool(operations)+ output_fields =+ result[:node_fields].find { |fields| fields[:node_name] == "Converted output" }[+ :output_fields+ ].first++ expect(result[:expression_errors]).to contain_exactly(+ a_string_including('references $json["missing-key"]'),+ )+ expect(output_fields).to include(+ '$json["full-name"]' => "string",+ '$json["a.b"]' => "boolean",+ '$json.records[0]["x y"]' => "integer",+ )+ ensure+ unregister_workflow_nodes(schema_node)+ endenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/filter_parameter_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/filter_parameter_spec.rbindex f8ca4d1ca2a..337f9edf5dc 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/filter_parameter_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/filter_parameter_spec.rb@@ -45,6 +45,89 @@ RSpec.describe DiscourseWorkflows::Executor::FilterParameter do],)end++ it "resolves rightValue for value operations regardless of singleValue" do+ resolved_values = []+ tracking_resolver =+ Class+ .new do+ define_method(:initialize) { |values| @values = values }++ define_method(:resolve) do |value|+ @values << value+ value+ end+ end+ .new(resolved_values)++ result =+ described_class.execute_filter(+ [+ {+ "leftValue" => "closed",+ "rightValue" => "closed",+ "operator" => {+ "type" => "string",+ "operation" => "equals",+ "singleValue" => true,+ },+ },+ ],+ "and",+ {},+ tracking_resolver,+ )++ expect(result["passed"]).to eq(true)+ expect(resolved_values).to eq(%w[closed closed])+ end++ it "does not resolve rightValue for single-value operations regardless of singleValue" do+ resolved_values = []+ tracking_resolver =+ Class+ .new do+ define_method(:initialize) { |values| @values = values }++ define_method(:resolve) do |value|+ @values << value+ value+ end+ end+ .new(resolved_values)++ result =+ described_class.execute_filter(+ [+ {+ "leftValue" => true,+ "rightValue" => "must-not-resolve",+ "operator" => {+ "type" => "boolean",+ "operation" => "true",+ "singleValue" => false,+ },+ },+ ],+ "and",+ {},+ tracking_resolver,+ )++ expect(result["passed"]).to eq(true)+ expect(resolved_values).to eq([true])+ end+ end++ describe ".supported_operation?" do+ it "uses the runtime type and operation contract" do+ expect(described_class.supported_operation?("number", "gte")).to eq(true)+ expect(described_class.supported_operation?("number", "contains")).to eq(false)+ expect(described_class.supported_operation?("integer", "equals")).to eq(false)+ expect(described_class.operation_needs_value?("equals")).to eq(true)+ expect(described_class.operation_needs_value?("true")).to eq(false)+ expect(described_class.operation_needs_value?("unknown")).to be_nil+ endenddescribe ".evaluate_type" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rbindex 2cbea60ccb7..68184aedc4a 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor_spec.rb@@ -686,12 +686,7 @@ RSpec.describe DiscourseWorkflows::Executor doDiscourseWorkflows::Registry.reset_indexes!end- after do- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |h|- h[:value] == unavailable_node_class- end- DiscourseWorkflows::Registry.reset_indexes!- end+ after { unregister_workflow_nodes(unavailable_node_class) }it "passes data through and records a skipped step" dograph =@@ -766,12 +761,7 @@ RSpec.describe DiscourseWorkflows::Executor doDiscourseWorkflows::Registry.reset_indexes!end- after do- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [v1_node_class, v2_node_class].include?(entry[:value])- end- DiscourseWorkflows::Registry.reset_indexes!- end+ after { unregister_workflow_nodes(v1_node_class, v2_node_class) }it "dispatches execution to the saved node type version" dograph =@@ -854,15 +844,12 @@ RSpec.describe DiscourseWorkflows::Executor doendafter do- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [- raw_array_node_class,- named_outputs_node_class,- malformed_array_node_class,- oversized_output_node_class,- ].include?(entry[:value])- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(+ raw_array_node_class,+ named_outputs_node_class,+ malformed_array_node_class,+ oversized_output_node_class,+ )endit "accepts positional output arrays" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/match_node_output_schema_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/match_node_output_schema_spec.rbnew file mode 100644index 00000000000..6d7df061b47--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/match_node_output_schema_spec.rb@@ -0,0 +1,113 @@+# frozen_string_literal: true++RSpec.describe RSpec::Matchers, "#match_node_output_schema" do+ let(:node_class) do+ Class.new do+ def self.name+ "OutputSchemaTestNode"+ end++ def self.output_schemas(_configuration = {}, input_schemas: [])+ [+ {+ "type" => "object",+ "properties" => {+ "profile" => {+ "type" => "object",+ "properties" => {+ "name" => {+ "type" => "string",+ },+ },+ "required" => ["name"],+ "additionalProperties" => false,+ },+ },+ "required" => ["profile"],+ "additionalProperties" => false,+ },+ ]+ end+ end+ end++ it "accepts output with nested symbol keys" do+ output = { profile: { name: "Ada" } }++ expect(output).to match_node_output_schema(node_class)+ end++ it "reports validation details and their schema pointers" do+ output = { profile: { name: 42 } }++ expect do expect(output).to match_node_output_schema(node_class) end.to raise_error(+ RSpec::Expectations::ExpectationNotMetError,+ ) { |error|+ expect(error.message).to include(+ "expected output to match OutputSchemaTestNode's output schema",+ "property '/profile/name' is not of type: string",+ "[schema: /properties/profile/properties/name]",+ )+ }+ end++ it "rejects nodes that resolve an empty output schema" do+ empty_schema_node =+ Class.new do+ def self.name+ "EmptyOutputSchemaTestNode"+ end++ def self.output_schemas(_configuration = {}, input_schemas: [])+ [{}]+ end+ end+ output = {}++ expect do expect(output).to match_node_output_schema(empty_schema_node) end.to raise_error(+ RSpec::Expectations::ExpectationNotMetError,+ "expected EmptyOutputSchemaTestNode to resolve a concrete output schema, but it resolved {}",+ )+ end++ it "forwards the configuration and input schema when resolving the output schema" do+ contextual_node =+ Class.new do+ def self.output_schemas(configuration = {}, input_schemas: [])+ property = configuration.fetch("property")+ property_type = input_schemas.fetch(0).fetch("type")++ [+ {+ "type" => "object",+ "properties" => {+ property => {+ "type" => property_type,+ },+ },+ "required" => [property],+ "additionalProperties" => false,+ },+ ]+ end+ end+ configuration = { "property" => "count" }+ input_schema = { "type" => "integer" }+ output = { count: 2 }++ expect(output).to match_node_output_schema(+ contextual_node,+ configuration: configuration,+ input_schemas: [input_schema],+ )+ end++ it "rejects non-Hash output" do+ output = [{ profile: { name: "Ada" } }]++ expect do expect(output).to match_node_output_schema(node_class) end.to raise_error(+ RSpec::Expectations::ExpectationNotMetError,+ "expected node output to be a Hash, got Array",+ )+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/node_output_contracts_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_output_contracts_spec.rbnew file mode 100644index 00000000000..1a5acd7dbcb--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_output_contracts_spec.rb@@ -0,0 +1,100 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::NodeType do+ let(:input_schema) do+ {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "string",+ },+ },+ }+ end++ it "preserves declarations through nodes that only forward or reorder items" do+ node_classes = [+ DiscourseWorkflows::Nodes::Log::V1,+ DiscourseWorkflows::Nodes::Sort::V1,+ DiscourseWorkflows::Nodes::RespondToWebhook::V1,+ DiscourseWorkflows::Nodes::LoopOverItems::V1,+ ]++ expect(+ node_classes.map do |node_class|+ node_class.output_schemas({}, input_schemas: [input_schema])+ end,+ ).to eq([[input_schema], [input_schema], [input_schema], [input_schema, input_schema]])+ end++ it "keeps append and preferred combine merge outputs while hiding suffixed keys" do+ node_class = DiscourseWorkflows::Nodes::Merge::V1++ expect(node_class.output_schemas({ "mode" => "append" }, input_schemas: [input_schema])).to eq(+ [input_schema],+ )+ expect(+ node_class.output_schemas(+ { "mode" => "combine", "resolve_clash" => "prefer_first" },+ input_schemas: [input_schema],+ ),+ ).to eq([input_schema])+ expect(+ node_class.output_schemas(+ { "mode" => "combine", "resolve_clash" => "add_suffix" },+ input_schemas: [input_schema],+ ),+ ).to eq([{}])+ end++ it "distinguishes time, webhook, and timeout-capable wait outputs" do+ node_class = DiscourseWorkflows::Nodes::Wait::V1++ expect(+ node_class.output_schemas({ "resume" => "time_interval" }, input_schemas: [input_schema]),+ ).to eq([input_schema])+ expect(+ node_class.output_schemas(+ { "resume" => "webhook", "limit_wait_time" => false },+ input_schemas: [input_schema],+ ),+ ).to eq([DiscourseWorkflows::Schema::WEBHOOK_REQUEST_SCHEMA])+ expect(+ node_class.output_schemas(+ { "resume" => "webhook", "limit_wait_time" => true },+ input_schemas: [input_schema],+ ),+ ).to eq([DiscourseWorkflows::Schema::WEBHOOK_REQUEST_SCHEMA])+ expect(+ node_class.output_schemas(+ { "resume" => "webhook", "limit_wait_time" => true, "timeout_amount" => 1 },+ input_schemas: [input_schema],+ ),+ ).to eq(+ [+ DiscourseWorkflows::Schema.union(+ input_schema,+ DiscourseWorkflows::Schema::WEBHOOK_REQUEST_SCHEMA,+ ),+ ],+ )+ end++ it "accepts every JSON body shape produced by webhook requests" do+ request =+ DiscourseWorkflows::WebhookRequest.new(+ method: "POST",+ path: "events",+ headers: {+ "Content-Type" => "application/json",+ },+ body: ["first", 2, nil],+ query: {+ },+ webhook_url: "https://example.com/workflows/webhook",+ )++ expect(request.item_json).to match_node_output_schema(DiscourseWorkflows::Nodes::Webhook::V1)+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_serializer_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_serializer_spec.rbnew file mode 100644index 00000000000..126d5e686da--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_serializer_spec.rb@@ -0,0 +1,111 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::NodeTypeSerializer do+ describe "#to_h" do+ it "serializes output contract schemas by version", :aggregate_failures do+ serializer = described_class.new(identifier: "action:group", available_versions: ["1.0"])++ version = serializer.to_h.dig(:versions, "1.0")++ expect(version.dig(:output_contracts, 0, :schema)).to eq({})+ expect(version.dig(:output_contracts, 0, :mode)).to eq(:replace)+ expect(version.dig(:output_contracts, 0, :variants)).to eq(+ [+ {+ schema:+ DiscourseWorkflows::Schema.merge(+ DiscourseWorkflows::Schema::GROUP_SCHEMA,+ DiscourseWorkflows::Schema::BASIC_USER_SCHEMA,+ ),+ mode: :replace,+ display_options: {+ show: {+ operation: %w[add remove],+ },+ },+ },+ {+ schema: DiscourseWorkflows::Schema::GROUP_SCHEMA,+ mode: :replace,+ display_options: {+ show: {+ operation: ["get"],+ },+ },+ },+ {+ schema: DiscourseWorkflows::Schema::GROUP_MEMBERSHIP_SCHEMA,+ mode: :merge,+ display_options: {+ show: {+ operation: ["check_membership"],+ },+ },+ },+ ],+ )+ end++ it "omits empty and default declaration fields", :aggregate_failures do+ serializer = described_class.new(identifier: "trigger:manual", available_versions: ["1.0"])++ version = serializer.to_h.dig(:versions, "1.0")++ expect(version).not_to have_key(:output_contracts)+ end++ it "serializes a non-default mode without an output schema" do+ serializer = described_class.new(identifier: "action:limit", available_versions: ["1.0"])++ version = serializer.to_h.dig(:versions, "1.0")++ expect(version[:output_contracts]).to contain_exactly(+ schema: {+ },+ mode: :passthrough,+ display_options: {+ },+ variants: [],+ )+ end++ it "serializes configuration-aware output variants" do+ serializer = described_class.new(identifier: "flow:wait", available_versions: ["1.0"])++ version = serializer.to_h.dig(:versions, "1.0")++ expect(version.dig(:output_contracts, 0, :variants)).to contain_exactly(+ {+ schema: DiscourseWorkflows::Schema::WEBHOOK_REQUEST_SCHEMA,+ mode: :union,+ display_options: {+ show: {+ resume: ["webhook"],+ limit_wait_time: [true],+ timeout_amount: [{ condition: { exists: true } }],+ },+ },+ },+ {+ schema: DiscourseWorkflows::Schema::WEBHOOK_REQUEST_SCHEMA,+ mode: :replace,+ display_options: {+ show: {+ resume: ["webhook"],+ },+ },+ },+ )+ end++ it "marks hidden executable definitions for client-side palette filtering" do+ serializer =+ described_class.new(identifier: "flow:loop_over_items", available_versions: ["1.0"])++ version = serializer.to_h.dig(:versions, "1.0")++ expect(version[:palette_visible]).to eq(false)+ expect(version[:output_contracts].pluck(:mode)).to eq(%i[passthrough passthrough])+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_spec.rbindex be3b4fb7f98..725d5977389 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/node_type_spec.rb@@ -96,6 +96,194 @@ RSpec.describe DiscourseWorkflows::NodeType doendend+ describe ".output_contracts" do+ let(:declared_schema) do+ {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "result" => {+ "type" => "object",+ "properties" => {+ "value" => {+ "type" => "string",+ },+ },+ },+ },+ }+ end++ let(:node_class) do+ schema = declared_schema+ Class.new(described_class) do+ description(+ name: "action:schema_test",+ output_contracts: [+ { schema: schema, mode: :merge, display_options: { show: { operation: ["run"] } } },+ ],+ )+ end+ end++ it "exposes one contract per output position" do+ expect(node_class.output_contracts).to contain_exactly(+ schema: declared_schema,+ mode: :merge,+ display_options: {+ show: {+ operation: ["run"],+ },+ },+ variants: [],+ )+ end++ it "resolves output schema against configuration and input" do+ input_schema = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ },+ },+ },+ }++ expect(+ node_class.output_schemas({ "operation" => "run" }, input_schemas: [input_schema]),+ ).to eq([DiscourseWorkflows::Schema.merge(input_schema, declared_schema)])+ end++ it "resolves an unknown output when the base contract is hidden" do+ input_schema = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "string",+ },+ },+ }++ expect(+ node_class.output_schemas({ "operation" => "other" }, input_schemas: [input_schema]),+ ).to eq([{}])+ end++ it "uses the first visible output contract variant before the base contract" do+ input_schema = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "string",+ },+ },+ }+ replacement_schema = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "response" => {+ "type" => "boolean",+ },+ },+ }+ klass =+ Class.new(described_class) do+ description(+ name: "action:variant_schema",+ output_contracts: [+ {+ mode: :passthrough,+ variants: [+ { schema: replacement_schema, display_options: { show: { mode: ["replace"] } } },+ ],+ },+ ],+ )+ end++ expect(klass.output_schemas({ "mode" => "replace" }, input_schemas: [input_schema])).to eq(+ [replacement_schema],+ )+ expect(klass.output_schemas({ "mode" => "pass" }, input_schemas: [input_schema])).to eq(+ [input_schema],+ )+ end++ it "keeps an empty declaration as the no-declaration sentinel" do+ expect(described_class.output_contracts).to contain_exactly(+ schema: {+ },+ mode: :replace,+ display_options: {+ },+ variants: [],+ )+ end++ it "declares valid JSON Schema for every registered node contract" do+ schemas =+ DiscourseWorkflows::Registry+ .nodes(include_disabled_plugins: true)+ .flat_map(&:output_contracts)+ .flat_map { |contract| [contract, *contract.fetch(:variants)] }+ .map { |contract| contract.fetch(:schema) }++ expect(schemas).to all(be_a(Hash))+ end++ it "rejects unknown contract modes at declaration time" do+ klass =+ Class.new(described_class) do+ description(name: "action:bad_mode", output_contracts: [{ mode: :passthru }])+ end++ expect { klass.output_contracts }.to raise_error(+ ArgumentError,+ "Unknown output schema mode: :passthru",+ )+ end++ it "rejects flat path declarations" do+ klass =+ Class.new(described_class) do+ description(+ name: "action:flat_schema",+ output_contracts: [{ schema: { "result.value" => "string" } }],+ )+ end++ expect { klass.output_contracts }.to raise_error(+ ArgumentError,+ "Output schema must declare JSON Schema Draft 2020-12",+ )+ end++ it "requires one schema contract per output position" do+ klass =+ Class.new(described_class) do+ description(+ name: "condition:schema_count",+ outputs: %i[true false],+ output_contracts: [{}],+ )+ end++ expect { klass.output_contracts }.to raise_error(+ ArgumentError,+ "condition:schema_count declares 1 output contracts for 2 outputs",+ )+ end+ end+describe "#with_paired_item" doit "adds normalized paired item metadata to an item" donode = described_class.newdiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/badge_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/badge_spec.rbindex 54e9fe060ad..97d3a3c0538 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/badge_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/badge_spec.rb@@ -43,7 +43,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Badge::V1 dolet(:item) { { "json" => {} } }context "with grant operation" do- it "grants the badge to the user" do+ it "grants the badge to the user", :aggregate_failures doconfig = {"operation" => "grant","username" => user.username,@@ -57,6 +57,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Badge::V1 doexpect(result["badge_id"]).to eq(badge.id)expect(result["badge_name"]).to eq(badge.name)expect(UserBadge.exists?(user: user, badge: badge)).to be(true)+ expect(result).to match_node_output_schema(described_class)endit "does not duplicate a non-multiple-grant badge" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/group_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/group_spec.rbindex 5cc4ede7bbb..edd1cd11040 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/group_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/group_spec.rb@@ -38,6 +38,49 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 doendend+ describe ".output_schemas" do+ let(:input_schema) do+ {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "string",+ },+ },+ }+ end++ it "advertises a concrete schema for each operation", :aggregate_failures do+ group_with_user =+ DiscourseWorkflows::Schema.merge(+ DiscourseWorkflows::Schema::GROUP_SCHEMA,+ DiscourseWorkflows::Schema::BASIC_USER_SCHEMA,+ )++ expect(+ described_class.output_schemas({ "operation" => "add" }, input_schemas: [input_schema]),+ ).to eq([group_with_user])+ expect(+ described_class.output_schemas({ "operation" => "remove" }, input_schemas: [input_schema]),+ ).to eq([group_with_user])+ expect(+ described_class.output_schemas({ "operation" => "get" }, input_schemas: [input_schema]),+ ).to eq([DiscourseWorkflows::Schema::GROUP_SCHEMA])+ end++ it "merges membership data over the input schema for check_membership", :aggregate_failures do+ schema =+ described_class.output_schemas(+ { "operation" => "check_membership" },+ input_schemas: [input_schema],+ ).first++ expect(schema.dig("properties", "source")).to eq("type" => "string")+ expect(schema.dig("properties", "group_membership", "properties")).to include("in_group")+ end+ end+describe "#execute" dolet(:item) { { "json" => {} } }@@ -52,6 +95,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 doexpect(result["user"]["id"]).to eq(user.id)expect(result["user"]["username"]).to eq(user.username)expect(GroupUser.exists?(user: user, group: group)).to be(true)+ expect(result).to match_node_output_schema(described_class, configuration: config)endit "is idempotent when user is already a member" do@@ -107,6 +151,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 doexpect(result["user"]["id"]).to eq(user.id)expect(result["user"]["username"]).to eq(user.username)expect(GroupUser.exists?(user: user, group: group)).to be(false)+ expect(result).to match_node_output_schema(described_class, configuration: config)endit "logs the removal in group history" do@@ -191,6 +236,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 doexpect(result["group"]["name"]).to eq(group.name)expect(result["group"]["user_count"]).to eq(group.user_count)expect(result["group"]["automatic"]).to be(false)+ expect(result).to match_node_output_schema(described_class, configuration: config)endit "raises when group does not exist" do@@ -222,14 +268,16 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 dobefore { group.add(member) }it "adds membership data to each item", :aggregate_failures do+ configuration = {+ "operation" => "check_membership",+ "username" => "={{ $json.username }}",+ "group_id" => group.id,+ "actor_username" => "system",+ }+output =execute_node_output(- configuration: {- "operation" => "check_membership",- "username" => "={{ $json.username }}",- "group_id" => group.id,- "actor_username" => "system",- },+ configuration: configuration,input_items: [{ "json" => { "username" => member.username, "post_id" => 1 } },{ "json" => { "username" => non_member.username, "post_id" => 2 } },@@ -262,6 +310,53 @@ RSpec.describe DiscourseWorkflows::Nodes::Group::V1 do),),)++ output.first.each do |output_item|+ expect(output_item["json"]).to match_node_output_schema(+ described_class,+ configuration: configuration,+ )+ end+ end++ it "replaces an existing membership object in both runtime data and its schema contract",+ :aggregate_failures do+ configuration = {+ "operation" => "check_membership",+ "username" => member.username,+ "group_id" => group.id,+ "actor_username" => "system",+ }+ input_schema = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "group_membership" => {+ "type" => "object",+ "properties" => {+ "legacy" => {+ "type" => "string",+ },+ },+ },+ },+ }++ output =+ execute_node_output(+ configuration: configuration,+ input_items: [{ "json" => { "group_membership" => { "legacy" => "old" } } }],+ )+ output_schema =+ described_class.output_schemas(configuration, input_schemas: [input_schema]).first++ expected_keys = %w[group_id group_name user_id username in_group]+ expect(output.first.first.dig("json", "group_membership").keys).to contain_exactly(+ *expected_keys,+ )+ expect(+ output_schema.dig("properties", "group_membership", "properties").keys,+ ).to contain_exactly(*expected_keys)endit "handles the logged_in_users pseudogroup without group_users rows", :aggregate_failures dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/markdown_table_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/markdown_table_spec.rbindex d123eac0bd7..9cc797a38ea 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/markdown_table_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/markdown_table_spec.rb@@ -129,20 +129,25 @@ RSpec.describe DiscourseWorkflows::Nodes::MarkdownTable::V1 doendcontext "when mapping_mode is auto" do- it "derives headers from the keys of input items" do+ it "derives headers from the keys of input items", :aggregate_failures doitems = [{ "json" => { "name" => "Alice", "age" => 30 } },{ "json" => { "name" => "Bob", "age" => 25 } },]- markdown = execute(items, { "mapping_mode" => "auto" })+ output =+ execute_node_output(configuration: { "mapping_mode" => "auto" }, input_items: items)+ .first+ .first+ .fetch("json")- expect(markdown).to eq(<<~MD.strip)+ expect(output.fetch("markdown")).to eq(<<~MD.strip)| name | age || --- | --- || Alice | 30 || Bob | 25 |MD+ expect(output).to match_node_output_schema(described_class)endit "unions keys across items preserving first-appearance order" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_created_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_created_spec.rbindex 9e57b18bd79..5dbf25bb705 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_created_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_created_spec.rb@@ -55,7 +55,7 @@ RSpec.describe DiscourseWorkflows::Nodes::PostCreated::V1 doenddescribe "#output" do- it "returns post and topic data" do+ it "returns post and topic data", :aggregate_failures doupload = Fabricate(:image_upload)UploadReference.create!(target: reply, upload: upload)@@ -83,6 +83,16 @@ RSpec.describe DiscourseWorkflows::Nodes::PostCreated::V1 doexpect(output[:topic][:tags].map { |topic_tag| topic_tag[:name] }).to eq(["test-tag"])expect(output[:topic][:category_id]).to eq(topic.category_id)expect(output[:topic][:archetype]).to eq(topic.archetype)+ expect(output).to match_node_output_schema(described_class)+ end++ it "returns personal message data without a category", :aggregate_failures do+ personal_message_post = Fabricate(:post, topic: direct_pm_topic, user: reply_user)+ output = described_class.new(personal_message_post).output++ expect(output.dig(:post, :category_id)).to be_nil+ expect(output.dig(:topic, :category_id)).to be_nil+ expect(output).to match_node_output_schema(described_class)endenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_moved_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_moved_spec.rbindex 3e1d2aca5c8..c42d8674657 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_moved_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/post_moved_spec.rb@@ -42,7 +42,7 @@ RSpec.describe DiscourseWorkflows::Nodes::PostMoved::V1 doenddescribe "#output" do- it "returns moved post, destination topic, and original topic data" do+ it "returns moved post, destination topic, and original topic data", :aggregate_failures dotrigger = described_class.new(moved_post, source_topic.id)output = trigger.output@@ -59,6 +59,7 @@ RSpec.describe DiscourseWorkflows::Nodes::PostMoved::V1 docategory_id: destination_category.id,)expect(output[:original_topic]).to include(id: source_topic.id, title: source_topic.title)+ expect(output).to match_node_output_schema(described_class)endenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/reviewable_approved_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/reviewable_approved_spec.rbindex c20119d717a..d434a8ba784 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/reviewable_approved_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/reviewable_approved_spec.rb@@ -61,11 +61,12 @@ RSpec.describe DiscourseWorkflows::Nodes::ReviewableApproved::V1 doenddescribe "#output" do- it "returns reviewable data only" do+ it "returns reviewable data", :aggregate_failures doreviewable.update!(status: :approved)trigger = described_class.new(:approved, reviewable)+ output = trigger.output- expect(trigger.output).to eq(+ expect(output).to eq(reviewable: {id: reviewable.id,type: "ReviewableFlaggedPost",@@ -78,6 +79,7 @@ RSpec.describe DiscourseWorkflows::Nodes::ReviewableApproved::V1 docreated_at: reviewable.created_at.iso8601,},)+ expect(output).to match_node_output_schema(described_class)endenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/schedule/payload_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/schedule/payload_spec.rbindex 17cdf361b5b..c0b8e3c9556 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/schedule/payload_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/schedule/payload_spec.rb@@ -2,7 +2,7 @@RSpec.describe DiscourseWorkflows::Nodes::Schedule::Payload dodescribe ".build" do- it "returns compatible timestamp fields" do+ it "returns compatible timestamp fields", :aggregate_failures dopayload = described_class.build(time: Time.utc(2026, 3, 18, 9, 0), timezone: "UTC")expect(payload).to include(@@ -18,6 +18,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Schedule::Payload do"second" => "00","timezone" => "UTC (UTC+00:00)",)+ expect(payload).to match_node_output_schema(DiscourseWorkflows::Nodes::Schedule::V1)endit "formats fields in the resolved workflow timezone" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/stale_topic_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/stale_topic_spec.rbindex ebfa99c3b0f..ee1e444af30 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/stale_topic_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/stale_topic_spec.rb@@ -15,12 +15,13 @@ RSpec.describe DiscourseWorkflows::Nodes::StaleTopic::V1 do{ "id" => "trigger-1", "type" => "trigger:stale_topic", "parameters" => { "hours" => 24 } }end- it "returns one item per stale topic" do+ it "returns one item per stale topic", :aggregate_failures doitems = described_class.trigger_data_for(trigger_context)expect(items.size).to eq(1)expect(items.first[:topic][:id]).to eq(stale_topic.id)expect(items.first[:topic][:tags].map { |t| t[:name] }).to eq(["stale-tag"])+ expect(items.first).to match_node_output_schema(described_class)endcontext "with category filter" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/template_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/template_spec.rbindex 3a8b6514e66..55238b70b39 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/template_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/template_spec.rb@@ -127,7 +127,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Template::V1 do)end- it "emits only the template field" do+ it "emits only the template field", :aggregate_failures doresult =execute_template("{% for item in items %}{{ item.name }}{% endfor %}",@@ -135,6 +135,7 @@ RSpec.describe DiscourseWorkflows::Nodes::Template::V1 do)expect(result.first["json"]).to eq("template" => "Alice")+ expect(result.first["json"]).to match_node_output_schema(described_class)endit "links the output item to every source item" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_category_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_category_changed_spec.rbindex e4cfc832822..38f41fbd3a3 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_category_changed_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_category_changed_spec.rb@@ -29,7 +29,7 @@ RSpec.describe DiscourseWorkflows::Nodes::TopicCategoryChanged::V1 doenddescribe "#output" do- it "returns topic data with both category ids" do+ it "returns topic data with both category ids", :aggregate_failures dotrigger = described_class.new(topic, category)output = trigger.output@@ -39,6 +39,7 @@ RSpec.describe DiscourseWorkflows::Nodes::TopicCategoryChanged::V1 doexpect(output[:topic][:category_id]).to eq(topic.category_id)expect(output[:old_category_id]).to eq(category.id)expect(output[:topic][:posters].map { |poster| poster[:user_id] }).to include(topic.user_id)+ expect(output).to match_node_output_schema(described_class)endendenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_tag_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_tag_changed_spec.rbindex dff1986b44c..bf6d9600bc5 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_tag_changed_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/topic_tag_changed_spec.rb@@ -26,7 +26,7 @@ RSpec.describe DiscourseWorkflows::Nodes::TopicTagChanged::V1 doenddescribe "#output" do- it "returns tag change data with computed diffs" do+ it "returns tag change data with computed diffs", :aggregate_failures dotrigger =described_class.new(topic,@@ -44,6 +44,7 @@ RSpec.describe DiscourseWorkflows::Nodes::TopicTagChanged::V1 doexpect(output[:added_tags]).to eq(%w[urgent])expect(output[:removed_tags]).to eq(%w[help])expect(output[:topic][:posters].map { |poster| poster[:user_id] }).to include(topic.user_id)+ expect(output).to match_node_output_schema(described_class)endit "handles tags added from empty" dodiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_search_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_search_spec.rbindex 34a8fec8a12..cdbee7cc540 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_search_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_search_spec.rb@@ -16,10 +16,12 @@ RSpec.describe DiscourseWorkflows::Nodes::UserSearch::V1 doenddescribe "#output" do- it "returns the query" do+ it "returns the query", :aggregate_failures dotrigger = described_class.new("workflow query")+ output = trigger.output- expect(trigger.output).to eq(query: "workflow query")+ expect(output).to eq(query: "workflow query")+ expect(output).to match_node_output_schema(described_class)endendenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_spec.rbindex c8c68a2e415..3301066dbe3 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_spec.rb@@ -17,10 +17,7 @@ RSpec.describe DiscourseWorkflows::Registry doexpect(described_class.find_node_type("action:plugin_hook_direct_test")).to eq(node_class)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- described_class.reset_indexes!+ unregister_workflow_nodes(node_class)endit "defers a node registration block until workflow node registration is ready" do@@ -46,10 +43,7 @@ RSpec.describe DiscourseWorkflows::Registry doexpect(plugin.discourse_workflows_node_registrations).to be_emptyensureDiscourseWorkflows.node_registration_ready = true- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- described_class.reset_indexes!+ unregister_workflow_nodes(node_class)endit "resets registry indexes when the registering plugin is enabled or disabled" do@@ -78,10 +72,7 @@ RSpec.describe DiscourseWorkflows::Registry doDiscourseEvent.off(:site_setting_changed, &handler) if handlerendSiteSetting.discourse_sample_plugin_enabled = true- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- described_class.reset_indexes!+ unregister_workflow_nodes(node_class)endit "reflects the current filtered registry without requiring an index reset" do@@ -112,10 +103,7 @@ RSpec.describe DiscourseWorkflows::Registry do),).to eq(node_class)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- described_class.reset_indexes!+ unregister_workflow_nodes(node_class)endend@@ -154,10 +142,7 @@ RSpec.describe DiscourseWorkflows::Registry do)expect(described_class.latest_version("action:registry_versioned_test")).to eq("2.0")ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [v1, v2].include?(entry[:value])- end- described_class.reset_indexes!+ unregister_workflow_nodes(v1, v2)endit "rejects duplicate node identifier and version registrations" do@@ -179,10 +164,7 @@ RSpec.describe DiscourseWorkflows::Registry do"Duplicate workflow node type action:registry_duplicate_test v1.0",)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [first, duplicate].include?(entry[:value])- end- described_class.reset_indexes!+ unregister_workflow_nodes(first, duplicate)endendenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/schema_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/schema_spec.rbnew file mode 100644index 00000000000..234602f7b38--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/schema_spec.rb@@ -0,0 +1,737 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Schema do+ let(:input_schema) do+ {+ "$schema" => described_class::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "source" => {+ "type" => "string",+ },+ "shared" => {+ "type" => "object",+ "properties" => {+ "kept" => {+ "type" => "string",+ },+ },+ },+ },+ }+ end++ let(:output_schema) do+ {+ "$schema" => described_class::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "shared" => {+ "type" => "object",+ "properties" => {+ "added" => {+ "type" => "boolean",+ },+ },+ },+ },+ }+ end++ describe "reusable schema constants" do+ it "exposes reusable basic user and group properties" do+ property_types =+ {+ "user" => described_class::BASIC_USER_PROPERTIES,+ "group" => described_class::BASIC_GROUP_PROPERTIES,+ }.transform_values do |properties|+ properties.transform_values { |property| property.fetch("type") }+ end++ expect(property_types).to eq(+ "user" => {+ "id" => "integer",+ "username" => "string",+ "name" => %w[string null],+ "avatar_template" => "string",+ },+ "group" => {+ "id" => "integer",+ "name" => "string",+ "full_name" => %w[string null],+ "automatic" => "boolean",+ },+ )+ end++ it "defines reusable schemas as valid Draft 2020-12 declarations" do+ schemas =+ described_class.constants.grep(/_SCHEMA\z/).map { |name| described_class.const_get(name) }++ expect(schemas).to all(+ satisfy do |schema|+ schema["$schema"] == described_class::DRAFT_URI && JSONSchemer.valid_schema?(schema)+ end,+ )+ end+ end++ describe ".normalize" do+ it "accepts valid Draft 2020-12 object schemas and stringifies keys" do+ schema = {+ "$schema": described_class::DRAFT_URI,+ type: "object",+ properties: {+ value: {+ type: "string",+ },+ },+ }++ expect(described_class.normalize(schema)).to eq(+ "$schema" => described_class::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "value" => {+ "type" => "string",+ },+ },+ )+ end++ it "keeps an empty hash as the no-declaration sentinel" do+ expect(described_class.normalize({})).to eq({})+ end++ it "rejects non-object declarations" do+ expect { described_class.normalize("string") }.to raise_error(+ ArgumentError,+ "Output schema must be a JSON Schema object",+ )+ end++ it "rejects declarations without a Draft 2020-12 marker" do+ expect { described_class.normalize("result.value" => "string") }.to raise_error(+ ArgumentError,+ "Output schema must declare JSON Schema Draft 2020-12",+ )+ end++ it "rejects invalid JSON Schema declarations" do+ schema = {+ "$schema" => described_class::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "value" => {+ "type" => 12,+ },+ },+ }++ expect { described_class.normalize(schema) }.to raise_error(ArgumentError)+ end+ end++ describe ".merge" do+ it "combines disjoint object schemas" do+ merged = described_class.merge(input_schema, output_schema)++ expect(merged.dig("properties", "source", "type")).to eq("string")+ expect(merged.dig("properties", "shared", "properties").keys).to contain_exactly(+ "kept",+ "added",+ )+ end++ it "replaces conflicting non-object properties wholesale" do+ left = described_class.document("value" => { "type" => "string", "format" => "date-time" })+ right = described_class.document("value" => { "type" => "integer" })++ expect(described_class.merge(left, right).dig("properties", "value")).to eq(+ "type" => "integer",+ )+ end++ it "unions required fields" do+ left = input_schema.merge("required" => ["source"])+ right = output_schema.merge("required" => ["shared"])++ expect(described_class.merge(left, right)["required"]).to eq(%w[source shared])+ end++ it "ignores empty schemas" do+ expect(described_class.merge({}, input_schema, {})).to eq(input_schema)+ expect(described_class.merge({}, {})).to eq({})+ end+ end++ describe ".union" do+ it "expresses alternatives as anyOf" do+ expect(described_class.union(input_schema, output_schema)).to eq(+ "$schema" => described_class::DRAFT_URI,+ "anyOf" => [input_schema, output_schema],+ )+ end++ it "collapses identical alternatives" do+ expect(described_class.union(input_schema, input_schema)).to eq(input_schema)+ end++ it "flattens nested anyOf alternatives" do+ third = described_class.document("extra" => { "type" => "boolean" })++ expect(+ described_class.union(described_class.union(input_schema, output_schema), third),+ ).to eq(+ "$schema" => described_class::DRAFT_URI,+ "anyOf" => [input_schema, output_schema, third],+ )+ end++ it "becomes unknown when any alternative is unknown" do+ expect(described_class.union(input_schema, {})).to eq({})+ expect(described_class.union).to eq({})+ end+ end++ describe ".resolve" do+ it "replaces the input schema by default" do+ expect(+ described_class.resolve(output_schema, mode: :replace, input_schema: input_schema),+ ).to eq(output_schema)+ end++ it "passes the input schema through" do+ expect(+ described_class.resolve(output_schema, mode: :passthrough, input_schema: input_schema),+ ).to eq(input_schema)+ end++ it "preserves distinct input properties and replaces colliding root properties on merge" do+ result = described_class.resolve(output_schema, mode: :merge, input_schema: input_schema)++ expect(result.dig("properties", "source", "type")).to eq("string")+ expect(result.dig("properties", "shared", "properties").keys).to eq(["added"])+ end++ it "keeps the declaration when merging over an unknown input" do+ expect(described_class.resolve(output_schema, mode: :merge, input_schema: {})).to eq(+ output_schema,+ )+ end++ it "unions alternative output schemas" do+ expect(+ described_class.resolve(output_schema, mode: :union, input_schema: input_schema),+ ).to eq("$schema" => described_class::DRAFT_URI, "anyOf" => [input_schema, output_schema])+ end++ it "distributes a merge over anyOf input alternatives and stays idempotent" do+ union = described_class.union(input_schema, output_schema)+ declared = described_class.document("extra" => { "type" => "boolean" })++ result = described_class.resolve(declared, mode: :merge, input_schema: union)++ expect(result["anyOf"].length).to eq(2)+ expect(result["anyOf"]).to all(+ satisfy { |branch| branch.dig("properties", "extra") == { "type" => "boolean" } },+ )+ expect(described_class.resolve(declared, mode: :merge, input_schema: result)).to eq(result)+ end++ it "rejects unknown output schema modes" do+ expect { described_class.resolve(output_schema, mode: :append) }.to raise_error(+ ArgumentError,+ "Unknown output schema mode: :append",+ )+ end+ end++ describe ".infer" do+ it "infers a JSON Schema from sample item JSON" do+ schema =+ described_class.infer(+ "custom" => {+ "id" => 1,+ "score" => 1.5,+ "enabled" => true,+ "labels" => ["important", nil],+ "missing" => nil,+ },+ )++ expect(schema).to eq(+ "type" => "object",+ "properties" => {+ "custom" => {+ "type" => "object",+ "properties" => {+ "id" => {+ "type" => "integer",+ },+ "score" => {+ "type" => "number",+ },+ "enabled" => {+ "type" => "boolean",+ },+ "labels" => {+ "type" => "array",+ "items" => {+ "anyOf" => [{ "type" => "string" }, { "type" => "null" }],+ },+ },+ "missing" => {+ "type" => "null",+ },+ },+ },+ },+ )+ end++ it "leaves empty array items unconstrained and collapses homogeneous arrays" do+ schema = described_class.infer("empty" => [], "same" => [1, 2])++ expect(schema.dig("properties", "empty")).to eq("type" => "array")+ expect(schema.dig("properties", "same")).to eq(+ "type" => "array",+ "items" => {+ "type" => "integer",+ },+ )+ end++ it "returns the unknown sentinel without sample fields" do+ expect(described_class.infer({})).to eq({})+ expect(described_class.infer("not a hash")).to eq({})+ end+ end++ describe ".visible?" do+ it "supports show and hide condition operators", :aggregate_failures do+ display_options = {+ show: {+ operation: ["run"],+ },+ hide: {+ selection: [{ condition: { exists: false } }],+ },+ }++ expect(described_class.visible?(display_options, operation: "run", selection: [1])).to eq(+ true,+ )+ expect(described_class.visible?(display_options, operation: "run", selection: [])).to eq(+ false,+ )+ expect(described_class.visible?(display_options, operation: "skip", selection: [1])).to eq(+ false,+ )+ end+ end++ describe ".resolve_graph" do+ it "propagates declared schemas through connected nodes" do+ graph =+ build_workflow_graph do |builder|+ builder.node "post-created", "trigger:post_created"+ builder.node "filter", "condition:filter"+ builder.connect "post-created", "filter"+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])+ filter_schema = resolution[:output_schemas]["filter"][0]++ expect(filter_schema.dig("properties", "post", "properties", "id", "type")).to eq("integer")+ expect(filter_schema.dig("properties", "user", "properties", "username", "type")).to eq(+ "string",+ )+ end++ it "resolves unregistered node type versions to unknown schemas and keeps downstream unions unknown" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ trigger_class =+ Class.new(DiscourseWorkflows::NodeType) do+ description(+ name: "trigger:schema_version_test",+ version: "1.0",+ output_contracts: [{ schema: trigger_schema }],+ )+ end+ join_class =+ Class.new(DiscourseWorkflows::NodeType) do+ description(+ name: "action:schema_version_join_test",+ version: "1.0",+ output_contracts: [{ mode: :passthrough }],+ )+ end+ DiscoursePluginRegistry.register_discourse_workflows_node(trigger_class, Plugin::Instance.new)+ DiscoursePluginRegistry.register_discourse_workflows_node(join_class, Plugin::Instance.new)+ DiscourseWorkflows::Registry.reset_indexes!+ graph =+ build_workflow_graph do |builder|+ builder.node "current", "trigger:schema_version_test"+ builder.node "stale", "trigger:schema_version_test"+ builder.node "join", "action:schema_version_join_test"+ builder.connect "current", "join"+ builder.connect "stale", "join"+ end+ graph[:nodes].find { |node| node["id"] == "stale" }["typeVersion"] = "9.0"++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["current"]).to eq([trigger_schema])+ expect(resolution[:output_schemas]["stale"]).to eq([{}])+ expect(resolution[:output_schemas]["join"]).to eq([{}])+ ensure+ unregister_workflow_nodes(trigger_class, join_class)+ end++ it "resolves nodes without a typeVersion as the default version instead of the latest" do+ v1_schema = described_class.document("from_v1" => { "type" => "string" })+ v2_schema = described_class.document("from_v2" => { "type" => "string" })+ v1_class =+ Class.new(DiscourseWorkflows::NodeType) do+ description(+ name: "trigger:schema_default_version_test",+ version: "1.0",+ output_contracts: [{ schema: v1_schema }],+ )+ end+ v2_class =+ Class.new(DiscourseWorkflows::NodeType) do+ description(+ name: "trigger:schema_default_version_test",+ version: "2.0",+ output_contracts: [{ schema: v2_schema }],+ )+ end+ DiscoursePluginRegistry.register_discourse_workflows_node(v1_class, Plugin::Instance.new)+ DiscoursePluginRegistry.register_discourse_workflows_node(v2_class, Plugin::Instance.new)+ DiscourseWorkflows::Registry.reset_indexes!+ graph =+ build_workflow_graph do |builder|+ builder.node "legacy", "trigger:schema_default_version_test"+ end+ graph[:nodes].each { |node| node.delete("typeVersion") }++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["legacy"]).to eq([v1_schema])+ ensure+ unregister_workflow_nodes(v1_class, v2_class)+ end++ it "selects the source schema by output position" do+ schemas =+ %w[kept rejected].map { |field| described_class.document(field => { "type" => "boolean" }) }+ source_class =+ Class.new { define_singleton_method(:output_schemas) { |*, input_schemas:| schemas } }+ target_class =+ Class.new do+ define_singleton_method(:input_ports) { |*| [{}, {}] }+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "source", "condition:test"+ builder.node "target", "action:test"+ builder.connect "source", "target", output: 1, input: 1+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ identifier == "condition:test" ? source_class : target_class+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["source"]).to eq(schemas)+ expect(resolution[:input_schemas]["target"]).to eq([nil, schemas.second])+ expect(resolution[:output_schemas]["target"]).to eq([schemas.second])+ end++ it "joins alternative incoming schemas with anyOf" do+ left_schema = described_class.document("left" => { "type" => "string" })+ right_schema = described_class.document("right" => { "type" => "string" })+ node_class_for =+ lambda do |schema|+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ schema ? [schema] : [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ end+ node_classes = {+ "trigger:left" => node_class_for.call(left_schema),+ "trigger:right" => node_class_for.call(right_schema),+ "action:target" => node_class_for.call(nil),+ }+ graph =+ build_workflow_graph do |builder|+ builder.node "left", "trigger:left"+ builder.node "right", "trigger:right"+ builder.node "target", "action:target"+ builder.connect "left", "target"+ builder.connect "right", "target"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ node_classes.fetch(identifier)+ end++ target_schema =+ described_class.resolve_graph(graph[:nodes], graph[:connections])[:output_schemas][+ "target"+ ][+ 0+ ]++ expect(target_schema).to eq(+ "$schema" => described_class::DRAFT_URI,+ "anyOf" => [left_schema, right_schema],+ )+ end++ it "keeps a join unknown when any incoming branch has no declaration" do+ declared_schema = described_class.document("value" => { "type" => "string" })+ declared_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [declared_schema] }+ end+ unknown_class =+ Class.new { define_singleton_method(:output_schemas) { |*, input_schemas:| [{}] } }+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ node_classes = {+ "trigger:declared" => declared_class,+ "action:unknown" => unknown_class,+ "action:target" => passthrough_class,+ }+ graph =+ build_workflow_graph do |builder|+ builder.node "declared", "trigger:declared"+ builder.node "unknown", "action:unknown"+ builder.node "target", "action:target"+ builder.connect "declared", "target"+ builder.connect "unknown", "target"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ node_classes.fetch(identifier)+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["target"]).to eq([{}])+ end++ it "propagates an external declaration through a passthrough cycle" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ trigger_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [trigger_schema] }+ end+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "cycle-a", "action:passthrough"+ builder.node "cycle-b", "action:passthrough"+ builder.node "trigger", "trigger:test"+ builder.connect "trigger", "cycle-a"+ builder.connect "cycle-a", "cycle-b"+ builder.connect "cycle-b", "cycle-a"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ identifier == "trigger:test" ? trigger_class : passthrough_class+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas].values_at("cycle-a", "cycle-b")).to all(+ eq([trigger_schema]),+ )+ end++ it "keeps a join unknown when another branch is an unseeded passthrough cycle" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ trigger_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [trigger_schema] }+ end+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "cycle-a", "action:passthrough"+ builder.node "cycle-b", "action:passthrough"+ builder.node "target", "action:passthrough"+ builder.node "trigger", "trigger:test"+ builder.connect "cycle-a", "cycle-b"+ builder.connect "cycle-b", "cycle-a"+ builder.connect "cycle-a", "target"+ builder.connect "trigger", "target"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ identifier == "trigger:test" ? trigger_class : passthrough_class+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["target"]).to eq([{}])+ end++ it "converges when a merge contract participates in a cycle" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ declared_schema = described_class.document("extra" => { "type" => "boolean" })+ trigger_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [trigger_schema] }+ end+ merge_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [+ DiscourseWorkflows::Schema.resolve(+ declared_schema,+ mode: :merge,+ input_schema: DiscourseWorkflows::Schema.union(*input_schemas.compact),+ ),+ ]+ end+ end+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ node_classes = {+ "trigger:test" => trigger_class,+ "action:merge" => merge_class,+ "action:passthrough" => passthrough_class,+ }+ graph =+ build_workflow_graph do |builder|+ builder.node "trigger", "trigger:test"+ builder.node "merger", "action:merge"+ builder.node "loop-back", "action:passthrough"+ builder.connect "trigger", "merger"+ builder.connect "merger", "loop-back"+ builder.connect "loop-back", "merger"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ node_classes.fetch(identifier)+ end++ merger_schema =+ described_class.resolve_graph(graph[:nodes], graph[:connections])[:output_schemas][+ "merger"+ ][+ 0+ ]++ expect(merger_schema.dig("properties", "value", "type")).to eq("string")+ expect(merger_schema.dig("properties", "extra", "type")).to eq("boolean")+ end++ it "ignores self connections when resolving inputs" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ trigger_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [trigger_schema] }+ end+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "trigger", "trigger:test"+ builder.node "looper", "action:passthrough"+ builder.connect "trigger", "looper"+ builder.connect "looper", "looper"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ identifier == "trigger:test" ? trigger_class : passthrough_class+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas]["looper"]).to eq([trigger_schema])+ end++ it "raises when a custom node contract cannot converge" do+ counter = 0+ diverging_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.document("field_#{counter += 1}" => { "type" => "string" })]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "cycle-a", "action:diverging"+ builder.node "cycle-b", "action:diverging"+ builder.connect "cycle-a", "cycle-b"+ builder.connect "cycle-b", "cycle-a"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ diverging_class+ end++ expect { described_class.resolve_graph(graph[:nodes], graph[:connections]) }.to raise_error(+ ArgumentError,+ "Output schema graph did not converge",+ )+ end++ it "propagates a reverse-ordered chain of passthrough nodes" do+ trigger_schema = described_class.document("value" => { "type" => "string" })+ trigger_class =+ Class.new do+ define_singleton_method(:output_schemas) { |*, input_schemas:| [trigger_schema] }+ end+ passthrough_class =+ Class.new do+ define_singleton_method(:output_schemas) do |*, input_schemas:|+ [DiscourseWorkflows::Schema.union(*input_schemas.compact)]+ end+ end+ graph =+ build_workflow_graph do |builder|+ builder.node "step-3", "action:passthrough"+ builder.node "step-2", "action:passthrough"+ builder.node "step-1", "action:passthrough"+ builder.node "trigger", "trigger:test"+ builder.connect "trigger", "step-1"+ builder.connect "step-1", "step-2"+ builder.connect "step-2", "step-3"+ end+ allow(DiscourseWorkflows::Registry).to receive(:find_node_type) do |identifier, version: nil|+ identifier == "trigger:test" ? trigger_class : passthrough_class+ end++ resolution = described_class.resolve_graph(graph[:nodes], graph[:connections])++ expect(resolution[:output_schemas].values_at("step-1", "step-2", "step-3")).to all(+ eq([trigger_schema]),+ )+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/trigger_runtime_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/trigger_runtime_spec.rbindex 604d7502300..18112d5a2ff 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/trigger_runtime_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/trigger_runtime_spec.rb@@ -28,11 +28,7 @@ RSpec.describe DiscourseWorkflows::TriggerRuntime dodescribed_class.activate_workflow!(workflow, workflow_version: workflow.active_version)}.not_to raise_errorensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == passive_trigger_class- end- DiscourseWorkflows::NodeType.registered_nodes.delete(passive_trigger_class)- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(passive_trigger_class)endendenddiff --git a/plugins/discourse-workflows/spec/requests/discourse_workflows/dynamic_node_parameters_controller_spec.rb b/plugins/discourse-workflows/spec/requests/discourse_workflows/dynamic_node_parameters_controller_spec.rbindex 7269756c1f4..121867ab1ad 100644--- a/plugins/discourse-workflows/spec/requests/discourse_workflows/dynamic_node_parameters_controller_spec.rb+++ b/plugins/discourse-workflows/spec/requests/discourse_workflows/dynamic_node_parameters_controller_spec.rb@@ -182,10 +182,7 @@ RSpec.describe DiscourseWorkflows::DynamicNodeParametersController do"user_id" => admin.id,)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(node_class)endit "uses the requested node version when loading options" do@@ -238,10 +235,7 @@ RSpec.describe DiscourseWorkflows::DynamicNodeParametersController doexpect(response).to have_http_status(:ok)expect(response.parsed_body).to contain_exactly("id" => "v2", "name" => "Version 2")ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [v1, v2].include?(entry[:value])- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(v1, v2)endit "requires exact node versions when loading options" do@@ -270,10 +264,7 @@ RSpec.describe DiscourseWorkflows::DynamicNodeParametersController doexpect(response).to have_http_status(:not_found)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(node_class)endit "requires the context-aware option loader" do@@ -302,10 +293,7 @@ RSpec.describe DiscourseWorkflows::DynamicNodeParametersController doexpect(response).to have_http_status(:not_found)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(node_class)endendenddiff --git a/plugins/discourse-workflows/spec/services/discourse_workflows/node_type/list_spec.rb b/plugins/discourse-workflows/spec/services/discourse_workflows/node_type/list_spec.rbindex 51235ae9e7c..1c8ab6fc260 100644--- a/plugins/discourse-workflows/spec/services/discourse_workflows/node_type/list_spec.rb+++ b/plugins/discourse-workflows/spec/services/discourse_workflows/node_type/list_spec.rb@@ -191,10 +191,11 @@ RSpec.describe DiscourseWorkflows::NodeType::List do)end- it "does not serialize hidden loop node" do+ it "serializes hidden executable node definitions outside the palette" doloop_node = result[:node_types].find { |nt| nt[:identifier] == "flow:loop_over_items" }- expect(loop_node).to be_nil+ expect(loop_node[:palette_visible]).to eq(false)+ expect(loop_node[:output_contracts].pluck(:mode)).to eq(%i[passthrough passthrough])endit "serializes ui palette group for trigger nodes" do@@ -275,8 +276,7 @@ RSpec.describe DiscourseWorkflows::NodeType::List doexpect(unavailable[:available]).to eq(false)expect(unavailable[:unavailable_reason_key]).to eq(reason_key)ensure- DiscoursePluginRegistry.discourse_workflows_nodes.delete(unavailable_class)- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(unavailable_class)endit "serializes full descriptions for each registered node version" do@@ -326,10 +326,7 @@ RSpec.describe DiscourseWorkflows::NodeType::List doexpect(node_type).not_to have_key(:property_schema_versions)expect(node_type[:latest]).not_to have_key(:property_schema)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [v1, v2].include?(entry[:value])- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(v1, v2)endendenddiff --git a/plugins/discourse-workflows/spec/services/discourse_workflows/workflow/action/populate_graph_spec.rb b/plugins/discourse-workflows/spec/services/discourse_workflows/workflow/action/populate_graph_spec.rbindex 055400feacc..da478d05970 100644--- a/plugins/discourse-workflows/spec/services/discourse_workflows/workflow/action/populate_graph_spec.rb+++ b/plugins/discourse-workflows/spec/services/discourse_workflows/workflow/action/populate_graph_spec.rb@@ -276,10 +276,7 @@ RSpec.describe DiscourseWorkflows::Workflow::Action::PopulateGraph do"typeVersion" => "1.0",)ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- entry[:value] == node_class- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(node_class)endend@@ -311,10 +308,7 @@ RSpec.describe DiscourseWorkflows::Workflow::Action::PopulateGraph doexpect(result).to eq(true)expect(workflow.reload.nodes.first["typeVersion"]).to eq("2.0")ensure- DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|- [v1, v2].include?(entry[:value])- end- DiscourseWorkflows::Registry.reset_indexes!+ unregister_workflow_nodes(v1, v2)endenddiff --git a/plugins/discourse-workflows/spec/support/matchers/match_node_output_schema.rb b/plugins/discourse-workflows/spec/support/matchers/match_node_output_schema.rbnew file mode 100644index 00000000000..6140b11807e--- /dev/null+++ b/plugins/discourse-workflows/spec/support/matchers/match_node_output_schema.rb@@ -0,0 +1,44 @@+# frozen_string_literal: true++RSpec::Matchers.define :match_node_output_schema do |node_class, configuration: {}, input_schemas: [], output_index: 0|+ match do |output|+ @resolved_schema = nil+ @validation_errors = []+ @non_hash_output = !output.is_a?(Hash)++ if @non_hash_output+ false+ else+ @resolved_schema =+ node_class.output_schemas(configuration, input_schemas: input_schemas)[output_index] || {}++ if @resolved_schema.blank?+ false+ else+ @validation_errors =+ JSONSchemer.schema(@resolved_schema).validate(output.deep_stringify_keys).to_a+ @validation_errors.empty?+ end+ end+ end++ failure_message do |output|+ node_name = node_class.name.presence || node_class.to_s++ if @non_hash_output+ "expected node output to be a Hash, got #{output.class}"+ elsif @resolved_schema.blank?+ "expected #{node_name} to resolve a concrete output schema, but it resolved #{@resolved_schema.inspect}"+ else+ details =+ @validation_errors+ .map do |error|+ schema_pointer = error["schema_pointer"].presence || "/"+ "#{JSONSchemer::Errors.pretty(error)} [schema: #{schema_pointer}]"+ end+ .join("\n")++ "expected output to match #{node_name}'s output schema:\n#{details}"+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/support/workflow_node_registry_helpers.rb b/plugins/discourse-workflows/spec/support/workflow_node_registry_helpers.rbnew file mode 100644index 00000000000..271d956ed01--- /dev/null+++ b/plugins/discourse-workflows/spec/support/workflow_node_registry_helpers.rb@@ -0,0 +1,15 @@+# frozen_string_literal: true++module DiscourseWorkflows+ module WorkflowNodeRegistryHelpers+ def unregister_workflow_nodes(*node_classes)+ DiscoursePluginRegistry._raw_discourse_workflows_nodes.reject! do |entry|+ node_classes.include?(entry[:value])+ end+ NodeType.registered_nodes.reject! { |node_class| node_classes.include?(node_class) }+ Registry.reset_indexes!+ end+ end+end++RSpec.configure { |config| config.include DiscourseWorkflows::WorkflowNodeRegistryHelpers }diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-input-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-input-test.gjsindex 302f9deba42..f371ff1268c 100644--- a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-input-test.gjs+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-input-test.gjs@@ -300,6 +300,212 @@ module(assert.dom(".workflows-context-panel__empty").doesNotExist();});+ test("renders declared direct and ancestor schemas before the first run", async function (assert) {+ const triggerNode = {+ clientId: "trigger",+ type: "trigger:sample",+ typeVersion: "1.0",+ name: "Trigger",+ };+ const stepNode = {+ clientId: "step",+ type: "action:step",+ typeVersion: "1.0",+ name: "Step",+ };+ const currentNode = {+ clientId: "current",+ type: "action:current",+ typeVersion: "1.0",+ name: "Current",+ };+ const nodes = makeNodes(triggerNode, stepNode, currentNode);+ const connections = [+ { sourceClientId: "trigger", targetClientId: "step" },+ { sourceClientId: "step", targetClientId: "current" },+ ];+ const nodeTypes = [+ {+ name: "trigger:sample",+ versions: {+ "1.0": {+ output_contracts: [+ {+ schema: {+ type: "object",+ properties: {+ trigger: {+ type: "object",+ description: "Trigger payload",+ properties: { id: { type: "integer" } },+ },+ },+ },+ },+ ],+ },+ },+ },+ {+ name: "action:step",+ versions: {+ "1.0": {+ output_contracts: [+ {+ mode: "merge",+ schema: {+ type: "object",+ properties: { result: { type: "string" } },+ },+ },+ ],+ },+ },+ },+ ];++ await render(+ <template>+ <InputContext+ @node={{currentNode}}+ @nodes={{nodes}}+ @connections={{connections}}+ @nodeTypes={{nodeTypes}}+ @session={{this.session}}+ />+ </template>+ );++ const sections = [+ ...this.element.querySelectorAll(".workflows-context-panel__section"),+ ];+ const directSection = sections.find((section) =>+ section+ .querySelector(".workflows-context-panel__title")+ ?.textContent.includes("Step")+ );+ const ancestorSection = sections.find((section) =>+ section+ .querySelector(".workflows-context-panel__title")+ ?.textContent.includes("Trigger")+ );+ const directKeys = [+ ...directSection.querySelectorAll(".workflows-schema-field__key-title"),+ ].map((element) => element.textContent.trim());+ const ancestorKeys = [+ ...ancestorSection.querySelectorAll(+ ".workflows-schema-field__key-title"+ ),+ ].map((element) => element.textContent.trim());++ assert.deepEqual(+ directKeys,+ ["trigger", "result"],+ "the direct input includes propagated and merged declarations"+ );+ assert.deepEqual(+ ancestorKeys,+ ["trigger"],+ "the ancestor section uses its declaration"+ );+ assert+ .dom(".workflows-context-panel__title-meta")+ .doesNotExist("declarations do not fabricate input item counts");++ const dragged = {};+ await triggerEvent(+ ancestorSection.querySelector(".workflows-schema-field__key"),+ "dragstart",+ {+ dataTransfer: {+ setData(type, value) {+ dragged[type] = value;+ },+ },+ }+ );++ assert.strictEqual(+ JSON.parse(dragged[WORKFLOW_VARIABLE_MIME]).id,+ '$("Trigger").item.json.trigger',+ "uses a safe linked-item expression when no item count exists"+ );+ });++ test("reuses one declared schema resolution across ancestor sections", async function (assert) {+ let declarationReads = 0;+ const triggerNode = {+ clientId: "trigger",+ type: "trigger:sample",+ typeVersion: "1.0",+ name: "Trigger",+ };+ const stepNodes = Array.from({ length: 8 }, (_, index) => ({+ clientId: `step-${index}`,+ type: "action:passthrough",+ typeVersion: "1.0",+ name: `Step ${index}`,+ }));+ const currentNode = {+ clientId: "current",+ type: "action:current",+ name: "Current",+ };+ const nodes = [triggerNode, ...stepNodes, currentNode];+ const connections = nodes.slice(1).map((node, index) => ({+ sourceClientId: nodes[index].clientId,+ targetClientId: node.clientId,+ }));+ const passthroughVersion = {+ get output_contracts() {+ declarationReads++;+ return [{ mode: "passthrough" }];+ },+ };+ const nodeTypes = [+ {+ name: "trigger:sample",+ versions: {+ "1.0": {+ output_contracts: [+ {+ schema: {+ type: "object",+ properties: { id: { type: "integer" } },+ },+ },+ ],+ },+ },+ },+ {+ name: "action:passthrough",+ versions: { "1.0": passthroughVersion },+ },+ ];++ await render(+ <template>+ <InputContext+ @node={{currentNode}}+ @nodes={{nodes}}+ @connections={{connections}}+ @nodeTypes={{nodeTypes}}+ @session={{this.session}}+ />+ </template>+ );++ assert.strictEqual(+ declarationReads,+ stepNodes.length,+ "all direct and ancestor sections share one graph-level resolution"+ );+ assert+ .dom(".workflows-schema-field__key-title")+ .includesText("id", "the propagated declaration remains visible");+ });+test("shows an empty input state when the input has no JSON fields", async function (assert) {const previousNode = {clientId: "previous-1",@@ -679,7 +885,7 @@ module();});- test("renders ancestor nodes with $() expression format", async function (assert) {+ test("uses pinned item counts for ancestor expressions", async function (assert) {const triggerNode = {clientId: "t1",type: "trigger:webhook",@@ -734,6 +940,12 @@ module(},],};+ this.session.pinData = {+ "First Step": [+ { json: { result: "pinned one" } },+ { json: { result: "pinned two" } },+ ],+ };await render(<template>@@ -770,7 +982,8 @@ module(assert.strictEqual(JSON.parse(dragged[WORKFLOW_VARIABLE_MIME]).id,- '$("First Step").first().json.result'+ '$("First Step").item.json.result',+ "uses the two pinned items instead of the stale single-item run");});diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-output-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-output-test.gjsindex b3274e988b8..8407c791551 100644--- a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-output-test.gjs+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/context-output-test.gjs@@ -1,4 +1,4 @@-import { render } from "@ember/test-helpers";+import { click, render } from "@ember/test-helpers";import { module, test } from "qunit";import { setupRenderingTest } from "discourse/tests/helpers/component-test";import OutputContext from "discourse/plugins/discourse-workflows/admin/components/workflows/context/output";@@ -99,6 +99,76 @@ module(.hasText(/Add sample data/);});+ test("renders a configuration-aware declaration before the first run", async function (assert) {+ const node = {+ clientId: "n1",+ name: "Group",+ type: "action:group",+ typeVersion: "1.0",+ configuration: { operation: "add" },+ };+ const nodeTypes = [+ {+ name: "action:group",+ versions: {+ "1.0": {+ output_contracts: [+ {+ mode: "merge",+ schema: {+ type: "object",+ properties: {+ group_membership: {+ type: "object",+ description: "Group membership result",+ properties: { in_group: { type: "boolean" } },+ },+ },+ },+ display_options: {+ show: { operation: ["check_membership"] },+ },+ },+ ],+ },+ },+ },+ ];+ const configuration = { operation: "check_membership" };++ await render(+ <template>+ <OutputContext+ @node={{node}}+ @nodes={{Array node}}+ @connections={{(Array)}}+ @nodeTypes={{nodeTypes}}+ @session={{this.session}}+ @configuration={{configuration}}+ />+ </template>+ );++ assert+ .dom(".workflows-schema-field__key-title")+ .hasText("group_membership", "shows the enabled declared schema");+ assert+ .dom(".workflows-context-panel__title-meta")+ .doesNotExist("does not show a fabricated item count");+ assert+ .dom(".workflows-context-panel__pin-btn")+ .isDisabled("does not allow declarations to be pinned as run data");++ await click(".workflows-context-panel__tab:last-child");++ assert+ .dom(".workflows-context-panel__empty-state-title")+ .hasText("No output yet", "keeps the JSON view based on actual data");+ assert+ .dom(".workflows-context-panel__empty-state-btn")+ .hasText(/Add sample data/, "still offers adding real sample data");+ });+test("does not show the pin tip when output data is already pinned", async function (assert) {const node = {clientId: "n1",diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/property-engine-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/property-engine-test.gjsindex ff8df7dd71c..010832484df 100644--- a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/property-engine-test.gjs+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/property-engine-test.gjs@@ -823,6 +823,126 @@ module("Integration | Component | workflows property engine", function (hooks) {);});+ test("condition builder supports declared integer and array fields", async function (assert) {+ this.setProperties({+ configuration: { conditions: [] },+ formApi: null,+ node: {+ clientId: "branch",+ type: "condition:if",+ name: "Branch",+ },+ nodes: [+ {+ clientId: "trigger",+ type: "trigger:sample",+ typeVersion: "1.0",+ name: "Trigger",+ },+ {+ clientId: "branch",+ type: "condition:if",+ name: "Branch",+ },+ ],+ connections: [+ {+ sourceClientId: "trigger",+ targetClientId: "branch",+ },+ ],+ nodeTypes: [+ {+ name: "trigger:sample",+ versions: {+ "1.0": {+ output_contracts: [+ {+ schema: {+ type: "object",+ properties: {+ post: {+ type: "object",+ properties: {+ id: { type: "integer" },+ mixed: { type: ["integer", "string"] },+ tags: {+ type: "array",+ items: { type: "string" },+ },+ },+ },+ },+ },+ },+ ],+ },+ },+ },+ ],+ nodeType: "condition:if",+ schema: {+ conditions: {+ type: "array",+ ui: { control: "condition_builder" },+ },+ },+ registerApi: (api) => {+ this.set("formApi", api);+ },+ });++ await render(+ <template>+ <Form+ @data={{this.configuration}}+ @onRegisterApi={{this.registerApi}}+ as |form transientData|+ >+ <PropertyEngineConfigurator+ @form={{form}}+ @formApi={{this.formApi}}+ @configuration={{transientData}}+ @connections={{this.connections}}+ @node={{this.node}}+ @nodes={{this.nodes}}+ @nodeType={{this.nodeType}}+ @nodeTypes={{this.nodeTypes}}+ @schema={{this.schema}}+ @session={{this.session}}+ />+ </Form>+ </template>+ );++ await click(".workflows-empty-state .btn-primary");++ assert+ .dom("option[value='$json.post.tags']")+ .exists("offers the array itself for array operators");+ assert+ .dom("option[value='$json.post.tags[0]']")+ .exists("also offers the declared array item path");+ assert+ .dom("option[value='$json.post.mixed']")+ .doesNotExist("does not guess an operator type for union fields");++ await select(+ ".workflows-property-engine__collection-row select",+ "$json.post.id"+ );++ assert.deepEqual(+ this.formApi.get("conditions.0.operator"),+ {+ operation: "equals",+ type: "number",+ singleValue: false,+ },+ "stores the runtime-supported number type for declared integers"+ );+ });+test("renders webhook URL previews from schema controls", async function (assert) {this.setProperties({configuration: { path: "my-hook" },diff --git a/plugins/discourse-workflows/test/javascripts/unit/components/workflows/canvas/node-panel-test.js b/plugins/discourse-workflows/test/javascripts/unit/components/workflows/canvas/node-panel-test.jsindex 3479769f897..70516a9f3c3 100644--- a/plugins/discourse-workflows/test/javascripts/unit/components/workflows/canvas/node-panel-test.js+++ b/plugins/discourse-workflows/test/javascripts/unit/components/workflows/canvas/node-panel-test.js@@ -1,5 +1,8 @@import { module, test } from "qunit";-import { sortNodeTypesByLabel } from "discourse/plugins/discourse-workflows/admin/components/workflows/canvas/node-panel";+import {+ nodeTypesForPalette,+ sortNodeTypesByLabel,+} from "discourse/plugins/discourse-workflows/admin/components/workflows/canvas/node-panel";module("Unit | Component | Workflows | Canvas | NodePanel", function () {test("sorts node types by translated label", function (assert) {@@ -15,4 +18,18 @@ module("Unit | Component | Workflows | Canvas | NodePanel", function () {"the node panel order is alphabetical by label");});++ test("excludes non-palette executable node types", function (assert) {+ const visible = nodeTypesForPalette([+ { identifier: "action:user" },+ { identifier: "flow:loop_over_items", palette_visible: false },+ { identifier: "action:unavailable", available: false },+ ]);++ assert.deepEqual(+ visible.map((nodeType) => nodeType.identifier),+ ["action:user"],+ "keeps hidden executable definitions out of search and categories"+ );+ });});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-preview-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-preview-test.jsnew file mode 100644index 00000000000..56ced5e32e5--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-preview-test.js@@ -0,0 +1,395 @@+import { module, test } from "qunit";+import {+ inputSummaryForNode,+ outputPreviewForNode,+ outputSummaryForNode,+ schemaFieldsForNodeInput,+ schemaFieldsForNodeOutput,+} from "discourse/plugins/discourse-workflows/admin/lib/workflows/data-preview";++function declaredType(name) {+ return {+ name,+ versions: {+ "1.0": {+ output_contracts: [+ {+ schema: {+ type: "object",+ properties: { declared: { type: "string" } },+ },+ },+ ],+ },+ },+ };+}++function typedNode(clientId, name, type) {+ return { clientId, name, type, typeVersion: "1.0" };+}++function sampleGraph() {+ const node = typedNode("sample", "Sample", "action:sample");+ const graph = {+ nodes: [node],+ connections: [],+ nodeTypes: [declaredType("action:sample")],+ };+ return { node, graph };+}++function sourceCurrentGraph() {+ const sourceNode = typedNode("source", "Source", "trigger:source");+ const currentNode = typedNode("current", "Current", "action:current");+ const graph = {+ nodes: [sourceNode, currentNode],+ connections: [{ sourceClientId: "source", targetClientId: "current" }],+ nodeTypes: [declaredType("trigger:source")],+ };+ return { sourceNode, currentNode, graph };+}++function successRun(attrs) {+ return { status: "success", ...attrs };+}++function port(index, jsons, extra = {}) {+ return {+ index,+ items: jsons.map((json) => ({ json })),+ item_count: jsons.length,+ ...extra,+ };+}++function keys(fields) {+ return fields.map((field) => field.key);+}++module("Unit | lib | discourse-workflows | data-preview", function () {+ test("schemaFieldsForNodeOutput and outputSummaryForNode use the latest successful run", function (assert) {+ const runData = {+ "Node 1": [+ successRun({ outputs: [port(0, [{ old: true }])] }),+ successRun({+ outputs: [+ port(0, [{ current: true }]),+ port(1, [{ value: 1 }], { item_count: 3, truncated: true }),+ ],+ }),+ ],+ };++ assert.deepEqual(+ keys(schemaFieldsForNodeOutput(runData, "Node 1")),+ ["current"],+ "the latest run wins over older runs"+ );+ assert.deepEqual(+ outputSummaryForNode(runData, "Node 1", 1),+ { outputIndex: 1, itemCount: 3, truncated: true },+ "summaries expose item counts and truncation per output index"+ );++ const emptied = {+ "Node 1": [+ successRun({ outputs: [port(0, [{ stale: true }])] }),+ successRun({ outputs: [port(0, [])] }),+ ],+ };+ assert.deepEqual(+ schemaFieldsForNodeOutput(emptied, "Node 1"),+ [],+ "a zero-item latest run does not reuse older item data"+ );+ assert.deepEqual(outputSummaryForNode(emptied, "Node 1"), {+ outputIndex: 0,+ itemCount: 0,+ truncated: false,+ });+ });++ test("output declarations fill in before a run and after full compaction", function (assert) {+ const { node, graph } = sampleGraph();++ assert.deepEqual(+ keys(schemaFieldsForNodeOutput({}, "Sample", { node, graph })),+ ["declared"],+ "uses declared fields before the first run"+ );+ assert.deepEqual(+ outputPreviewForNode({}, "Sample", { node, graph }),+ {+ summary: null,+ fields: [{ key: "declared", id: "$json.declared", type: "string" }],+ },+ "does not fabricate a declaration summary or items"+ );++ const emptyRun = { Sample: [successRun({ outputs: [port(0, [])] })] };+ assert.deepEqual(+ schemaFieldsForNodeOutput(emptyRun, "Sample", { node, graph }),+ [],+ "a successful empty output takes precedence over the declaration"+ );++ const compacted = {+ Sample: [+ successRun({+ outputs: [port(0, [], { item_count: 24, truncated: true })],+ }),+ ],+ };+ assert.deepEqual(+ keys(schemaFieldsForNodeOutput(compacted, "Sample", { node, graph })),+ ["declared"],+ "recovers declarations when persistence removed every output sample"+ );+ const preview = outputPreviewForNode(compacted, "Sample", { node, graph });+ assert.deepEqual(+ preview.summary,+ { itemCount: 24, truncated: true },+ "keeps the real compacted-run summary alongside declared fields"+ );+ assert.deepEqual(keys(preview.fields), ["declared"]);+ });++ test("schemaFieldsForNodeOutput ignores runs for another node with the same name", function (assert) {+ const runData = {+ Log: [+ successRun({+ node_id: "old-log",+ node_type: "action:log",+ outputs: [port(0, [{ stale: true }])],+ }),+ ],+ };+ const node = { id: "new-log", name: "Log", type: "action:log" };++ assert.deepEqual(schemaFieldsForNodeOutput(runData, "Log", { node }), []);+ assert.strictEqual(outputSummaryForNode(runData, "Log", 0, { node }), null);+ });++ test("outputPreviewForNode combines output indexes into one preview item", function (assert) {+ const runData = {+ "Node 1": [+ successRun({+ outputs: [+ port(0, [{ matched: true }]),+ port(1, [{ rejected: true }]),+ ],+ }),+ ],+ };+ const preview = outputPreviewForNode(runData, "Node 1");++ assert.deepEqual(preview.summary, { itemCount: 1, truncated: false });+ assert.deepEqual(keys(preview.fields), ["matched", "rejected"]);+ });++ test("schemaFieldsForNodeInput reads recorded inputs and previews upstream output", function (assert) {+ const recorded = {+ "Node 1": [+ successRun({+ inputs: [+ port(1, [{ topic: { id: 1 } }], {+ item_count: 2,+ source: { node_name: "Upstream", output_index: 0 },+ }),+ ],+ }),+ ],+ };++ assert.deepEqual(+ keys(schemaFieldsForNodeInput(recorded, "Node 1", { inputIndex: 1 })),+ ["topic"],+ "reads the recorded input port"+ );+ assert.deepEqual(inputSummaryForNode(recorded, "Node 1", 1), {+ inputIndex: 1,+ itemCount: 2,+ truncated: false,+ });++ const currentNode = { id: "post", name: "Post", type: "action:post" };+ const sourceNode = {+ id: "template",+ name: "Template",+ type: "action:template",+ };+ const previewData = {+ Template: [+ successRun({+ node_id: "template",+ node_type: "action:template",+ outputs: [port(0, [{ template: "Rendered body" }])],+ }),+ ],+ Post: [+ {+ node_id: "post",+ node_type: "action:post",+ status: "skipped",+ inputs: [port(0, [{ template: "Rendered body" }], { source: null })],+ },+ ],+ };++ assert.deepEqual(+ keys(+ schemaFieldsForNodeInput(previewData, "Post", {+ node: currentNode,+ sourceNode,+ outputIndex: 0,+ })+ ),+ ["template"],+ "previews the connected upstream output before the current node succeeds"+ );+ assert.deepEqual(+ inputSummaryForNode(previewData, "Post", 0, {+ node: currentNode,+ sourceNode,+ outputIndex: 0,+ }),+ { inputIndex: 0, itemCount: 1, truncated: false }+ );+ });++ test("a successful run with a stale recorded source yields no input preview", function (assert) {+ const { sourceNode, currentNode, graph } = sourceCurrentGraph();+ const runData = {+ Source: [+ successRun({+ node_id: "source",+ node_type: "trigger:source",+ outputs: [port(0, [{ fresh: true }])],+ }),+ ],+ Current: [+ successRun({+ node_id: "current",+ node_type: "action:current",+ inputs: [+ port(0, [{ stale: true }], {+ source: { node_name: "Old source", output_index: 0 },+ }),+ ],+ }),+ ],+ };++ assert.deepEqual(+ schemaFieldsForNodeInput(runData, "Current", {+ node: currentNode,+ sourceNode,+ graph,+ outputIndex: 0,+ }),+ [],+ "does not expose fields from a stale source, a declaration or the source output"+ );+ assert.strictEqual(+ inputSummaryForNode(runData, "Current", 0, {+ node: currentNode,+ sourceNode,+ outputIndex: 0,+ }),+ null,+ "does not expose input summary from a stale source"+ );+ });++ test("schemaFieldsForNodeInput recovers declarations from a fully compacted port", function (assert) {+ const { sourceNode, currentNode, graph } = sourceCurrentGraph();+ const runData = {+ Current: [+ successRun({+ inputs: [+ port(0, [], {+ item_count: 15,+ truncated: true,+ source: { node_name: "Source", output_index: 0 },+ }),+ ],+ }),+ ],+ };++ assert.deepEqual(+ keys(+ schemaFieldsForNodeInput(runData, "Current", {+ node: currentNode,+ sourceNode,+ graph,+ })+ ),+ ["declared"],+ "uses the source declaration when persistence removed every input sample"+ );+ assert.deepEqual(+ inputSummaryForNode(runData, "Current", 0, {+ node: currentNode,+ sourceNode,+ }),+ { inputIndex: 0, itemCount: 15, truncated: true },+ "preserves the actual compacted input count"+ );+ });++ test("schemaFieldsForNodeInput prefers recorded and pinned items over declarations", function (assert) {+ const { sourceNode, currentNode, graph } = sourceCurrentGraph();+ const pinnedItems = [+ { json: { pinned: true } },+ { json: { pinned: false } },+ ];++ assert.deepEqual(+ keys(+ schemaFieldsForNodeInput({}, "Current", {+ node: currentNode,+ sourceNode,+ graph,+ pinnedItems,+ })+ ),+ ["pinned"],+ "pinned source items win before the current node runs"+ );+ assert.deepEqual(+ inputSummaryForNode({}, "Current", 0, {+ node: currentNode,+ sourceNode,+ pinnedItems,+ }),+ { inputIndex: 0, itemCount: 2, truncated: false },+ "pinned items provide a real item summary"+ );++ const runData = {+ Current: [+ successRun({+ inputs: [+ port(0, [{ recorded: true }], {+ source: { node_name: "Source", output_index: 0 },+ }),+ ],+ }),+ ],+ };+ assert.deepEqual(+ keys(+ schemaFieldsForNodeInput(runData, "Current", {+ node: currentNode,+ sourceNode,+ graph,+ pinnedItems,+ })+ ),+ ["recorded"],+ "the current node's recorded input remains authoritative"+ );+ });+});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-schema-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-schema-test.jsdeleted file mode 100644index d4efff2d280..00000000000--- a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-data-schema-test.js+++ /dev/null@@ -1,517 +0,0 @@-import { module, test } from "qunit";-import {- ancestorOutputNodes,- exemplarFromFields,- inputConnectionsForNode,- inputFieldPrefixForConnection,- inputForRun,- inputSummaryForNode,- nodeOutputFirstJsonPath,- nodeOutputItemJsonPath,- nodeOutputJsonPath,- nodeOutputLinkedItemJsonPath,- outputForRun,- outputSchemaForNode,- outputSummaryForNode,- schemaFieldsForItems,- schemaFieldsForNodeInput,- schemaFieldsForNodeOutput,-} from "discourse/plugins/discourse-workflows/admin/lib/workflows/data-schema";--module("Unit | lib | discourse-workflows | data-schema", function () {- test("schemaFieldsForItems infers and merges nested JSON fields", function (assert) {- const fields = schemaFieldsForItems([- {- json: {- title: "Hello",- count: 1,- published: true,- author: { username: "sam" },- },- },- {- json: {- count: 2,- author: { id: 12 },- tags: ["support"],- },- },- ]);-- assert.deepEqual(- fields.map((field) => [field.key, field.type, field.id]),- [- ["title", "string", "$json.title"],- ["count", "number", "$json.count"],- ["published", "boolean", "$json.published"],- ["author", "object", "$json.author"],- ["tags", "array", "$json.tags"],- ]- );- assert.deepEqual(- fields.find((field) => field.key === "author").children.map((f) => f.key),- ["username", "id"]- );- assert.strictEqual(- fields.find((field) => field.key === "tags").children[0].id,- "$json.tags[0]"- );- });-- test("schemaFieldsForItems uses bracket paths for unsafe keys", function (assert) {- const fields = schemaFieldsForItems([- { json: { "topic title": { "post-count": 2 } } },- ]);-- assert.strictEqual(fields[0].id, '$json["topic title"]');- assert.strictEqual(- fields[0].children[0].id,- '$json["topic title"]["post-count"]'- );- });-- test("schemaFieldsForItems preserves null values", function (assert) {- const fields = schemaFieldsForItems([- { json: { deleted_at: null, title: null } },- { json: { title: "Topic" } },- ]);-- const deletedAt = fields.find((field) => field.key === "deleted_at");- const title = fields.find((field) => field.key === "title");-- assert.strictEqual(deletedAt.type, "null");- assert.strictEqual(deletedAt.value, null);- assert.strictEqual(title.type, "string");- assert.strictEqual(title.value, "Topic");- assert.deepEqual(exemplarFromFields(fields), {- deleted_at: null,- title: "Topic",- });- });-- test("schemaFieldsForNodeOutput uses the latest successful run", function (assert) {- const runData = {- "Node 1": [- {- status: "success",- outputs: [- { index: 0, items: [{ json: { old: true } }], item_count: 1 },- ],- },- {- status: "success",- outputs: [- { index: 0, items: [{ json: { current: true } }], item_count: 1 },- ],- },- ],- };-- assert.deepEqual(- schemaFieldsForNodeOutput(runData, "Node 1").map((f) => f.key),- ["current"]- );- });-- test("schemaFieldsForNodeOutput does not reuse older item data after a zero-item run", function (assert) {- const runData = {- "Node 1": [- {- status: "success",- outputs: [- { index: 0, items: [{ json: { stale: true } }], item_count: 1 },- ],- },- {- status: "success",- outputs: [{ index: 0, items: [], item_count: 0 }],- },- ],- };-- assert.deepEqual(schemaFieldsForNodeOutput(runData, "Node 1"), []);- assert.deepEqual(outputSummaryForNode(runData, "Node 1"), {- outputIndex: 0,- itemCount: 0,- truncated: false,- });- });-- test("schemaFieldsForNodeOutput ignores runs for another node with the same name", function (assert) {- const runData = {- Log: [- {- node_id: "old-log",- node_type: "action:log",- status: "success",- outputs: [- { index: 0, items: [{ json: { stale: true } }], item_count: 1 },- ],- },- ],- };- const node = { id: "new-log", name: "Log", type: "action:log" };-- assert.deepEqual(- schemaFieldsForNodeOutput(runData, "Log", { node }),- [],- "does not expose output from a different node id"- );- assert.strictEqual(- outputSummaryForNode(runData, "Log", 0, { node }),- null,- "does not expose summary from a different node id"- );- });-- test("outputForRun keeps output indexes positional", function (assert) {- const run = {- outputs: [{ index: 0, items: [{ json: { primary: true } }] }],- };-- assert.strictEqual(outputForRun(run, 1), null);- });-- test("outputSchemaForNode combines output indexes into one preview item", function (assert) {- const runData = {- "Node 1": [- {- status: "success",- outputs: [- { index: 0, items: [{ json: { matched: true } }], item_count: 1 },- {- index: 1,- items: [{ json: { rejected: true } }],- item_count: 1,- },- ],- },- ],- };- const schema = outputSchemaForNode(runData, "Node 1");-- assert.deepEqual(schema.summary, {- itemCount: 1,- truncated: false,- });- assert.deepEqual(- schema.fields.map((field) => field.key),- ["matched", "rejected"]- );- });-- test("schemaFieldsForNodeInput reads recorded node inputs", function (assert) {- const runData = {- "Node 1": [- {- status: "success",- inputs: [- {- index: 1,- items: [{ json: { topic: { id: 1 } } }],- item_count: 2,- source: { node_name: "Upstream", output_index: 0 },- },- ],- },- ],- };-- assert.deepEqual(- schemaFieldsForNodeInput(runData, "Node 1", { inputIndex: 1 }).map(- (f) => f.key- ),- ["topic"]- );- assert.deepEqual(inputSummaryForNode(runData, "Node 1", 1), {- inputIndex: 1,- itemCount: 2,- truncated: false,- });- assert.strictEqual(inputForRun(runData["Node 1"][0], 0), null);- });-- test("schemaFieldsForNodeInput ignores recorded inputs from another source", function (assert) {- const currentNode = { id: "log", name: "Log", type: "action:log" };- const sourceNode = {- id: "post-moved",- name: "Post moved",- type: "trigger:post_moved",- };- const runData = {- Log: [- {- node_id: "log",- node_type: "action:log",- status: "success",- inputs: [- {- index: 0,- items: [{ json: { reviewable: { id: 1 } } }],- item_count: 1,- source: { node_name: "Approved reviewable", output_index: 0 },- },- ],- },- ],- "Post moved": [- {- node_id: "post-moved",- node_type: "trigger:post_moved",- status: "success",- outputs: [- { index: 0, items: [{ json: { post: { id: 1 } } }], item_count: 1 },- ],- },- ],- };-- assert.deepEqual(- schemaFieldsForNodeInput(runData, "Log", {- node: currentNode,- sourceNode,- outputIndex: 0,- }),- [],- "does not expose input fields from a stale source"- );- assert.strictEqual(- inputSummaryForNode(runData, "Log", 0, {- node: currentNode,- sourceNode,- outputIndex: 0,- }),- null,- "does not expose input summary from a stale source"- );- });-- test("schemaFieldsForNodeInput previews connected upstream output before the current node succeeds", function (assert) {- const currentNode = {- id: "post",- name: "Post",- type: "action:post",- };- const sourceNode = {- id: "template",- name: "Template",- type: "action:template",- };- const runData = {- Template: [- {- node_id: "template",- node_type: "action:template",- status: "success",- outputs: [- {- index: 0,- items: [{ json: { template: "Rendered body" } }],- item_count: 1,- },- ],- },- ],- Post: [- {- node_id: "post",- node_type: "action:post",- status: "skipped",- inputs: [- {- index: 0,- items: [{ json: { template: "Rendered body" } }],- item_count: 1,- source: null,- },- ],- },- ],- };-- assert.deepEqual(- schemaFieldsForNodeInput(runData, "Post", {- node: currentNode,- sourceNode,- outputIndex: 0,- }).map((field) => field.key),- ["template"]- );- assert.deepEqual(- inputSummaryForNode(runData, "Create post", 0, {- node: currentNode,- sourceNode,- outputIndex: 0,- }),- {- inputIndex: 0,- itemCount: 1,- truncated: false,- }- );- });-- test("nodeOutputFirstJsonPath escapes node names and output indexes for expressions", function (assert) {- assert.strictEqual(- nodeOutputFirstJsonPath('Fetch "quoted" \\ data', { outputIndex: 1 }),- '$("Fetch \\"quoted\\" \\\\ data").first(1).json'- );- assert.strictEqual(- nodeOutputFirstJsonPath("Fetch data"),- '$("Fetch data").first().json'- );- });-- test("nodeOutputLinkedItemJsonPath escapes node names for expressions", function (assert) {- assert.strictEqual(- nodeOutputLinkedItemJsonPath('Fetch "quoted" \\ data'),- '$("Fetch \\"quoted\\" \\\\ data").item.json'- );- });-- test("nodeOutputJsonPath uses the simplest safe output expression", function (assert) {- const runData = {- Aggregate: [- {- status: "success",- outputs: [- {- index: 0,- items: [{ json: { markdown: "summary" } }],- item_count: 1,- },- ],- },- ],- "Per item": [- {- status: "success",- outputs: [- {- index: 0,- items: [{ json: { name: "Ada" } }, { json: { name: "Grace" } }],- item_count: 2,- },- ],- },- ],- };-- assert.strictEqual(- nodeOutputJsonPath(runData, "Aggregate"),- '$("Aggregate").first().json'- );- assert.strictEqual(- nodeOutputJsonPath(runData, "Per item"),- '$("Per item").item.json'- );- });-- test("nodeOutputItemJsonPath builds explicit output and item index references", function (assert) {- assert.strictEqual(- nodeOutputItemJsonPath("Second input", { outputIndex: 1 }),- '$("Second input").all(1)[$itemIndex].json'- );- });-- test("inputFieldPrefixForConnection uses $json only for the primary input connection", function (assert) {- const primaryConnection = {- sourceClientId: "left",- targetClientId: "merge",- targetInputIndex: 0,- };- const secondaryConnection = {- sourceClientId: "right",- targetClientId: "merge",- targetInputIndex: 1,- sourceOutputIndex: 2,- };-- assert.strictEqual(- inputFieldPrefixForConnection(- primaryConnection,- { name: "Left" },- { primaryConnection }- ),- "$json"- );- assert.strictEqual(- inputFieldPrefixForConnection(- secondaryConnection,- { name: "Right" },- { primaryConnection }- ),- '$("Right").all(2)[$itemIndex].json'- );- });-- test("outputSummaryForNode exposes item counts and truncation metadata", function (assert) {- const runData = {- "Node 1": [- {- status: "success",- outputs: [- {- index: 1,- items: [{ json: { value: 1 } }],- item_count: 3,- truncated: true,- },- ],- },- ],- };-- assert.deepEqual(outputSummaryForNode(runData, "Node 1", 1), {- outputIndex: 1,- itemCount: 3,- truncated: true,- });- });-- test("ancestorOutputNodes follows the upstream chain with output indexes", function (assert) {- const trigger = { clientId: "trigger" };- const branch = { clientId: "branch" };- const current = { clientId: "current" };- const graph = {- nodes: [trigger, branch, current],- connections: [- { sourceClientId: "trigger", targetClientId: "branch" },- {- sourceClientId: "branch",- targetClientId: "current",- sourceOutputIndex: 1,- },- ],- };-- assert.deepEqual(ancestorOutputNodes(current, graph), [- { node: branch, outputIndex: 1 },- { node: trigger, outputIndex: 0 },- ]);- });-- test("inputConnectionsForNode returns all incoming connections by input index", function (assert) {- const graph = {- connections: [- {- sourceClientId: "right",- targetClientId: "merge",- targetInputIndex: 1,- },- {- sourceClientId: "left",- targetClientId: "merge",- targetInputIndex: 0,- },- ],- };-- assert.deepEqual(- inputConnectionsForNode({ clientId: "merge" }, graph).map(- (connection) => connection.sourceClientId- ),- ["left", "right"]- );- });-});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-expression-paths-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-expression-paths-test.jsnew file mode 100644index 00000000000..dc300ad28f8--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-expression-paths-test.js@@ -0,0 +1,109 @@+import { module, test } from "qunit";+import {+ inputFieldPrefixForConnection,+ nodeOutputFirstJsonPath,+ nodeOutputItemJsonPath,+ nodeOutputJsonPath,+ nodeOutputLinkedItemJsonPath,+} from "discourse/plugins/discourse-workflows/admin/lib/workflows/expression-paths";++module("Unit | lib | discourse-workflows | expression-paths", function () {+ test("nodeOutputFirstJsonPath escapes node names and output indexes for expressions", function (assert) {+ assert.strictEqual(+ nodeOutputFirstJsonPath('Fetch "quoted" \\ data', { outputIndex: 1 }),+ '$("Fetch \\"quoted\\" \\\\ data").first(1).json'+ );+ assert.strictEqual(+ nodeOutputFirstJsonPath("Fetch data"),+ '$("Fetch data").first().json'+ );+ });++ test("nodeOutputLinkedItemJsonPath escapes node names for expressions", function (assert) {+ assert.strictEqual(+ nodeOutputLinkedItemJsonPath('Fetch "quoted" \\ data'),+ '$("Fetch \\"quoted\\" \\\\ data").item.json'+ );+ });++ test("nodeOutputJsonPath uses the simplest safe output expression", function (assert) {+ const runData = {+ Aggregate: [+ {+ status: "success",+ outputs: [+ {+ index: 0,+ items: [{ json: { markdown: "summary" } }],+ item_count: 1,+ },+ ],+ },+ ],+ "Per item": [+ {+ status: "success",+ outputs: [+ {+ index: 0,+ items: [{ json: { name: "Ada" } }, { json: { name: "Grace" } }],+ item_count: 2,+ },+ ],+ },+ ],+ };++ assert.strictEqual(+ nodeOutputJsonPath(runData, "Aggregate"),+ '$("Aggregate").first().json'+ );+ assert.strictEqual(+ nodeOutputJsonPath(runData, "Per item"),+ '$("Per item").item.json'+ );+ assert.strictEqual(+ nodeOutputJsonPath(runData, "Aggregate", { itemCount: 2 }),+ '$("Aggregate").item.json',+ "an effective pinned item count overrides the stale run count"+ );+ });++ test("nodeOutputItemJsonPath builds explicit output and item index references", function (assert) {+ assert.strictEqual(+ nodeOutputItemJsonPath("Second input", { outputIndex: 1 }),+ '$("Second input").all(1)[$itemIndex].json'+ );+ });++ test("inputFieldPrefixForConnection uses $json only for the primary input connection", function (assert) {+ const primaryConnection = {+ sourceClientId: "left",+ targetClientId: "merge",+ targetInputIndex: 0,+ };+ const secondaryConnection = {+ sourceClientId: "right",+ targetClientId: "merge",+ targetInputIndex: 1,+ sourceOutputIndex: 2,+ };++ assert.strictEqual(+ inputFieldPrefixForConnection(+ primaryConnection,+ { name: "Left" },+ { primaryConnection }+ ),+ "$json"+ );+ assert.strictEqual(+ inputFieldPrefixForConnection(+ secondaryConnection,+ { name: "Right" },+ { primaryConnection }+ ),+ '$("Right").all(2)[$itemIndex].json'+ );+ });+});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-node-types-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-node-types-test.jsindex 662e64a41ad..3e2aa9cc97b 100644--- a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-node-types-test.js+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-node-types-test.js@@ -130,6 +130,16 @@ module("Unit | Utility | workflows node types", function () {"old",]);assert.deepEqual(nodeTypeOutputKeys(nodeType), ["new"]);+ assert.strictEqual(+ resolveNodeTypeVersion(nodeType, "3.0"),+ null,+ "an unregistered version does not fall back to latest"+ );+ assert.deepEqual(+ nodeTypeOutputKeys(nodeType, {}),+ ["old"],+ "a node without a typeVersion uses the default version, not latest"+ );});test("detects configurable node type fields from metadata", function (assert) {diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-run-data-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-run-data-test.jsnew file mode 100644index 00000000000..a8b47128d91--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-run-data-test.js@@ -0,0 +1,32 @@+import { module, test } from "qunit";+import {+ inputForRun,+ outputForRun,+} from "discourse/plugins/discourse-workflows/admin/lib/workflows/run-data";++module("Unit | lib | discourse-workflows | run-data", function () {+ test("outputForRun keeps output indexes positional", function (assert) {+ const run = {+ outputs: [{ index: 0, items: [{ json: { primary: true } }] }],+ };++ assert.strictEqual(outputForRun(run, 1), null);+ });++ test("inputForRun keeps input indexes positional", function (assert) {+ const run = {+ inputs: [+ {+ index: 1,+ items: [{ json: { topic: { id: 1 } } }],+ },+ ],+ };++ assert.strictEqual(+ inputForRun(run, 0),+ null,+ "does not fall back to a differently indexed input"+ );+ });+});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-fields-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-fields-test.jsnew file mode 100644index 00000000000..3708c4e347e--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-fields-test.js@@ -0,0 +1,279 @@+import { module, test } from "qunit";+import {+ fieldsForSchema,+ schemaFieldsForItems,+} from "discourse/plugins/discourse-workflows/admin/lib/workflows/schema-fields";++module("Unit | lib | discourse-workflows | schema-fields", function () {+ test("fieldsForSchema converts JSON Schemas into draggable fields", function (assert) {+ const fields = fieldsForSchema({+ type: "object",+ properties: {+ topic: {+ type: "object",+ description: "Topic serializer payload",+ properties: {+ created_at: { type: "string", format: "date-time" },+ score: { type: ["number", "null"] },+ tags: { type: "array", items: { type: "string" } },+ groups: {+ type: "array",+ items: {+ type: "object",+ properties: { id: { type: "integer" } },+ },+ },+ },+ },+ action: { type: "string", const: "added" },+ },+ });+ const topic = fields.find((field) => field.key === "topic");+ const createdAt = topic.children.find(+ (field) => field.key === "created_at"+ );+ const score = topic.children.find((field) => field.key === "score");+ const tags = topic.children.find((field) => field.key === "tags");+ const groups = topic.children.find((field) => field.key === "groups");+ const action = fields.find((field) => field.key === "action");++ assert.strictEqual(topic.type, "object", "descriptive roots are objects");+ assert.strictEqual(+ topic.description,+ "Topic serializer payload",+ "preserves descriptions"+ );+ assert.deepEqual(+ [createdAt.type, createdAt.format, createdAt.id],+ ["string", "date-time", "$json.topic.created_at"],+ "preserves formats"+ );+ assert.deepEqual(+ [score.type, score.nullable],+ ["number", true],+ "normalizes nullable type arrays"+ );+ assert.deepEqual(+ [tags.type, tags.children[0].type, tags.children[0].id],+ ["array", "string", "$json.topic.tags[0]"],+ "adds a typed array item path at index 0"+ );+ assert.deepEqual(+ [+ groups.children[0].type,+ groups.children[0].children[0].type,+ groups.children[0].children[0].id,+ ],+ ["object", "integer", "$json.topic.groups[0].id"],+ "adds draggable paths for object array fields"+ );+ assert.deepEqual(+ [action.type, action.value, action.id],+ ["string", "added", "$json.action"],+ "preserves literal types"+ );+ });++ test("fieldsForSchema only traverses schema properties", function (assert) {+ assert.deepEqual(+ fieldsForSchema({ declared: "string" }),+ [],+ "flat maps that are not JSON Schema produce no fields"+ );+ assert.deepEqual(+ fieldsForSchema({ type: "string" }),+ [],+ "non-object schemas produce no fields"+ );+ });++ test("fieldsForSchema does not narrow conflicting type unions", function (assert) {+ const fields = fieldsForSchema({+ type: "object",+ properties: {+ conflict: { type: ["string", "integer"] },+ numeric: { type: ["integer", "number", "null"] },+ nullableInteger: { type: ["integer", "null"] },+ nullableString: { type: ["string", "null"] },+ },+ });++ assert.deepEqual(+ fields.map((field) => [field.key, field.type, field.nullable]),+ [+ ["conflict", "unknown", undefined],+ ["numeric", "number", true],+ ["nullableInteger", "integer", true],+ ["nullableString", "string", true],+ ],+ "keeps conflicts unknown while canonicalizing compatible numeric types"+ );+ });++ test("fieldsForSchema merges anyOf branches for display", function (assert) {+ const fields = fieldsForSchema({+ anyOf: [+ {+ type: "object",+ properties: {+ id: { type: "integer" },+ title: { type: "string" },+ subtitle: { anyOf: [{ type: "string" }, { type: "null" }] },+ },+ },+ {+ type: "object",+ properties: {+ id: { type: "string" },+ deleted: { type: "boolean" },+ },+ },+ ],+ });++ assert.deepEqual(+ fields.map((field) => field.key),+ ["id", "title", "subtitle", "deleted"],+ "unions properties from every branch"+ );+ assert.strictEqual(+ fields.find((field) => field.key === "id").type,+ "unknown",+ "conflicting branch types stay unknown"+ );+ assert.deepEqual(+ fields+ .filter((field) => ["title", "deleted"].includes(field.key))+ .map((field) => field.type),+ ["string", "boolean"],+ "branch-specific properties keep their own types"+ );+ assert.deepEqual(+ [+ fields.find((field) => field.key === "subtitle").type,+ fields.find((field) => field.key === "subtitle").nullable,+ ],+ ["string", true],+ "nested anyOf with a null branch becomes nullable"+ );+ });++ test("fieldsForSchema infers types from const values", function (assert) {+ const fields = fieldsForSchema({+ type: "object",+ properties: {+ action: { const: "added" },+ count: { const: 3 },+ flag: { const: true },+ },+ });++ assert.deepEqual(+ fields.map((field) => [field.key, field.type, field.value]),+ [+ ["action", "string", "added"],+ ["count", "integer", 3],+ ["flag", "boolean", true],+ ],+ "const provides both the value and the inferred type"+ );+ });++ test("fieldsForSchema uses bracket paths for unsafe keys", function (assert) {+ const fields = fieldsForSchema({+ type: "object",+ properties: {+ "topic title": {+ type: "object",+ properties: {+ "post-count": { type: "integer" },+ },+ },+ },+ });++ assert.strictEqual(fields[0].id, '$json["topic title"]');+ assert.strictEqual(+ fields[0].children[0].id,+ '$json["topic title"]["post-count"]'+ );+ });++ test("fieldsForSchema honors the prefix option", function (assert) {+ const fields = fieldsForSchema(+ {+ type: "object",+ properties: { title: { type: "string" } },+ },+ { prefix: "$item" }+ );++ assert.strictEqual(fields[0].id, "$item.title");+ });++ test("schemaFieldsForItems infers and merges nested JSON fields", function (assert) {+ const fields = schemaFieldsForItems([+ {+ json: {+ title: "Hello",+ count: 1,+ published: true,+ author: { username: "sam" },+ },+ },+ {+ json: {+ count: 2,+ author: { id: 12 },+ tags: ["support"],+ },+ },+ ]);++ assert.deepEqual(+ fields.map((field) => [field.key, field.type, field.id]),+ [+ ["title", "string", "$json.title"],+ ["count", "number", "$json.count"],+ ["published", "boolean", "$json.published"],+ ["author", "object", "$json.author"],+ ["tags", "array", "$json.tags"],+ ]+ );+ assert.deepEqual(+ fields.find((field) => field.key === "author").children.map((f) => f.key),+ ["username", "id"]+ );+ assert.strictEqual(+ fields.find((field) => field.key === "tags").children[0].id,+ "$json.tags[0]"+ );+ });++ test("schemaFieldsForItems uses bracket paths for unsafe keys", function (assert) {+ const fields = schemaFieldsForItems([+ { json: { "topic title": { "post-count": 2 } } },+ ]);++ assert.strictEqual(fields[0].id, '$json["topic title"]');+ assert.strictEqual(+ fields[0].children[0].id,+ '$json["topic title"]["post-count"]'+ );+ });++ test("schemaFieldsForItems preserves null values", function (assert) {+ const fields = schemaFieldsForItems([+ { json: { deleted_at: null, title: null } },+ { json: { title: "Topic" } },+ ]);++ const deletedAt = fields.find((field) => field.key === "deleted_at");+ const title = fields.find((field) => field.key === "title");++ assert.strictEqual(deletedAt.type, "null");+ assert.strictEqual(deletedAt.value, null);+ assert.strictEqual(title.type, "string");+ assert.strictEqual(title.value, "Topic");+ });+});diff --git a/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-graph-test.js b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-graph-test.jsnew file mode 100644index 00000000000..735c4b70971--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/unit/lib/workflows-schema-graph-test.js@@ -0,0 +1,531 @@+import { module, test } from "qunit";+import {+ ancestorOutputNodes,+ inputConnectionsForNode,+ outputSchemaForNode,+ previousNodeForConnection,+ resolveDeclaredOutputSchemas,+} from "discourse/plugins/discourse-workflows/admin/lib/workflows/schema-graph";++const DRAFT_URI = "https://json-schema.org/draft/2020-12/schema";++function objectSchema(properties, extra = {}) {+ return { type: "object", properties, ...extra };+}++function prop(name, type) {+ return objectSchema({ [name]: { type } });+}++function node(clientId, type, extra = {}) {+ return { clientId, type, typeVersion: "1.0", ...extra };+}++function conn(sourceClientId, targetClientId, extra = {}) {+ return { sourceClientId, targetClientId, ...extra };+}++function nodeType(name, contracts) {+ return { name, versions: { "1.0": { output_contracts: contracts } } };+}++function triggerType(name, schema) {+ return nodeType(name, [{ schema }]);+}++const PASSTHROUGH_TYPE = nodeType("flow:passthrough", [+ { mode: "passthrough" },+]);+const UNKNOWN_TRIGGER_TYPE = {+ name: "trigger:unknown",+ versions: { "1.0": {} },+};++module("Unit | lib | discourse-workflows | schema-graph", function () {+ test("output positions, visited nodes and out-of-graph nodes", function (assert) {+ const kept = prop("kept", "boolean");+ const rejected = prop("rejected", "boolean");+ const source = node("source", "condition:branch");+ const nodeTypes = [+ nodeType("condition:branch", [{ schema: kept }, { schema: rejected }]),+ PASSTHROUGH_TYPE,+ ];+ const graph = {+ nodes: [source, node("target", "flow:passthrough")],+ connections: [+ conn("source", "target", { sourceOutputIndex: 1, targetInputIndex: 1 }),+ ],+ nodeTypes,+ };+ const out = (n, opts) => outputSchemaForNode(n, graph, opts);++ assert.deepEqual(+ resolveDeclaredOutputSchemas(graph).get("source"),+ [kept, rejected],+ "each output port resolves its own schema"+ );+ assert.deepEqual(+ out(source, { outputIndex: 1 }),+ rejected,+ "outputIndex selects the port on the resolved node"+ );+ assert.deepEqual(out(graph.nodes[1]), rejected, "routes the source port");++ const resolved = resolveDeclaredOutputSchemas(graph, {+ visited: new Set(["source"]),+ });+ assert.false(resolved.has("source"), "visited nodes are not resolved");+ assert.deepEqual(resolved.get("target"), [{}], "visited links ignored");+ assert.deepEqual(+ out(source, { visited: new Set(["source"]) }),+ {},+ "a visited node resolves to unknown"+ );+ assert.deepEqual(out(null), {}, "a missing node resolves to unknown");++ const detached = node("detached", "flow:passthrough");+ const partial = {+ nodes: [source],+ connections: [conn("source", "detached")],+ nodeTypes,+ };+ assert.deepEqual(+ outputSchemaForNode(detached, partial),+ kept,+ "a node missing from the graph is appended to the resolution graph"+ );+ assert.strictEqual(partial.nodes.length, 1, "the graph is left untouched");+ });++ test("merge contracts resolve saved versions and overlay shallowly", function (assert) {+ const input = objectSchema(+ { root: { type: "string" }, shared: prop("left", "string") },+ { required: ["shared"] }+ );+ const declared = objectSchema(+ { shared: prop("own", "boolean"), extra: { type: "integer" } },+ { required: ["extra"] }+ );+ const v1 = { version: "1.0", output_contracts: [{ schema: input }] };+ const v2 = {+ version: "2.0",+ output_contracts: [{ schema: prop("latest", "boolean") }],+ };+ const staleLatest = {+ version: "2.0",+ output_contracts: [{ mode: "merge", schema: prop("latest", "boolean") }],+ };+ const merge = node("merge", "action:merge");+ const stale = node("stale", "action:versioned");+ const noOverlay = node("no-overlay", "action:no-overlay");+ const overlayOnly = node("overlay-only", "action:merge");+ const graph = {+ nodes: [+ node("source", "trigger:versioned"),+ node("unknown-source", "trigger:unknown"),+ merge,+ stale,+ noOverlay,+ overlayOnly,+ ],+ connections: [+ conn("source", "merge"),+ conn("source", "stale"),+ conn("source", "no-overlay"),+ conn("unknown-source", "overlay-only"),+ ],+ nodeTypes: [+ {+ name: "trigger:versioned",+ latest: v2,+ versions: { "1.0": v1, "2.0": v2 },+ },+ {+ name: "action:versioned",+ ...staleLatest,+ latest: staleLatest,+ versions: { "1.0": { version: "1.0" }, "2.0": staleLatest },+ },+ nodeType("action:merge", [{ mode: "merge", schema: declared }]),+ nodeType("action:no-overlay", [{ mode: "merge" }]),+ UNKNOWN_TRIGGER_TYPE,+ ],+ };+ const out = (n) => outputSchemaForNode(n, graph);++ assert.deepEqual(+ out(merge),+ objectSchema(+ {+ root: { type: "string" },+ shared: prop("own", "boolean"),+ extra: { type: "integer" },+ },+ { required: ["shared", "extra"] }+ ),+ "the saved trigger version feeds the merge, which keeps input root properties, replaces a colliding property wholesale and unions required"+ );+ assert.deepEqual(out(stale), {}, "saved versions do not inherit latest");+ assert.deepEqual(out(noOverlay), input, "empty declarations keep input");+ assert.deepEqual(out(overlayOnly), declared, "declared replaces unknown");+ });++ test("unregistered and missing type versions resolve like the server", function (assert) {+ const v1Schema = prop("from_v1", "string");+ const v2Schema = prop("from_v2", "string");+ const legacy = { clientId: "legacy", type: "trigger:versioned" };+ const stale = node("stale", "trigger:versioned", { typeVersion: "9.0" });+ const current = node("current", "trigger:versioned");+ const join = node("join", "flow:passthrough");+ const graph = {+ nodes: [legacy, stale, current, join],+ connections: [conn("current", "join"), conn("stale", "join")],+ nodeTypes: [+ {+ name: "trigger:versioned",+ latest: { version: "2.0", output_contracts: [{ schema: v2Schema }] },+ versions: {+ "1.0": { version: "1.0", output_contracts: [{ schema: v1Schema }] },+ "2.0": { version: "2.0", output_contracts: [{ schema: v2Schema }] },+ },+ },+ PASSTHROUGH_TYPE,+ ],+ };+ const out = (n) => outputSchemaForNode(n, graph);++ assert.deepEqual(+ out(current),+ v1Schema,+ "a registered typeVersion resolves its own declaration"+ );+ assert.deepEqual(+ out(stale),+ {},+ "an unregistered typeVersion resolves to unknown instead of latest"+ );+ assert.deepEqual(+ out(legacy),+ v1Schema,+ "a missing typeVersion resolves the default version, not latest"+ );+ assert.deepEqual(+ out(join),+ {},+ "an unknown version keeps downstream unions unknown"+ );+ });++ test("contract selection applies variants, display rules and overrides", function (assert) {+ const src = prop("source", "string");+ const hook = prop("body", "object");+ const base = prop("base", "string");+ const variant = prop("variant", "integer");+ const wait = node("wait", "flow:wait", {+ configuration: { resume: "time" },+ });+ const chooser = node("chooser", "action:chooser");+ const graph = {+ nodes: [node("source", "trigger:source"), wait, chooser],+ connections: [conn("source", "wait"), conn("source", "chooser")],+ nodeTypes: [+ triggerType("trigger:source", src),+ nodeType("flow:wait", [+ {+ variants: [+ {+ mode: "passthrough",+ display_options: { show: { resume: ["time"] } },+ },+ {+ schema: hook,+ mode: "replace",+ display_options: { show: { resume: ["webhook"] } },+ },+ ],+ },+ ]),+ nodeType("action:chooser", [+ {+ schema: base,+ display_options: { show: { mode: ["base"] } },+ variants: [+ {+ schema: variant,+ display_options: { show: { mode: ["variant"] } },+ },+ ],+ },+ ]),+ ],+ };+ const out = (n, opts) => outputSchemaForNode(n, graph, opts);++ assert.deepEqual(out(wait), src, "stored config picks passthrough");+ assert.deepEqual(+ out(wait, { configuration: { resume: "webhook" } }),+ hook,+ "a current configuration override selects the replacement variant"+ );+ assert.deepEqual(+ resolveDeclaredOutputSchemas(graph, {+ configurationOverrides: new Map([["wait", { resume: "webhook" }]]),+ }).get("wait"),+ [hook],+ "graph-level configuration overrides select the same variant"+ );+ assert.deepEqual(+ out(chooser, { configuration: { mode: "variant" } }),+ variant,+ "a matching variant wins over the base contract"+ );+ assert.deepEqual(+ out(chooser, { configuration: { mode: "base" } }),+ base,+ "the base contract applies when only its display options match and replace ignores the connected input"+ );+ assert.deepEqual(+ out(chooser, { configuration: { mode: "other" } }),+ {},+ "no matching contract resolves to unknown without passing the input through"+ );+ });++ test("joins, union contracts and cycles resolve across the graph", function (assert) {+ const str = prop("v", "string");+ const num = prop("v", "integer");+ const third = prop("t", "boolean");+ const join = node("join", "flow:passthrough");+ const dedup = node("dedup", "flow:passthrough");+ const pjoin = node("pjoin", "flow:passthrough");+ const extend = node("extend", "union:extend");+ const same = node("same", "union:same");+ const chain = node("chain", "union:chain");+ const punion = node("punion", "union:extend");+ const seededA = node("seeded-a", "flow:passthrough");+ const loopA = node("loop-a", "flow:passthrough");+ const cjoin = node("cjoin", "flow:passthrough");+ const graph = {+ nodes: [+ node("string-source", "trigger:string"),+ node("number-source", "trigger:number"),+ node("string-twin", "trigger:string"),+ node("unknown-source", "trigger:unknown"),+ node("seeded-b", "flow:passthrough"),+ node("loop-b", "flow:passthrough"),+ join,+ dedup,+ pjoin,+ extend,+ same,+ chain,+ punion,+ seededA,+ loopA,+ cjoin,+ ],+ connections: [+ conn("string-source", "join"),+ conn("number-source", "join"),+ conn("string-source", "dedup"),+ conn("string-twin", "dedup"),+ conn("string-source", "pjoin"),+ conn("unknown-source", "pjoin"),+ conn("string-source", "extend"),+ conn("string-source", "same"),+ conn("extend", "chain"),+ conn("unknown-source", "punion"),+ conn("string-source", "seeded-a"),+ conn("seeded-a", "seeded-b"),+ conn("seeded-b", "seeded-a"),+ conn("loop-a", "loop-b"),+ conn("loop-b", "loop-a"),+ conn("string-source", "cjoin"),+ conn("loop-a", "cjoin"),+ ],+ nodeTypes: [+ triggerType("trigger:string", str),+ triggerType("trigger:number", num),+ UNKNOWN_TRIGGER_TYPE,+ PASSTHROUGH_TYPE,+ nodeType("union:extend", [{ mode: "union", schema: num }]),+ nodeType("union:same", [{ mode: "union", schema: str }]),+ nodeType("union:chain", [{ mode: "union", schema: third }]),+ ],+ };+ const out = (n) => outputSchemaForNode(n, graph);++ assert.deepEqual(+ out(join),+ { $schema: DRAFT_URI, anyOf: [num, str] },+ "branch joins keep every incoming schema in canonical connection order"+ );+ assert.deepEqual(out(dedup), str, "identical branches collapse into one");+ assert.deepEqual(out(pjoin), {}, "an unknown branch poisons the join");+ assert.deepEqual(+ out(extend),+ { $schema: DRAFT_URI, anyOf: [str, num] },+ "the declared union schema becomes an extra anyOf alternative"+ );+ assert.deepEqual(out(same), str, "identical declared alternatives dedup");+ assert.deepEqual(+ out(chain),+ { $schema: DRAFT_URI, anyOf: [str, num, third] },+ "nested anyOf branches are flattened"+ );+ assert.deepEqual(out(punion), {}, "an unknown input poisons the union");+ assert.deepEqual(out(seededA), str, "a seeded cycle propagates the seed");+ assert.deepEqual(out(loopA), {}, "an unseeded cycle resolves to unknown");+ assert.deepEqual(out(cjoin), {}, "an unseeded cycle poisons joins");+ });++ test("merge contracts converge inside cycles by distributing over anyOf", function (assert) {+ const graph = {+ nodes: [+ node("seed", "trigger:seed"),+ node("first", "m:a"),+ node("second", "m:b"),+ ],+ connections: [+ conn("seed", "first"),+ conn("first", "second"),+ conn("second", "first"),+ ],+ nodeTypes: [+ triggerType("trigger:seed", prop("seed", "string")),+ nodeType("m:a", [{ mode: "merge", schema: prop("a", "string") }]),+ nodeType("m:b", [{ mode: "merge", schema: prop("b", "string") }]),+ ],+ };++ const resolved = resolveDeclaredOutputSchemas(graph);+ assert.deepEqual(+ resolved.get("second"),+ [+ objectSchema({+ seed: { type: "string" },+ a: { type: "string" },+ b: { type: "string" },+ }),+ ],+ "the loop-back merge accumulates every declared property exactly once"+ );+ assert.deepEqual(+ resolved.get("first")[0].anyOf?.length,+ 2,+ "the merge inside the cycle keeps flat, bounded alternatives"+ );+ });++ test("resolution reads each declaration once and is reusable per node", function (assert) {+ const src = prop("source", "string");+ const source = node("source", "trigger:source");+ const nodes = [source];+ const connections = [];+ let previousLayer = [source];+ let reads = 0;++ for (let layer = 0; layer < 20; layer++) {+ const currentLayer = ["left", "right"].map((side) =>+ node(`${side}-${layer}`, "flow:passthrough")+ );+ nodes.push(...currentLayer);+ for (const previous of previousLayer) {+ for (const current of currentLayer) {+ connections.push(conn(previous.clientId, current.clientId));+ }+ }+ previousLayer = currentLayer;+ }++ const graph = {+ nodes: [...nodes].reverse(),+ connections,+ nodeTypes: [+ triggerType("trigger:source", src),+ {+ name: "flow:passthrough",+ versions: {+ "1.0": {+ get output_contracts() {+ reads++;+ return [{ mode: "passthrough" }];+ },+ },+ },+ },+ ],+ };++ assert.deepEqual(+ outputSchemaForNode(previousLayer[0], graph),+ src,+ "the declaration reaches the end of a reverse-ordered reconverging graph"+ );+ assert.strictEqual(reads, nodes.length - 1, "reads scale with node count");++ const outputSchemas = resolveDeclaredOutputSchemas(graph);+ const readsAfter = reads;+ outputSchemaForNode(nodes[5], graph, { outputSchemas });+ assert.strictEqual(reads, readsAfter, "lookups reuse the resolution");+ });++ test("ancestorOutputNodes deduplicates output ports and survives cycles", function (assert) {+ const trigger = { clientId: "t" };+ const branch = { clientId: "b" };+ const current = { clientId: "c" };+ const graph = {+ nodes: [trigger, branch, current],+ connections: [+ conn("t", "b"),+ conn("c", "t"),+ conn("b", "c", { sourceOutputIndex: 0, targetInputIndex: 0 }),+ conn("b", "c", { sourceOutputIndex: 1, targetInputIndex: 1 }),+ conn("b", "c", { sourceOutputIndex: 0, targetInputIndex: 2 }),+ ],+ };++ assert.deepEqual(+ ancestorOutputNodes(current, graph),+ [+ { node: branch, outputIndex: 0 },+ { node: branch, outputIndex: 1 },+ { node: trigger, outputIndex: 0 },+ ],+ "the upstream chain is followed with deduplicated output ports"+ );+ });++ test("connection helpers order inputs and resolve source nodes", function (assert) {+ const graph = {+ connections: [+ conn("merge", "merge"),+ conn("later-input", "merge", { targetInputIndex: 1 }),+ conn("beta", "merge", { targetInputIndex: 0, sourceOutputIndex: 1 }),+ conn("zulu", "merge", { targetInputIndex: 0, sourceOutputIndex: 0 }),+ conn("alpha", "merge", { targetInputIndex: 0, sourceOutputIndex: 1 }),+ ],+ };+ const sources = (visited) =>+ inputConnectionsForNode({ clientId: "merge" }, graph, visited).map(+ (connection) => connection.sourceClientId+ );++ assert.deepEqual(+ sources(),+ ["zulu", "alpha", "beta", "later-input"],+ "connections sort by target input, source output, then source node ID, skipping self-connections"+ );+ assert.deepEqual(+ sources(new Set(["zulu"])),+ ["alpha", "beta", "later-input"],+ "connections from visited sources are excluded"+ );++ const src = { clientId: "s" };+ const g2 = { nodes: [src] };+ assert.strictEqual(previousNodeForConnection(conn("s", "x"), g2), src);+ assert.strictEqual(previousNodeForConnection(conn("nope", "x"), g2), null);+ assert.strictEqual(previousNodeForConnection(null, g2), null);+ });+});