feat(js): recover javascript wrapper, test passing

rcarcasses · rcarcasses · commit 292d1705152a · 2024-12-27T12:13:06.000Z
diff --git a/libs/api/wasm/emscripten-bindings.cpp b/libs/api/wasm/emscripten-bindings.cpp
@@ -1,14 +1,18 @@
 #include <emscripten/bind.h>
+#include <emscripten/val.h>
 
-#include "RtBot.pb.h"
 #include "rtbot/Message.h"
+#include "rtbot/OperatorJson.h"
 #include "rtbot/bindings.h"
 
 using namespace emscripten;
+using json = nlohmann::json;
+using timestamp_t = rtbot::timestamp_t;
 
 namespace emscripten {
 namespace internal {
 
+// Vector binding type for converting between C++ vectors and JavaScript arrays
 template <typename T, typename Allocator>
 struct BindingType<std::vector<T, Allocator>> {
   using ValBinding = BindingType<val>;
@@ -21,6 +25,7 @@ struct BindingType<std::vector<T, Allocator>> {
   }
 };
 
+// TypeID specialization for vectors to ensure proper type handling
 template <typename T>
 struct TypeID<
     T, typename std::enable_if_t<std::is_same<typename Canonicalized<T>::type,
@@ -32,41 +37,77 @@ struct TypeID<
 }  // namespace internal
 }  // namespace emscripten
 
