.nestcoder

# NESTCODER

You are NestCoder, a HTMX, EJS and TypeScript/NestJS language coding assistant.

## INPUT: 

You will receive a TARGET <FILE/> in the EJS or TypeScript/NestJS language, some additional <FILE/>'s for context, and a change or refactor <REQUEST/>, from the user.

## OUTPUT:

You must answer with one or more <FILE/> tags, including files to be overwritten, in order to fulfill the user's request.

---

# EXAMPLE NESTCODER USAGE

## Suppose you're given the following INPUT:

<FILE path="/Users/v/vic/dev/tsbook/List/_.ts">
// A polymorphic List with two constructors:
// - Cons: appends an element to a list
// - Nil: the empty list
export type List<A>
  = { "$": "Cons", head: A, tail: List<A> }
  | { "$": "Nil" };
</FILE>

<FILE path="/Users/v/vic/dev/tsbook/List/map.ts" TARGET>
// The map function for List, to be implemented
import { List } from "./_";

export function map<A, B>(fn: (a: A) => B, list: List<A>): List<B> {
  ?
}
</FILE>

<REQUEST>
complete the map function
</REQUEST>

## Then, you must answer with the following OUTPUT:

<FILE path="/Users/v/vic/dev/tsbook/List/map.ts">
import { List } from "./_";

// Applies a function to each element of a list.
// - fn: the function to be applied
// - xs: the elements to apply fn to
// = a new list with fn applied to all elements
export function map<A, B>(xs: List<A>, fn: (a: A) => B): List<B> {
  switch (xs.$) {
    case "Cons": {
      var head = fn(xs.head);
      var tail = map(xs.tail, fn);
      return { $: "Cons", head, tail };
    }
    case "Nil": {
      return { $: "Nil" };
    }
  }
}
</FILE>

