feat(api): add support for nested prototypes

Author: rcarcasses

libs/api/include/rtbot/Prototype.h

@@ -38,47 +38,58 @@ class PrototypeHandler {
       return;
     }
 
-    auto prototypes = parse_prototypes(program_json["prototypes"]);
+    // Parse and store all prototypes
+    std::map<std::string, PrototypeDefinition> prototypes = parse_prototypes(program_json["prototypes"]);
+
     json expanded_operators = json::array();
     json expanded_connections = json::array();
     std::map<std::string, std::pair<std::string, std::string>> instance_mappings;
 
     // Process original operators
     for (const auto& op : program_json["operators"]) {
       if (op.contains("prototype")) {
-        const auto& proto = prototypes[op["prototype"].get<std::string>()];
+        // Handle prototype instance
+        const auto& proto = prototypes.at(op["prototype"].get<std::string>());
+        const std::string instance_id = op["id"].get<std::string>();
 
-        // Expand prototype instance
-        expand_prototype_instance(op["id"].get<std::string>(), proto, op.value("parameters", json::object()),
-                                  expanded_operators, expanded_connections, instance_mappings);
+        expand_prototype_instance(instance_id, proto, op.value("parameters", json::object()), expanded_operators,
+                                  expanded_connections, instance_mappings, prototypes);
       } else {
+        // Regular operator - add as-is
         expanded_operators.push_back(op);
       }
     }
 
     // Process original connections
     for (const auto& conn : program_json["connections"]) {
-      std::string from_id = conn["from"];
-      std::string to_id = conn["to"];
-
-      json remapped_conn = conn;
-
-      // Map prototype instance connections
-      if (instance_mappings.count(from_id)) {
-        remapped_conn["from"] = instance_mappings[from_id].second;
-        remapped_conn["fromPort"] = conn.value("fromPort", "o1");
-      }
-      if (instance_mappings.count(to_id)) {
-        remapped_conn["to"] = instance_mappings[to_id].first;
-        remapped_conn["toPort"] = conn.value("toPort", "i1");
+      bool processed = false;
+
+      // Check if connection involves prototype instances
+      for (const auto& [instance_id, mapping] : instance_mappings) {
+        if (conn["from"] == instance_id) {
+          json new_conn = conn;
+          new_conn["from"] = mapping.second;  // Use output port
+          expanded_connections.push_back(new_conn);
+          processed = true;
+        }
+        if (conn["to"] == instance_id) {
+          json new_conn = conn;
+          new_conn["to"] = mapping.first;  // Use entry port
+          expanded_connections.push_back(new_conn);
+          processed = true;
+        }
       }
 
-      expanded_connections.push_back(remapped_conn);
+      // If not involving prototypes, add as-is
+      if (!processed) {
+        expanded_connections.push_back(conn);
+      }
     }
 
-    // Update program with expanded operators and connections
+    // Update program JSON
     program_json["operators"] = expanded_operators;
     program_json["connections"] = expanded_connections;
+    program_json.erase("prototypes");
   }
 
  private:
@@ -129,32 +140,42 @@ class PrototypeHandler {
     }
   }
 