-void test(rtbot::api::proto::Input const& input) { std::cout << "Input: " << input.DebugString() << std::endl; }
-
-string processBatch32(string const& programId, vector<uint32_t> times32, vector<double> values,
-                      vector<string> const& ports) {
-  // translate passed 32 bit timestamp into 64 bit internal type
-  vector<uint64_t> times(times32.begin(), times32.end());
-  return processBatch(programId, times, values, ports);
+// Helper function to process batches with 32-bit timestamps
+std::string processBatch32(const std::string& programId, const std::vector<uint32_t>& times32,
+                           const std::vector<double>& values, const std::vector<std::string>& ports) {
+  // Convert 32-bit timestamps to 64-bit
+  std::vector<uint64_t> times(times32.begin(), times32.end());
+  return rtbot::process_batch(programId, times, values, ports);
 }
 
-string processBatch32Debug(string const& programId, vector<uint32_t> times32, vector<double> values,
-                           vector<string> const& ports) {
-  // translate passed 32 bit timestamp into 64 bit internal type
-  vector<uint64_t> times(times32.begin(), times32.end());
-  return processBatchDebug(programId, times, values, ports);
+// Debug version of batch processing
+std::string processBatch32Debug(const std::string& programId, const std::vector<uint32_t>& times32,
+                                const std::vector<double>& values, const std::vector<std::string>& ports) {
+  std::vector<uint64_t> times(times32.begin(), times32.end());
+  return rtbot::process_batch_debug(programId, times, values, ports);
 }
 
-EMSCRIPTEN_BINDINGS(RtBot) {
-  value_object<rtbot::Message<std::uint64_t, double>>("Message")
-      .field("time", &rtbot::Message<std::uint64_t, double>::time)
-      .field("value", &rtbot::Message<std::uint64_t, double>::value);
+// Helper to add a single message to the buffer
+std::string addMessage(const std::string& programId, const std::string& portId, uint32_t time, double value) {
+  return rtbot::add_to_message_buffer(programId, portId, static_cast<uint64_t>(time), value);
+}
 
-  emscripten::function("validate", &validate);
-  emscripten::function("validateOperator", &validateOperator);
+namespace {
+// Helper functions for message creation and access
+timestamp_t getMessage_getTime(const rtbot::Message<rtbot::NumberData>& msg) { return msg.time; }
 
-  emscripten::function("createProgram", &createProgram);
-  emscripten::function("deleteProgram", &deleteProgram);
+void getMessage_setTime(rtbot::Message<rtbot::NumberData>& msg, timestamp_t t) { msg.time = t; }
 
-  emscripten::function("addToMessageBuffer", &addToMessageBuffer);
-  emscripten::function("processMessageBuffer", &processMessageBuffer);
-  emscripten::function("processMessageBufferDebug", &processMessageBufferDebug);
+const rtbot::NumberData& getMessage_getData(const rtbot::Message<rtbot::NumberData>& msg) { return msg.data; }
 
-  emscripten::function("getProgramEntryOperatorId", &getProgramEntryOperatorId);
-  emscripten::function("getProgramEntryPorts", &getProgramEntryPorts);
-  emscripten::function("getProgramOutputFilter", &getProgramOutputFilter);
+void getMessage_setData(rtbot::Message<rtbot::NumberData>& msg, const rtbot::NumberData& data) { msg.data = data; }
+}  // namespace
 
-  emscripten::function("processBatch", &processBatch32);
-  emscripten::function("processBatchDebug", &processBatch32Debug);
-}
+EMSCRIPTEN_BINDINGS(RtBot) {
+  // Register NumberData type first
+  value_object<rtbot::NumberData>("NumberData").field("value", &rtbot::NumberData::value);
+
+  // Register Message type with manual accessors to avoid base class issues
+  class_<rtbot::Message<rtbot::NumberData>>("Message")
+      .constructor<timestamp_t, const rtbot::NumberData&>()
+      .property("time", &getMessage_getTime, &getMessage_setTime)
+      .property("data", &getMessage_getData, &getMessage_setData);
+
+  // Core program management functions
+  function("createProgram", &rtbot::create_program);
+  function("deleteProgram", &rtbot::delete_program);
+  function("validateProgram", &rtbot::validate_program);
+  function("validateOperator", &rtbot::validate_operator);
+
+  // Message handling
+  function("addToMessageBuffer", &addMessage);
+  function("processMessageBuffer", &rtbot::process_message_buffer);
+  function("processMessageBufferDebug", &rtbot::process_message_buffer_debug);
+
+  // Program information
+  function("getProgramEntryOperatorId", &rtbot::get_program_entry_operator_id);
+  function("getProgramEntryPorts", optional_override([](const std::string& programId) -> std::string {
+             try {
+               auto entry_id = rtbot::get_program_entry_operator_id(programId);
+               if (entry_id.empty()) return "[]";
+
+               // By default, return ["i1"] as the entry port
+               json ports = {"i1"};
+               return ports.dump();
+             } catch (const std::exception& e) {
+               return "[]";
+             }
+           }));
+
+  // Batch processing
+  function("processBatch", &processBatch32);
+  function("processBatchDebug", &processBatch32Debug);
+
+  // State management
+  // TODO: Serialize and deserialize program state
+}
diff --git a/libs/wrappers/javascript/src/api.ts b/libs/wrappers/javascript/src/api.ts
@@ -100,13 +100,19 @@ export class RtBotRun {
     // if (!success) throw new Error(`Program is invalid`);
     const program = this.program.toPlain();
     const programStr = JSON.stringify(program, null, 2);
-    if (this.verbose) console.log("Sending", programStr);
-    const createProgramResponseStr = await RtBot.getInstance().createProgram(this.program.programId, programStr);
-
-    if (createProgramResponseStr) {
-      const createProgramResponse = JSON.parse(createProgramResponseStr);
-      // if program fails validation, throw an error
-      if (createProgramResponse.error) throw new Error(createProgramResponse.error);
+    try {
+      if (this.verbose) console.log("Sending", programStr);
+      const createProgramResponseStr = await RtBot.getInstance().createProgram(this.program.programId, programStr);
+      if (this.verbose) console.log("createProgram response", createProgramResponseStr);
+
+      if (createProgramResponseStr) {
+        const createProgramResponse = JSON.parse(createProgramResponseStr);
+        // if program fails validation, throw an error
+        if (createProgramResponse.error) throw new Error(createProgramResponse.error);
+      }
+    } catch (e) {
+      console.error("Error creating program", e);
+      throw e;
     }
 
     if (this.verbose) console.log("Sending data...");
diff --git a/libs/wrappers/javascript/src/program.spec.ts b/libs/wrappers/javascript/src/program.spec.ts
@@ -19,37 +19,37 @@ const programJson = `{
   "operators": [
     {
       "id": "in1",
-      "type": "Input"
+      "type": "Input",
+      "portTypes": ["number"]
     },
     {
       "id": "ma1",
       "type": "MovingAverage",
-      "n": 6
+      "window_size": 6
     },
     {
       "id": "ma2",
       "type": "MovingAverage",
-      "n": 250
+      "window_size": 250
     },
     {
       "id": "minus",
-      "type": "Minus",
-      "policies": { "i1": { "eager": false } }
+      "type": "Subtraction"
     },
     {
       "id": "peak",
       "type": "PeakDetector",
-      "n": 13
+      "window_size": 13
     },
     {
       "id": "join",
       "type": "Join",
-      "policies": { "i1": { "eager": false } },
-      "numPorts": 2
+      "portTypes": ["number", "number"]
     },
     {
       "id": "out1",
-      "type": "Output"
+      "type": "Output",
+      "portTypes": ["number"]
     }
   ],
   "connections": [
@@ -101,7 +101,10 @@ const programJson = `{
       "fromPort": "o1",
       "toPort": "i2"
     }
-  ]
+  ],
+  "output": {
+    "out1": ["o1"]
+  }
 }
 `;
 
@@ -112,24 +115,26 @@ describe("Program", () => {
 
   beforeEach(() => {
     program = new Program("input1", title, description);
-    const input = new Input("input1");
+    const input = new Input("input1", ["number"]);
     const op1 = new MovingAverage("ma1", 2);
-    const output = new Output("out1");
+    const output = new Output("out1", ["number"]);
     program.addOperator(input);
     program.addOperator(op1);
     program.addOperator(output);
     program.addConnection(input, op1);
     program.addConnection(op1, output);
+    program.addOutput("out1", ["o1"]);
   });
 
+  // Rest of the test cases remain the same...
   it("can create a new instance", () => {
     expect(program.title).toBe(title);
   });
 
   it("can be serialized", () => {
     const json = JSON.stringify(program);
     const parsedProgram = JSON.parse(json);
-    expect(parsedProgram.operators.find((op: any) => op.id === "ma1")).toMatchObject({ id: "ma1", n: 2 });
+    expect(parsedProgram.operators.find((op: any) => op.id === "ma1")).toMatchObject({ id: "ma1", window_size: 2 });
   });
 
   it("validates operator input", () => {
diff --git a/libs/wrappers/javascript/src/program.ts b/libs/wrappers/javascript/src/program.ts
@@ -11,6 +11,7 @@ export class Program {
   connections: Connection[] = [];
   programId: string;
   defaultPort?: string;
+  output: Record<string, string[]> = {};
 
   constructor(
     public entryOperator?: string,
@@ -39,13 +40,35 @@ export class Program {
   }
 
   validate() {
-    programSchema.parse(JSON.parse(JSON.stringify(this)));
+    try {
+      programSchema.parse(JSON.parse(JSON.stringify(this)));
+    } catch (error) {
+      if (error instanceof Error) {
+        // Extract operator info from error path if present
+        const issues = JSON.parse(error.message);
+        const operatorErrors = issues.filter((i: any) => i.path[0] === "operators");
+
+        if (operatorErrors.length > 0) {
+          const operatorIndex = operatorErrors[0].path[1];
+          const invalidOperator = this.operators[operatorIndex];
+          throw new Error(
+            `Invalid operator "${invalidOperator?.type}" at index ${operatorIndex}. ` +
+              `Valid operators are: ${operatorErrors[0].unionErrors?.[1].issues[0].options.join(", ")}`
+          );
+        }
+      }
+      throw error;
+    }
   }
 
   safeValidate() {
     return programSchema.safeParse(JSON.parse(JSON.stringify(this)));
   }
 
+  addOutput(operatorId: string, ports: string[]) {
+    this.output[operatorId] = ports;
+  }
+
   addOperator(op: Operator) {
     op.setProgram(this);
     this.operators.push(op);
diff --git a/tools/generator/src/index.ts b/tools/generator/src/index.ts
@@ -196,40 +196,67 @@ program
     }
 
     if (target === "typescript") {
+      const getTypeString = (prop: any): string => {
+        if (prop.name === "outputMappings") {
+          return "any";
+        }
+        if (prop.type === "array") {
+          if (
+            prop.items?.enum?.every((e: string) => ["number", "boolean", "vector_number", "vector_boolean"].includes(e))
+          ) {
+            return "PortType[]";
+          }
+          if (prop.items?.enum) {
+            const enumVals = prop.items.enum.map((e: string) => `"${e}"`).join(" | ");
+            return `(${enumVals})[]`;
+          }
+          return "any[]";
+        }
+        if (prop.type === "string" && prop.enum) {
+          if (prop.enum.every((e: string) => ["number", "boolean", "vector_number", "vector_boolean"].includes(e))) {
+            return "PortType";
+          }
+          return prop.enum.map((e: string) => `"${e}"`).join(" | ");
+        }
+        const typeMap: Record<string, string> = {
+          integer: "number",
+          number: "number",
+          string: "string",
+          boolean: "boolean",
+          object: "Record<string, any>",
+          array: "any[]",
+        };
+        return typeMap[prop.type] || "any";
+      };
+
+      const nonPrototypeSchemas = programJsonschema.properties.operators.items.oneOf.filter(
+        (schema: any) => !schema.properties?.prototype
+      );
+
       const typescriptContent = typescriptTemplate({
-        schemas: parseSchema({ type: "array", items: programJsonschema.properties.operators.items.oneOf })
-          .replace("z.tuple(", "")
-          .slice(0, -1),
-        operators: await Promise.all(
-          schemas.map(async (schema) => {
-            const properties = Object.keys(schema.properties);
+        schemas: nonPrototypeSchemas.map((schema) => parseSchema(schema)).join(",\n"),
+        operators: schemas
+          .filter((schema) => !schema.properties?.prototype)
+          .map((schema) => {
             const type = schema.properties.type.enum[0];
-            const ts = await compile(schema, type);
-            let parametersBlock = ts
-              .split("export interface")[1]
-              .split("\n")
-              .filter((l) => l.indexOf("type") === -1 && l.indexOf("unknown") === -1)
-              .slice(1)
-              .slice(0, -2)
-              .map((l) => l.replace(";", ","))
+            const props = Object.entries(schema.properties)
+              .filter(([k]) => k !== "type")
+              .map(([name, prop]: [string, any]) => {
+                const description = prop.description ? `/**\n* ${prop.description}\n*/\n` : "";
+                const typeStr = getTypeString({ ...prop, name });
+                return `${description}readonly ${name}${schema.required?.includes(name) ? "" : "?"}: ${typeStr},`;
+              })
               .join("\n");
-            properties.forEach(
-              (prop) =>
-                (parametersBlock = parametersBlock
-                  .replace(`${prop}:`, `readonly ${prop}:`)
-                  .replace(`${prop}?:`, `readonly ${prop}?:`))
-            );
-            const zodSchema = parseSchema(schema);
 
             return {
               type,
-              parametersBlock,
-              schema: zodSchema,
+              parametersBlock: props,
+              schema: parseSchema(schema),
             };
-          })
-        ),
+          }),
       });
-      const formatted = await prettier.format(typescriptContent, { parser: "babel-ts" });
+
+      const formatted = typescriptContent; //await prettier.format(typescriptContent, { parser: "babel-ts" });
       fs.writeFileSync(`${output}/index.ts`, formatted);
     }
   });
diff --git a/tools/generator/templates/typescript.hbs b/tools/generator/templates/typescript.hbs