(Because it fulfills the user's request perfectly.)

---

# GUIDE FOR THE TYPESCRIPT LANGUAGE

- Your code must be inspired by pure functional programming languages like Haskell.

- Every file must declare only, and only one, top-level function or datatype.

- Functions must be pure, using switch instead of 'if-else' or 'case-of'.

- When defining local variables, align equal signs whenever possible.

- Use CamelCase for everything. (IMPORTANT)

- A 'Foo/Bar' top-level definition must be either on './Foo/Bar.ts' or './Foo/Bar/_.ts'. 

# GUIDE FOR THE EJS LANGUAGE

- Use HTMX for frontend.

## Top-Level Function

Every .ts file must define ONE top-level function. Example:

```typescript
// Calculates the size of an HTerm
// - term: the HTerm to measure
// = the number of nodes in the term
export function size(term: HTerm): number {
  switch (term.$) {
    case "Lam": {
      var bod_size = size(term.bod({$: "Var", nam: term.nam}));
      return 1 + bod_size;
    }
    case "App": {
      var fun_size = size(term.fun);
      var arg_size = size(term.arg);
      return 1 + fun_size + arg_size;
    }
    case "Var": {
      return 1;
    }
  }
}
```

Where:
- The function name is defined (e.g., 'size')
- Parameters are specified with their types (e.g., 'term: HTerm')
- The return type is specified (e.g., ': number')
- The function body uses a switch statement for pattern matching
- Local variables are used to make the code less horizontal

## Top-Level Datatype

Alternatively, a .ts file can also define a datatype (ADT). Example:

```typescript
// Represents a Higher-Order Abstract Syntax Term
// - Lam: lambda abstraction
// - App: function application
// - Var: variable
export type HTerm
  = { $: "Lam", bod: (x: HTerm) => HTerm }
  | { $: "App", fun: HTerm, arg: HTerm }
  | { $: "Var", nam: string }
```

ADTs must follow this convention:
- Constructors represented as objects
- The dollar-sign is used for the constructor name
- Other object fields are the constructor fields

## Idiomatic TypeScript Examples

Below are some additional idiomatic TypeScript in the purely functional style: 

### List/zip.ts

```typescript
import { List } from "./_";

// Combines two lists into a list of pairs
// - xs: the first input list
// - ys: the second input list
// = a new list of pairs, with length equal to the shorter input list
export function zip<A, B>(xs: List<A>, ys: List<B>): List<[A, B]> {
  switch (xs.$) {
    case "Cons": {
      switch (ys.$) {
        case "Cons": {
          var head = [xs.head, ys.head] as [A,B];
          var tail = zip(xs.tail, ys.tail);
          return { $: "Cons", head, tail };
        }
        case "Nil": {
          return { $: "Nil" };
        }
      }
    }
    case "Nil": {
      return { $: "Nil" };
    }
  }
}
```

### List/filter.ts

```typescript
import { List } from "./_";

// Filters a list based on a predicate function
// - xs: the input list
// - pred: the predicate function to test each element
// = a new list containing only elements that satisfy the predicate
export function filter<A>(xs: List<A>, pred: (a: A) => boolean): List<A> {
  switch (xs.$) {
    case "Cons": {
      var head = xs.head;
      var tail = filter(xs.tail, pred);
      return pred(xs.head) ? { $: "Cons", head, tail } : tail;
    }
    case "Nil": {
      return { $: "Nil" };
    }
  }
}
```

### Tree/_.ts

```typescript
// Represents a binary tree
// - Node: an internal node with a value and two subtrees
// - Leaf: a leaf node (empty)
export type Tree<A>
  = { $: "Node", val: A, left: Tree<A>, right: Tree<A> }
  | { $: "Leaf" };
```

### Tree/sum.ts

```typescript
import { Tree } from "./_";

// Sums all values in a numeric tree
// - tree: the tree to sum
// = the sum of all values in the tree
export function sum(tree: Tree<number>): number {
  switch (tree.$) {
    case "Node": {
      var left  = sum(tree.left);
      var right = sum(tree.right);
      return tree.val + left + right;
    }
    case "Leaf": {
      return 0;
    }
  }
}
```

### V3/_.ts

```typescript
// Represents a 3D vector
export type V3
  = { $: "V3", x: number, y: number, z: number };
```

### V3/dot.ts

```typescript
import { V3 } from "./_";

// Calculates the dot product of two 3D vectors
// - a: the first vector
// - b: the second vector
// = the dot product of a and b
export function dot(a: V3, b: V3): number {
  return a.x * b.x + a.y * b.y + a.z * b.z;
}
```

---

# NOTES

- Make ONLY the changes necessary to correctly fulfill the user's REQUEST.

- Do NOT fix, remove, complete or alter any parts unrelated to the REQUEST.

- Pay attention to the user's style, and mimic it as close as possible.

- Pay attention to the TypeScript examples and mimic their style as a default.

- Consult TypeScript guide to emit idiomatic correct code.

- Do NOT use or assume the existence of files that weren't shown to you.

- Be precise and careful in your modifications.

---

# TASK

You will now be given the actual INPUT you must work with.

<FILE path="/home/travis/Projects/flow-based-programming/src/components/benchmark-analyzer/benchmark-analyzer.handler.ts">
import { CustomLogger } from '../../logger/custom-logger';
import { Injectable, Inject } from '@nestjs/common';
import { ComponentBase } from '../../bases/component.base';
import { BackplaneService } from 'src/services/backplane.service';
import { Server } from 'socket.io';
import { TemplateCacheService } from 'src/services/template-cache.service';

@Injectable()
export class BenchmarkAnalyzerComponent extends ComponentBase {
  public logger: CustomLogger;
  private startTimes: { [size: number]: number } = {};
  private endTimes: { [size: number]: number } = {};
  private dataPoints: { [size: number]: number[] } = {};
  private currentMessageSize: number = 1;
  private messageSizes: number[] = [1, 10, 100, 1000, 10000];
  private messagesPerSize: number = 100;
  private currentSizeIndex: number = 0;
  public ports = {
    inputs: [
      'any.publish.startBenchmark',
      'any.publish.endBenchmark',
      'any.publish.dataPoint'
    ],
    outputs: [
      'any.publish.benchmarkResult',
      'htmx.display.benchmark-results',
      'any.publish.startMessageGeneration',
      'any.publish.stopMessageGeneration',
      'any.publish.nextMessageSize'
    ]
  }

  constructor(
    @Inject('FLOW_ID') flowId: string,
    @Inject('COMPONENT_ID') componentId: string,
    @Inject(BackplaneService) backplane: BackplaneService,
    @Inject('WEB_SOCKET_SERVER') protected server: Server,
    @Inject('TEMPLATES') templates: TemplateCacheService
  ) {
    super('benchmarkAnalyzer', 'benchmark-analyzer', 'Analyzes benchmark results', flowId, componentId, backplane, server, templates);
    this.flowId = flowId;
    this.componentId = componentId;
    this.logger = new CustomLogger(`${flowId}.${componentId}`);
  }

  async handleEvent(eventId: string, data: any): Promise<void> {
    switch (eventId) {
      case "init": {
        await this.initBenchmark(data);
        break;
      }
      case "startBenchmark": {
        await this.startBenchmark();
        break;
      }
      case "endBenchmark": {
        await this.endBenchmark();
        break;
      }
      case "dataPoint": {
        await this.addDataPoint(data.processingTime, data.size);
        break;
      }
    }
  }

  private async initBenchmark(data: any): Promise<void> {
    if (data && data.messageSizes) {
      this.messageSizes = data.messageSizes;
    }
    if (data && data.messagesPerSize) {
      this.messagesPerSize = data.messagesPerSize;
    }
    this.logger.log(`Benchmark initialized with message sizes: ${this.messageSizes}, messages per size: ${this.messagesPerSize}`);
    this.resetDataPoints();
  }
  
  private async startBenchmark(): Promise<void> {
    this.currentSizeIndex = 0;
    this.currentMessageSize = this.messageSizes[this.currentSizeIndex];
    this.resetDataPoints();
    
    this.startTimes[this.currentMessageSize] = Date.now();
    console.log('========');
    console.log(`Benchmark started for size ${this.currentMessageSize} at ${this.startTimes[this.currentMessageSize]}`);
    console.log('========');
    await this.publish(this.flowId, this.componentId, 'startMessageGeneration', {});
  }

  private async endBenchmark(): Promise<void> {
    this.endTimes[this.currentMessageSize] = Date.now();
    this.logger.log(`Benchmark ended for size ${this.currentMessageSize} at ${this.endTimes[this.currentMessageSize]}`);

    await this.publish(this.flowId, this.componentId, 'stopMessageGeneration', {});

    console.log('========');
    console.log('waiting 2s for benchmark to finish');
    console.log('========');
    await new Promise(resolve => setTimeout(resolve, 2000)); // wait for benchmark to finish

    if (this.currentSizeIndex < this.messageSizes.length - 1) {
      this.currentSizeIndex++;
      await this.startNextSizeBenchmark();
    } else {
      const result = this.analyzeBenchmark();
      await this.publish(this.flowId, this.componentId, 'benchmarkResult', result);
      await this.display(this.flowId, this.componentId, 'benchmark-results', { results: result });
      console.log('!!!!!!!!');
      console.log('benchmark-results: success');
      console.log('!!!!!!!!');
    }
  }

  private async addDataPoint(processingTime: number, size: number): Promise<void> {
    if (!this.dataPoints[size]) {
      this.dataPoints[size] = [];
    }
    this.dataPoints[size].push(processingTime);
    
    if (this.dataPoints[size].length === this.messagesPerSize) {
      console.log('////////// end benchmark', this.dataPoints[size].length, '===', this.messagesPerSize);
      await this.endBenchmark();
    }
  }

  private async startNextSizeBenchmark(): Promise<void> {
    this.currentMessageSize = this.messageSizes[this.currentSizeIndex];
    this.logger.log(`Starting benchmark for next size: ${this.currentMessageSize}`);
    await this.publish(this.flowId, this.componentId, 'nextMessageSize', { size: this.currentMessageSize });
    console.log('~~~~~~ startNextSizeBenchmark', this.currentMessageSize);
    await new Promise(resolve => setTimeout(resolve, 2000)); // wait for nextMessageSize to propagate
    this.startTimes[this.currentMessageSize] = Date.now();
    await this.publish(this.flowId, this.componentId, 'startMessageGeneration', {});
    await this.publish(this.flowId, this.componentId, 'startMessageGeneration', {});
    await this.publish(this.flowId, this.componentId, 'startMessageGeneration', {});
  }

  private analyzeBenchmark(): BenchmarkResults {
    const results: BenchmarkResults = {};

    for (const size of this.messageSizes) {
      const times = this.dataPoints[size] || [];
      const messageCount = times.length;
      const totalTime = times.reduce((sum, time) => sum + time, 0);
      const averageProcessingTime = messageCount > 0 ? totalTime / messageCount : 0;
      
      const startTime = this.startTimes[size] || 0;
      const endTime = this.endTimes[size] || 0;
      const totalDuration = (endTime - startTime) / 1000; // Convert to seconds
      const messagesPerSecond = totalDuration > 0 ? (messageCount / totalDuration).toFixed(2) : '0';

      results[size] = {
        messageCount,
        averageProcessingTime,
        messagesPerSecond,
      };

      this.logger.log(`Analysis for size ${size}: Count=${messageCount}, Avg=${averageProcessingTime.toFixed(2)}ms, MPS=${messagesPerSecond}`);
    }

    return results;
  }

  private resetDataPoints(): void {
    this.dataPoints = {};
    this.startTimes = {};
    this.endTimes = {};
    this.messageSizes.forEach(size => {
      this.dataPoints[size] = [];
    });
    this.logger.log('Data points reset');
  }
}

interface BenchmarkResult {
  messageCount: number;
  averageProcessingTime: number;
  messagesPerSecond: string;
}

interface BenchmarkResults {
  [size: number]: BenchmarkResult;
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/flows/benchmark.flow.ts">
import { schema } from "../schema/flow.schema";
import { default as initJobStateMachine } from "src/stateMachines/job.state-machine";

let benchmarks = {
  messageSizes: [1, 10, 100, 1000, 10000],
  messagesPerSize: 1000
}

let messageGenerator = {
  ports: {
    inputs: {
      start: {},
      stop: {},
      setMessageSize: {}
    },
    outputs: {
      messageGenerated: {}
    }
  },
  init: benchmarks
}

let messageProcessor = {
  ports: {
    inputs: {
      messageReceived: {}
    },
    outputs: {
      processingComplete: {}
    }
  }
}

let benchmarkAnalyzer = {
  ports: {
    inputs: {
      startBenchmark: {},
      endBenchmark: {},
      dataPoint: {}
    },
    outputs: {
      benchmarkResult: {},
      startMessageGeneration: {},
      stopMessageGeneration: {},
      nextMessageSize: {}
    }
  },
  init: benchmarks
}

let buttonTrigger = {
  ports: {
    inputs: {
      triggerButton: {}
    },
    outputs: {
      buttonPressed: {}
    }
  }
}

let components = {
  gen: {
    messageGenerator
  },
  proc: {
    messageProcessor
  },
  analyzer: {
    benchmarkAnalyzer
  },
  sm: {
    stateMachine: {
      init: initJobStateMachine,
      ports: {
        inputs: {
          initStateMachine: {}
        },
        outputs: {}
      }
    }
  },
  jsm: {
    jobStateMachine: {
      ports: {
        inputs: {
          initProxyMachine: {},
          'set-start': {},
          'set-pause': {},
          'set-resume': {},
          'set-finish': {},
          'set-reset': {}
        },
        outputs: {
          'get-start': {},
          'get-pause': {},
          'get-resume': {},
          'get-finish': {},
          'get-reset': {},
          stateChanged: {}
        }
      }
    }
  },
  startBtn: { buttonTrigger },
  stopBtn: { buttonTrigger },
  resetBtn: { buttonTrigger },
}

let flow = {
  id: 'benchmark-flow',
  components,
  connections: [
    {
      from: 'components.sm.stateMachine.ports.outputs.initProxyMachine',
      to: 'components.jsm.jobStateMachine.ports.inputs.initProxyMachine'
    },
    {
      from: 'components.jsm.jobStateMachine.ports.outputs.get-start',
      to: 'components.analyzer.benchmarkAnalyzer.ports.inputs.startBenchmark'
    },
    {
      from: 'components.analyzer.benchmarkAnalyzer.ports.outputs.nextMessageSize',
      to: 'components.gen.messageGenerator.ports.inputs.setMessageSize'
    },
    {
      from: 'components.jsm.jobStateMachine.ports.outputs.get-resume',
      to: 'components.analyzer.benchmarkAnalyzer.ports.inputs.startBenchmark'
    },
    {
      from: 'components.jsm.jobStateMachine.ports.outputs.get-finish',
      to: 'components.analyzer.benchmarkAnalyzer.ports.inputs.endBenchmark'
    },
    {
      from: 'components.gen.messageGenerator.ports.outputs.messageGenerated',
      to: 'components.proc.messageProcessor.ports.inputs.messageReceived'
    },
    {
      from: 'components.proc.messageProcessor.ports.outputs.processingComplete',
      to: 'components.analyzer.benchmarkAnalyzer.ports.inputs.dataPoint'
    },
    {
      from: 'components.analyzer.benchmarkAnalyzer.ports.outputs.startMessageGeneration',
      to: 'components.gen.messageGenerator.ports.inputs.start'
    },
    {
      from: 'components.analyzer.benchmarkAnalyzer.ports.outputs.stopMessageGeneration',
      to: 'components.gen.messageGenerator.ports.inputs.stop'
    },
    {
      from: 'components.startBtn.buttonTrigger.ports.outputs.buttonPressed',
      to: 'components.jsm.jobStateMachine.ports.inputs.set-start'
    },
    {
      from: 'components.stopBtn.buttonTrigger.ports.outputs.buttonPressed',
      to: 'components.jsm.jobStateMachine.ports.inputs.set-finish'
    },
    {
      from: 'components.resetBtn.buttonTrigger.ports.outputs.buttonPressed',
      to: 'components.jsm.jobStateMachine.ports.inputs.set-reset'
    }
  ]
};

export default schema(flow);
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/services/template-cache.service.ts">
import { Injectable } from '@nestjs/common';

@Injectable()
export class TemplateCacheService {
  private cache: Map<string, string> = new Map();

  setTemplate(key: string, content: string): void {
    this.cache.set(key, content);
  }

  getTemplate(key: string): string | undefined {
    return this.cache.get(key);
  }

  hasTemplate(key: string): boolean {
    return this.cache.has(key);
  }
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/logger/custom-logger.ts">
import { ConsoleLogger, Injectable, Inject } from '@nestjs/common';
import * as fs from 'fs';
import * as path from 'path';

@Injectable()
export class CustomLogger extends ConsoleLogger {
  constructor(
    private logId: string,
  ) {
    super(logId);
    this.setLogLevels(['log', 'error', 'warn', 'debug', 'verbose']);
  }

  log(message: string, context?: string) {
    this.printMessage(message, 'log', context);
    // this.emitLogEvent('log', message);
  }

  warn(message: string, context?: string) {
    this.printMessage(message, 'warn', context);
    // this.emitLogEvent('warn', message);
  }

  error(message: string, trace?: string, context?: string) {
    this.printMessage(message, 'error', context);
    // this.emitLogEvent('error', message);
    if (trace) {
      this.printMessage(trace, 'error', context);
    }
  }

  debug(message: string, context?: string) {
    this.printMessage(message, 'debug', context);
  }

  verbose(message: string, context?: string) {
    this.printMessage(message, 'verbose', context);
  }

  private printMessage(message: string, logLevel: string, context?: string) {
    const output = context ? `[${context}] ${message}` : message;
    console.log(`[${this.getNow()}] [${logLevel.toUpperCase()}] [${this.logId}] ${output}`);
  }

  private getNow(): string {
    return new Date().toISOString();
  }

  static write_to_file(message: string) {
    const logFile = path.join(process.cwd(), 'start:dev.stdout.txt');
    fs.appendFile(logFile, message, (err) => {
      if (err) {
        console.error('Failed to write to log file:', err);
      }
    });
  }

  static clearSTDOUT() {
    const logFile = path.join(process.cwd(), 'start:dev.stdout.txt');
    try {
      fs.writeFileSync(logFile, '');
      console.log(`Log file cleared at ${logFile}`);
    } catch (error) {
      console.error('Failed to clear log file:', error);
    }
  }
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/views/main.ejs">
<main>
  <h1>FBP Steam Engine</h1>
  <p>The complete Flow-based Programming solution:</p>
  <div style="overflow: hidden;">
    <ul class="navigation">
      <li><a href="/flows"><button>flows</button></a></li>
      <li><a href="/components"><button>components</button></a></li>
      <li><a href="/events"><button>events</button></a></li>
      <li><a href="/stateMachines"><button>state machines</button></a></li>
      <li><a href="/templates"><button>templates</button></a></li>
      <li><a href="/logs"><button>logs</button></a></li>
    </ul>
  </div>
  <p>
    > Works best with multiple screens! (chart, document, logger)<br />
    > *ideal for domain specific languages*
  </p>
  <hr>
  <p>
    What is FBP? Is it time for a new Steam Engine?<br />
    <a href="https://www.youtube.com/watch?v=up2yhNTsaDs" target="_blank">https://www.youtube.com/watch?v=up2yhNTsaDs</a>
  </p>  
  <p>
    Fork this FBP Steam Engine repository for each application.<br />
    <a href="https://github.com/subvind/flow-based-programming" target="_blank">https://github.com/subvind/flow-based-programming</a>
  </p>
  <span>~made with &hearts; by <a href="https://istrav.com">isTrav</a> & <a href="https://subvind.com">subVind</a> + ai :)</span>
</main>
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/views/style.ejs">

<style>
  body { 
    font-family: Arial, sans-serif; 
    margin: 0; 
    padding: 20px;
    background: #eee; 
  }
  main {
    border: 1px solid #111;
    margin: 0 auto;
    max-width: 600px;
    padding: 1em;
    background: #fff;
  }
  h1 {
    margin: 0;
  }
  .navigation {
    margin: 0;
    padding: 0;
    list-style: none outside none;
    position: relative;
  }
  .navigation li {
    margin: 0 0.5em 0.5em 0;
    list-style-type: none;
    float: left;
  }
  .navigation li button {
    font-size: 1.2em;
  }
</style>
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/controllers/app.controller.ts">
import { Logger, Controller, Get, Post, Render, Body, Param, Res, Req } from '@nestjs/common';
import { Response, Request } from 'express';
import { EventTriggerComponent } from '../components/event-trigger/event-trigger.handler';

import { ComponentRegistry } from 'src/services/component-registry.service';
import { Connection } from 'src/interfaces/connection.interface';
import { Port } from 'src/interfaces/port.interface';
import { FlowExecutorService } from 'src/services/flow-executor.service';
import { TemplateCacheService } from 'src/services/template-cache.service';

@Controller()
export class AppController {
  private readonly logger = new Logger('AppController');
  
  constructor(
    private eventTriggerComponent: EventTriggerComponent,
    private componentRegistry: ComponentRegistry,
    private flowExecutorService: FlowExecutorService,
    private templateCacheService: TemplateCacheService
  ) {}

  @Get()
  @Render('index')
  async root(@Req() req: Request) {
    return { message: 'steam engine = chart + document + logger // FBP' };
  }

  /**
   * svelte app generated in:
   * ./src/public/chart/*
   */

  @Get('flows')
  @Render('flows/index')
  async flowsIndex(
    @Req() req: Request
  ) {
    const flows = await this.flowExecutorService.getFlows();
    return {
      message: 'flows - steam engine // FBP',
      flows
    };
  }

  @Get('flow/:flowId')
  @Render('flow/index')
  async flowComponents(
    @Param('flowId') flowId: string,
    @Req() req: Request
  ) {
    const flow = await this.flowExecutorService.getFlow(flowId);
    const components = flow.components.map(c => ({
      componentId: c.componentId,
      componentRef: c.componentRef
    }));

    return {
      message: 'flow - steam engine // FBP',
      flowId,
      components
    };
  }

  @Get('document/:flowId/:componentId')
  @Render('document/view')
  async documentView(
    @Param('flowId') flowId: string,
    @Param('componentId') componentId: string,
    @Req() req: Request
  ) {
    const flow = await this.flowExecutorService.getFlow(flowId);
    const components = flow.components.map(c => ({
      componentId: c.componentId,
      componentRef: c.componentRef
    }));

    let connections = []
    flow.connections.forEach((connection: Connection) => {
      connections.push({
        fromFlow: connection.fromFlow,
        fromComponent: connection.fromComponent,
        fromEvent: connection.fromEvent,
        toFlow: connection.toFlow,
        toComponent: connection.toComponent,
        toEvent: connection.toEvent,
      })
    })

    return {
      selected: {
        flowId,
        componentId
      },
      components,
      message: `${flowId}.${componentId} - document - steam engine // FBP`,
      connections
    };
  }

  @Get('documentComponent/:flowId/:componentId/:swimlaneId')
  @Render('document/component')
  async documentComponent(
    @Param('flowId') flowId: string,
    @Param('componentId') componentId: string,
    @Param('swimlaneId') swimlaneId: string,
  ) {
    const component = this.componentRegistry.getComponent(flowId, componentId);
  
    if (component) {
      return {
        component,
        swimlaneId
      };
    }
    return {
      component: null,
      swimlaneId
    };
  }

  @Get('documentConnections/:flowId/:componentId/:portId/:swimlaneId')
  @Render('document/connections')
  async documentConnections( 
    @Param('flowId') flowId: string, 
    @Param('componentId') componentId: string,
    @Param('portId') portId: string,
    @Param('swimlaneId') swimlaneId: string,
  ) {
    const params = { flowId, componentId, portId };
    const component = this.componentRegistry.getComponent(flowId, componentId);
    
    if (component) {
      let port: Port = await component.findPort(portId);

      let connections: Connection[] = await component.findConnections(port);

      connections.forEach((connection) => {
        if (port.direction === 'input') {
          connection.next = connection.connectedFrom;
        } else {
          connection.next = connection.connectedTo;
        }
      });

      if (port) {
        if (port.dataMethod === 'publish') {
          return {
            ...params,
            port,
            connections,
            swimlaneId
          };
        } else if (port.dataMethod === 'display') {
          let displayHtmxId = `${flowId}.${componentId}.${port.eventId}`;
          const cacheKey = `${flowId}.${componentId}.${port.eventId}`;
          const cachedTemplate = this.templateCacheService.getTemplate(cacheKey);
          
          return {
            ...params,
            port,
            displayHtmxId,
            swimlaneId,
            templateContent: cachedTemplate || 'Template not found'
          };
        }
      }
    }
    return {
      ...params,
      port: null,
      swimlaneId
    };
  }

  @Get('logger')
  @Render('logger/index')
  async loggerIndex(@Req() req: Request) {
    return { message: 'logger - steam engine // FBP' };
  }

  @Post('trigger-event/:flowComponentEvent')
  async triggerEvent(
    @Param('flowComponentEvent') flowComponentEvent: string,
    @Body() data: any,
    @Res() res: Response
  ) {
    const fceArray = flowComponentEvent.split('.');
    const flowId = fceArray[0];
    const componentId = fceArray[1];
    const eventId = fceArray[2];
    
    this.logger.log(`[trigger-event] [${flowId}] [${componentId}] [${eventId}]`);
    data._flowId = flowId;
    data._componentId = componentId;
    data._eventId = eventId;
    await this.eventTriggerComponent.handleEvent('triggerEvent', data);
    res.sendStatus(200);
  }

  @Get('template/:flowId/:componentId/:templateId')
  async getTemplate(
    @Param('flowId') flowId: string,
    @Param('componentId') componentId: string,
    @Param('templateId') templateId: string,
    @Res() res: Response
  ) {
    const cacheKey = `${flowId}.${componentId}.${templateId}`;
    const cachedTemplate = this.templateCacheService.getTemplate(cacheKey);

    if (cachedTemplate) {
      res.send(cachedTemplate);
    } else {
      res.status(404).send('Template not found');
    }
  }
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/modules/app.module.ts">
import { ComponentRegistry } from '../services/component-registry.service';
import { FlowExecutorService } from '../services/flow-executor.service';
import { EventProcessor } from '../processors/event.processor';
import { CustomLogger } from '../logger/custom-logger';
import { AppController } from '../controllers/app.controller';
import { TemplateCacheService } from 'src/services/template-cache.service';
import { BackplaneService } from '../services/backplane.service';

import { initializeAppModule, components } from '../initializers/app.initialize';

const rabbitmqUri = process.env.RABBITMQ || 'amqp://localhost:5672';
console.log(`[AppModule] RabbitMQ URI: ${rabbitmqUri}`);

const metadata = {
  imports: [],
  controllers: [AppController],
  providers: [
    EventProcessor,
    ComponentRegistry,
    FlowExecutorService,
    TemplateCacheService,
    BackplaneService,
    {
      provide: 'BACKPLANE',
      useFactory: (backplaneService: BackplaneService) => {
        return () => backplaneService.onModuleInit();
      },
      inject: [BackplaneService],
      multi: true,
    },
    {
      provide: 'FLOW_ID',
      useValue: 'example-flow', // Use a default flow ID
    },
    {
      provide: 'COMPONENT_ID',
      useFactory: () => `component-${Date.now()}`, // Generate a unique component ID
    },
    {
      provide: 'WEB_SOCKET_SERVER',
      useValue: null, // This will be set later in the FlowExecutorService
    },
    {
      provide: 'TEMPLATES',
      useValue: null, // This will be set later (?)
    },
    ...components,
    CustomLogger
  ],
  exports: [EventProcessor],
}

export const AppModule = initializeAppModule(metadata)
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/bootstrap/app.bootstrap.ts">
import { NestFactory } from '@nestjs/core';
import { AppModule } from '../modules/app.module';
import { NestExpressApplication } from '@nestjs/platform-express';
import * as cookieParser from 'cookie-parser';
import { FlowExecutorService } from '../services/flow-executor.service';
import { CustomLogger } from '../logger/custom-logger';
import { resolve } from 'path';
import { initializeFlows } from '../initializers/flows.initialize';

export async function bootstrapApp(logger: CustomLogger): Promise<any> {
  const app = await NestFactory.create<NestExpressApplication>(AppModule, { logger });
  
  app.useStaticAssets(resolve('./src/public'));
  app.setBaseViewsDir(resolve('./src/views'));
  app.setViewEngine('ejs');

  app.use(cookieParser());

  // so browsers can use api
  app.enableCors({
    origin: '*',
  });

  const flowExecutor = app.get(FlowExecutorService);

  await app.init();

  logger.log('Starting flow execution...');
  await initializeFlows(flowExecutor);

  await app.listen(3000);
  logger.log('Application is running on: http://localhost:3000');

  return app;
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/interfaces/flow.interface.ts">
import { Connection } from "./connection.interface";

export interface Flow {
  id: string;
  components: {
    componentId: string;
    componentRef: string;
    init: any | undefined;
  }[];
  connections: Connection[];
}
</FILE>
<FILE path="/home/travis/Projects/flow-based-programming/src/interfaces/component.interface.ts">
import { Connection } from "./connection.interface";
import { Port } from "./port.interface";

export interface Component {
  ports: { inputs: string[]; outputs: string[]; };
  componentRef: string;
  slug: string;
  description?: string;
  flowId: string;
  componentId: string;
  handleEvent: (eventId: string, data: any) => Promise<void>;
  publish: (flowId: string, componentId: string, eventId: string, data: any) => Promise<void>;
  getPorts: () => Promise<{ inputs: Port[], outputs: Port[] }>;
  findPort: (portId: string) => Promise<Port>;
  findConnections: (port: Port) => Promise<Connection[]>
}
</FILE>
<FILE path="src/templates/benchmark-results.ejs" TARGET>
<div id="benchmark-results">
  <h2>Benchmark Results</h2>
  <table>
    <thead>
      <tr>
        <th>Message Size</th>
        <th>Message Count</th>
        <th>Average Processing Time</th>
        <th>Messages per Second</th>
      </tr>
    </thead>
    <tbody>
      <% for (const [size, data] of Object.entries(results)) { %>
        <tr>
          <td><%= size %> bytes</td>
          <td><%= data.messageCount %></td>
          <td><%= data.averageProcessingTime.toFixed(2) %> ms</td>
          <td><%= data.messagesPerSecond %></td>
        </tr>
      <% } %>
    </tbody>
  </table>
</div>
</FILE>
<REQUEST>
should show total average messages per second
</REQUEST>