Picking away

server/Computer.ts

@@ -10,6 +10,7 @@ import { Param } from "./Param"
 export type RunArgs = {
   input: InputDeviceInterface,
   output: OutputDeviceInterface,
+  params: Record<string, Param>
 }
 
 export interface Computer {

server/DiagramBuilder.test.ts

@@ -13,24 +13,69 @@ describe('get', () => {
 })
 
 describe('add', () => {
-  it('adds a node to the diagram', () => {
+  it('adds a node to the diagram and ensures unique ids', () => {
     const diagram = new DiagramBuilder()
       .add(CreateJson)
       .add(Pass)
+      .add(Pass)
       .add(Accept)
       .get()
 
-    /*
-      ### Expect nodes
-      * ids: CreateJson.1, Pass.1, Accept.1
-      * types: CreateJson, Pass, Accept
-      * inputs: [], ['input'], ['input']
-      * outputs: ['output'], ['output'], []
-      
-      ### Expect links
-      * CreateJson.1.output-->Pass.1.input
-      * Pass.1.output-->Accept.1.input
-    */
+    const nodeIds = diagram.nodes.map(node => node.id)
+    const nodeTypes = diagram.nodes.map(node => node.type)
+    const nodeInputs = diagram.nodes.map(node => node.inputs)
+    const nodeOutputs = diagram.nodes.map(node => node.outputs)
+
+    expect(nodeIds).toMatchObject([
+      'CreateJson.1',
+      'Pass.1',
+      'Pass.2',
+      'Accept.1'
+    ])
+
+    expect(nodeTypes).toMatchObject([
+      'CreateJson',
+      'Pass',
+      'Pass',
+      'Accept'
+    ])
+
+    expect(nodeInputs).toMatchObject([
+      [],
+      [{id: 'Pass.1.input', name: 'input'}],
+      [{id: 'Pass.2.input', name: 'input'}],
+      [{id: 'Accept.1.input', name: 'input'}]
+    ])
+
+    expect(nodeOutputs).toMatchObject([
+      [{id: 'CreateJson.1.output', name: 'output'}],
+      [{id: 'Pass.1.output', name: 'output'}],
+      [{id: 'Pass.2.output', name: 'output'}],
+      []
+    ])
+  })
+
+  it('links nodes together if possible', () => {
+    const diagram = new DiagramBuilder()
+      .add(CreateJson)
+      .add(Pass)
+      .get()
+
+    expect(diagram.links).toMatchObject([
+      {
+        id: 'CreateJson.1.output-->Pass.1.input',
+        sourcePortId: 'CreateJson.1.output',
+        targetPortId: 'Pass.1.input'
+      }
+    ])
+  })
+
+  it('does not link nodes together if not possible', () => {
+    const diagram = new DiagramBuilder()
+      .add(CreateJson)
+      .add(CreateJson)
+      .get()
 
+    expect(diagram.links).toMatchObject([])
   })
 })

server/DiagramBuilder.ts

@@ -1,6 +1,8 @@
 import { Computer } from "./Computer";
 import { Diagram } from "./Diagram";
+import { Link } from "./Link";
 import { Node } from "./Node";
+import { Port } from "./Port";
 
 export class DiagramBuilder {
   diagram: Diagram
@@ -11,16 +13,24 @@ export class DiagramBuilder {
   }
 
   add(computer: Computer) {
+    const nodeId = `${computer.name}.${this.getScopedId(computer.name)}`
+
     const node = new Node({
-      id: `${computer.name}.1`,
+      id: nodeId,
       type: computer.name,
-      inputs: [],
-      outputs: [],
+      inputs: (computer.inputs ?? []).map(name => {
+        return new Port(`${nodeId}.${name}`, name)
+      }),
+      outputs: (computer.outputs ?? []).map(name => {
+        return new Port(`${nodeId}.${name}`, name)
+      }),
     })
 
     this.diagram.nodes.push(node)
+
+    if (this.previousNode) this.linkToPrevious(node)
 
-    if (this.previousNode) this.attemptLink(this.previousNode, node)
+    this.previousNode = node
 
     return this
   }
@@ -29,7 +39,31 @@ export class DiagramBuilder {
     return this.diagram
   }
 
-  protected attemptLink(previous: Node, next: Node) {
+  protected getScopedId(computerName: string) {
+    const max = this.diagram.nodes
+      .filter(node => node.type === computerName)
+      .map(node => node.id)
+      .map(id => id.split('.')[1])
+      .map(id => parseInt(id))
+      .reduce((max, id) => Math.max(max, id), 0)
+
+    return max + 1      
+  }
+
+  protected linkToPrevious(newNode: Node) {
+    const previousNode = this.previousNode!
+
+    const previousNodePort: Port | undefined = previousNode.outputs[0]
+    const newNodePort: Port | undefined = newNode.inputs[0]
+
+    if(!previousNodePort || !newNodePort) return
+
+    const link = new Link(
+      `${previousNodePort.id}-->${newNodePort.id}`,
+      previousNodePort.id,
+      newNodePort.id,
+    )
 
+    this.diagram.links.push(link)
   }
 }

server/Executor.ts

@@ -25,7 +25,7 @@ export class Executor {
     while(!this.isComplete()) {
       // Start execution of all nodes that can run
       const runnables = this.getRunnableNodes()
-      
+
       const promises = runnables.map(node => {
         // Put node in busy state
         this.nodeStatuses.set(node.id, 'BUSY')
@@ -84,6 +84,11 @@ export class Executor {
         computer.run({
           input: this.makeInputDevice(node),
           output: this.makeOutputDevice(node),
+          // TODO: WHO OWNS THE PARAMS??
+          // I think, while they originating from React Flow NODES configuration,
+          // they should be considered as settings given to the computer.
+          // The computer is initialized/hydrated with the params
+          params: {},
         })
       )
     }

server/computers/CreateJson.ts

@@ -4,9 +4,10 @@ export const CreateJson: Computer = {
   name: 'CreateJson',  
   outputs: ['output'],
 
-  async *run({ output }: RunArgs) {
+  async *run({ output, params }: RunArgs) {
     while(true) {
       const json = '[{"id": 1}, {"id": 2}, {"id": 3}]'
+      // const json = params.json.value // TODO return to this
       output.push(JSON.parse(json))
       yield;
     }

utils/JsonLike.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { JsonLike } from "./JsonLike";
+
+describe('parse', () => {
+  it('should parse regular JSON', () => {
+    const json = '{"name": "John", "age": 30}';
+    const parsed = JsonLike.parse(json);
+    expect(parsed).toEqual({ name: 'John', age: 30 });
+  });
+
+  it('should parse indented JSON-like string with unquoted keys', () => {
+    const json = `{
+      name: "John",
+      age: 30,
+      address: {
+        street: "123 Main St",
+        city: "Anytown",
+        state: "CA"
+      }
+    }`;
+    const parsed = JsonLike.parse(json);
+    expect(parsed).toEqual({
+      name: 'John',
+      age: 30,
+      address: {
+        street: '123 Main St',
+        city: 'Anytown',
+        state: 'CA'
+      }
+    });
+  });
+
+  it('cant parse unquoted keys without indentation', () => {
+    const json = `{name: "John", age: 30}`
+
+    expect(() => JsonLike.parse(json)).toThrow()
+  })
+});

utils/JsonLike.ts

@@ -0,0 +1,18 @@
+export const JsonLike = {
+  parse(json: string) {
+    // Check if the string is already valid JSON
+    try {
+      return JSON.parse(json);
+    } catch (e) {}
+
+    // Handle JSON-like string where keys may not have quotes
+    const matchKey = /\s+(\w+)\s*:/g;
+    const fixed = json.replace(matchKey, '"$1":');
+
+    try {
+      return JSON.parse(fixed);
+    } catch (e) {
+      throw new Error('Could not parse JSON-like string.');
+    }
+  },
+};