-  static void expand_prototype_instance(const std::string& instance_id, const PrototypeDefinition& proto,
-                                        const json& params, json& expanded_operators, json& expanded_connections,
-                                        std::map<std::string, std::pair<std::string, std::string>>& instance_mappings) {
+  static void expand_prototype_instance(
+      const std::string& instance_id, const PrototypeDefinition& proto, const json& params, json& expanded_operators,
+      json& expanded_connections, std::map<std::string, std::pair<std::string, std::string>>& instance_mappings,
+      const std::map<std::string, PrototypeDefinition>& all_prototypes  // Add prototypes map
+  ) {
     json resolved_params = resolve_parameters(instance_id, params, proto.parameters);
 
-    // Create a copy of operators for modification
     json instance_operators = proto.operators;
 
-    // First resolve parameters in all operators, including nested Pipelines
+    // First pass: Resolve parameters
     resolve_pipeline_operators(instance_operators, resolved_params);
 
-    // Expand operators with scoped IDs
+    // Second pass: Handle nested prototypes
     for (auto& op : instance_operators) {
-      std::string local_id = op["id"];
-      op["id"] = instance_id + "::" + local_id;
-      expanded_operators.push_back(op);
+      if (op.contains("prototype")) {
+        // Recursively expand nested prototype
+        const auto& nested_proto = all_prototypes.at(op["prototype"].get<std::string>());
+        const std::string nested_id = instance_id + "::" + op["id"].get<std::string>();
+
+        expand_prototype_instance(nested_id, nested_proto, op.value("parameters", json::object()), expanded_operators,
+                                  expanded_connections, instance_mappings, all_prototypes);
+      } else {
+        // Regular operator - add with scoped ID
+        std::string local_id = op["id"];
+        op["id"] = instance_id + "::" + local_id;
+        expanded_operators.push_back(op);
+      }
     }
 
-    // Expand connections
+    // Expand connections with scoped IDs
     for (auto conn : proto.connections) {
       conn["from"] = instance_id + "::" + conn["from"].get<std::string>();
       conn["to"] = instance_id + "::" + conn["to"].get<std::string>();
       expanded_connections.push_back(conn);
     }
 
-    // Store mappings
     instance_mappings[instance_id] =
         std::make_pair(instance_id + "::" + proto.entry.operator_id, instance_id + "::" + proto.output.operator_id);
   }

libs/api/test/test_program.cpp

@@ -1030,4 +1030,77 @@ SCENARIO("Program handles nested Pipeline prototypes correctly", "[program][prot
       REQUIRE_THROWS_WITH(Program(invalid_json), Catch::Contains("Unknown parameter reference '${nonexistent_param}'"));
     }
   }
+}
+
+SCENARIO("Program with nested prototypes", "[program]") {
+  std::string program_json = R"({
+      "prototypes": {
+        "simpleMA": {
+          "parameters": [
+            {"name": "window", "type": "number"}
+          ],
+          "operators": [
+            {"type": "MovingAverage", "id": "ma", "window_size": "${window}"}
+          ],
+          "connections": [],
+          "entry": {"operator": "ma"},
+          "output": {"operator": "ma"}
+        },
+        "dualMA": {
+          "parameters": [
+            {"name": "window1", "type": "number"},
+            {"name": "window2", "type": "number"}
+          ],
+          "operators": [
+            {"id": "ma1", "prototype": "simpleMA", "parameters": {"window": "${window1}"}},
+            {"id": "ma2", "prototype": "simpleMA", "parameters": {"window": "${window2}"}}
+          ],
+          "connections": [
+            {"from": "ma1::ma", "to": "ma2::ma"}
+          ],
+          "entry": {"operator": "ma1::ma"},
+          "output": {"operator": "ma2::ma"}
+        }
+      },
+      "operators": [
+        {"type": "Input", "id": "input1", "portTypes": ["number"]},
+        {"id": "nested_ma", "prototype": "dualMA", "parameters": {"window1": 2, "window2": 3}},
+        {"type": "Output", "id": "output1", "portTypes": ["number"]}
+      ],
+      "connections": [
+        {"from": "input1", "to": "nested_ma::ma1::ma"},
+        {"from": "nested_ma::ma2::ma", "to": "output1"}
+      ],
+      "entryOperator": "input1",
+      "output": {
+        "output1": ["o1"]
+      }
+    })";
+
+  Program program(program_json);
+  WHEN("Processing messages through nested moving averages") {
+    ProgramMsgBatch batch;
+    std::vector<double> results;
+
+    // Send messages one by one
+    batch = program.receive(Message<NumberData>(1, NumberData{2.0}));
+    REQUIRE(batch.empty());  // First MA collecting
+
+    batch = program.receive(Message<NumberData>(2, NumberData{4.0}));
+    REQUIRE(batch.empty());  // First MA starts outputting, second MA collecting
+
+    batch = program.receive(Message<NumberData>(3, NumberData{6.0}));
+    REQUIRE(batch.empty());  // Second MA still collecting
+
+    batch = program.receive(Message<NumberData>(4, NumberData{8.0}));
+    REQUIRE(batch.size() == 1);
+    REQUIRE(batch["output1"]["o1"].size() == 1);
+    auto* msg = dynamic_cast<const Message<NumberData>*>(batch["output1"]["o1"].back().get());
+    REQUIRE(msg->data.value == Approx(5.0));  // First output from nested MAs
+
+    batch = program.receive(Message<NumberData>(5, NumberData{10.0}));
+    REQUIRE(batch.size() == 1);
+    msg = dynamic_cast<const Message<NumberData>*>(batch["output1"]["o1"].back().get());
+    REQUIRE(msg->data.value == Approx(7.0));
+  }
 }