@canmingir/link-express 1.7.0 → 1.7.2

package/bin/event-listener.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+require("ts-node").register({
+  transpileOnly: true,
+  compilerOptions: {
+    module: "commonjs",
+    esModuleInterop: true,
+  },
+});
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function parseArgs(args: string[]) {
+  const options: Record<string, string> = {};
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith("-p") || args[i].startsWith("--port")) {
+      options.port = args[i + 1];
+      i++;
+    }
+  }
+  return options;
+}
+
+if (command === "start") {
+  const options = parseArgs(args);
+  if (options.port) {
+    process.env.PORT = options.port;
+  }
+  require("../src/event/server/server.ts");
+} else {
+  console.log("Usage: event-listener start [-p <port>]");
+  console.log("\nCommands:");
+  console.log("  start    Start the event server");
+  console.log("\nOptions:");
+  console.log("  -p, --port    Port to listen on (default: 8080)");
+  process.exit(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canmingir/link-express",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "",
   "main": "index.ts",
   "types": "index.ts",
@@ -23,10 +23,16 @@
       ],
       "sequelize": [
         "src/sequelize.ts"
+      ],
+      "event": [
+        "src/event/index.ts"
       ]
     }
   },
   "author": "NucTeam",
+  "bin": {
+    "event-listener": "./bin/event-listener.ts"
+  },
   "exports": {
     ".": "./index.ts",
     "./models": "./src/models/index.ts",
@@ -34,7 +40,10 @@
     "./authorization": "./src/authorization.ts",
     "./error": "./src/error.ts",
     "./types": "./src/types/index.ts",
-    "./sequelize": "./src/sequelize.ts"
+    "./sequelize": "./src/sequelize.ts",
+    "./event": "./src/event/serc/Event.ts",
+    "./event/client": "./src/event/client/index.ts",
+    "./event/server": "./src/event/server/server.ts"
   },
   "scripts": {
     "prepare": "tsx prepare.ts",
@@ -57,15 +66,20 @@
     "joi": "^17.13.3",
     "joi-to-swagger": "^6.2.0",
     "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
     "lodash": "^4.17.21",
     "morgan": "^1.10.0",
+    "oracledb": "^6.10.0",
     "pg": "^8.12.0",
     "pino": "^10.1.0",
     "pino-elasticsearch": "^8.1.0",
     "prom-client": "^15.1.3",
     "sequelize": "^6.37.7",
     "sequelize-typescript": "^2.1.6",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
     "swagger-jsdoc": "^6.2.8",
+    "ts-node": "^10.9.2",
     "uuid": "^10.0.0"
   },
   "devDependencies": {

package/src/event/client/adapters/KafkaAdapter.ts

@@ -0,0 +1,140 @@
+import { Consumer, Kafka, Producer } from "kafkajs";
+
+import { EventAdapter } from "../types/types";
+
+export class KafkaAdapter implements EventAdapter {
+  private kafka: Kafka;
+  private consumer: Consumer | null = null;
+  private producer: Producer | null = null;
+  private messageHandler?: (type: string, payload: object) => void;
+
+  constructor(
+    private readonly options: {
+      clientId: string;
+      brokers: string[];
+      groupId: string;
+      topics: string[]; 
+    }
+  ) {
+    this.kafka = new Kafka({
+      clientId: options.clientId,
+      brokers: options.brokers,
+    });
+  }
+
+  async connect(): Promise<void> {
+    this.producer = this.kafka.producer();
+    await this.producer.connect();
+    this.consumer = this.kafka.consumer({ groupId: this.options.groupId });
+
+    await this.consumer.connect();
+    await this.consumer.subscribe({
+      topics: [/^(?!__).*$/],
+      fromBeginning: false,
+    });
+    await this.consumer.run({
+      partitionsConsumedConcurrently: 160,
+      eachMessage: async ({ topic, message }) => {
+        if (topic.startsWith("__")) {
+          return;
+        }
+
+        if (this.messageHandler) {
+          try {
+            const payload = JSON.parse(message.value?.toString() || "{}");
+            this.messageHandler(topic, payload);
+          } catch (error) {
+            console.error(
+              `Error processing message for topic ${topic}:`,
+              error
+            );
+          }
+        }
+      },
+    });
+    console.log(`Kafka consumer connected`);
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.consumer) {
+      await this.consumer.stop();
+      await this.consumer.disconnect();
+      this.consumer = null;
+    }
+    if (this.producer) {
+      await this.producer.disconnect();
+      this.producer = null;
+    }
+  }
+
+  async publish<T = object>(type: string, payload: T): Promise<void> {
+    if (!this.producer) {
+      throw new Error("Producer not connected");
+    }
+    this.producer.send({
+      topic: type,
+      messages: [{ value: JSON.stringify(payload) }],
+    }).then(() => {
+      console.log(`Message published to topic ${type}`);
+    }).catch((error) => {
+      console.error(`Error publishing message to topic ${type}:`, error);
+      return Promise.reject(error);
+    });
+  }
+
+  async subscribe(type: string): Promise<void> {
+    // No-op: EventManager handles callback registration in memory
+  }
+
+  async unsubscribe(type: string): Promise<void> {
+    // No-op: EventManager handles callback removal in memory
+  }
+
+  onMessage(handler: (type: string, payload: object) => void): void {
+    this.messageHandler = handler;
+  }
+
+  async getBacklog(topics: string[]): Promise<Map<string, number>> {
+    const backlogMap = new Map<string, number>();
+
+    if (topics.length === 0) {
+      return backlogMap;
+    }
+
+    const admin = this.kafka.admin();
+    await admin.connect();
+
+    try {
+      for (const topic of topics) {
+        const offsetsResponse = await admin.fetchOffsets({
+          groupId: this.options.groupId,
+          topics: [topic],
+        });
+
+        const topicOffsets = await admin.fetchTopicOffsets(topic);
+        let totalLag = 0;
+
+        const topicResponse = offsetsResponse.find((r) => r.topic === topic);
+        if (topicResponse) {
+          topicResponse.partitions.forEach((partitionOffset) => {
+            const latestOffset = topicOffsets.find(
+              (to) => to.partition === partitionOffset.partition
+            );
+
+            if (latestOffset) {
+              const consumerOffset = parseInt(partitionOffset.offset);
+              const latestOffsetValue = parseInt(latestOffset.offset);
+              totalLag += Math.max(0, latestOffsetValue - consumerOffset);
+            }
+          });
+        }
+
+        backlogMap.set(topic, totalLag);
+      }
+    } finally {
+      await admin.disconnect();
+    }
+
+    return backlogMap;
+  }
+}

package/src/event/client/adapters/SocketAdapter.ts

@@ -0,0 +1,59 @@
+import { Socket, io } from "socket.io-client";
+
+import { EventAdapter } from "../types/types";
+
+export class SocketAdapter implements EventAdapter {
+  private socket: Socket | null = null;
+  private messageHandler?: (type: string, payload: object) => void;
+
+  constructor(private readonly options: {
+    host: string;
+    port?: number;
+    protocol: string;
+  }) {}
+
+  async connect(): Promise<void> {
+    const { host, port, protocol } = this.options;
+    const socketPath = port ? `${protocol}://${host}:${port}` : `${protocol}://${host}`;
+    
+    this.socket = io(socketPath);
+    
+    this.socket.on("event", ({ type, payload }: { type: string; payload: object }) => {
+      if (this.messageHandler) {
+        this.messageHandler(type, payload);
+      }
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+
+  async publish(type: string, payload: object): Promise<void> {
+    if (!this.socket) {
+      throw new Error("Socket not connected");
+    }
+    this.socket.emit("publish", { type, payload });
+  }
+
+  async subscribe(type: string): Promise<void> {
+    if (!this.socket) {
+      throw new Error("Socket not connected");
+    }
+    this.socket.emit("subscribe", type);
+  }
+
+  async unsubscribe(type: string): Promise<void> {
+    if (!this.socket) {
+      throw new Error("Socket not connected");
+    }
+    this.socket.emit("unsubscribe", type);
+  }
+
+  onMessage(handler: (type: string, payload: object) => void): void {
+    this.messageHandler = handler;
+  }
+}

package/src/event/client/adapters/TxEventQAdapter.ts

@@ -0,0 +1,232 @@
+import * as oracledb from "oracledb";
+
+import { EventAdapter } from "../types/types";
+
+export class TxEventQAdapter implements EventAdapter {
+  private connection: oracledb.Connection | null = null;
+  private queue: oracledb.AdvancedQueue<any> | null = null;
+  private queueCache: Map<string, oracledb.AdvancedQueue<any>> = new Map();
+  private messageHandler?: (type: string, payload: object) => void;
+  private isRunning: boolean = false;
+
+  constructor(
+    private readonly options: {
+      connectString: string;
+      user: string;
+      password: string;
+      instantClientPath?: string;
+      walletPath?: string;
+      consumerName?: string;
+      batchSize?: number;
+      waitTime?: number;
+      autoCommit?: boolean;
+    }
+  ) {}
+
+  async connect(): Promise<void> {
+    try {
+      if (this.options.instantClientPath && oracledb.thin) {
+        try {
+          oracledb.initOracleClient({
+            libDir: this.options.instantClientPath,
+            configDir: this.options.walletPath,
+            walletPath: this.options.walletPath,
+          });
+          console.log("Oracle Thick client initialized");
+        } catch (initError: any) {
+          if (initError.code !== "NJS-509") {
+            throw initError;
+          }
+          console.log("Oracle Thick client already initialized");
+        }
+      }
+
+      this.connection = await oracledb.getConnection({
+        connectString: this.options.connectString,
+        user: this.options.user,
+        password: this.options.password,
+        configDir: this.options.walletPath,
+        walletPath: this.options.walletPath,
+      });
+
+      this.isRunning = true;
+
+      console.log("TxEventQ adapter connected successfully");
+    } catch (error: any) {
+      console.error("Failed to connect to TxEventQ:", error.message);
+      throw error;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this.isRunning = false;
+
+    if (this.connection) {
+      try {
+        this.queueCache.clear();
+
+        await this.connection.close();
+        console.log("TxEventQ connection closed");
+      } catch (error) {
+        console.error("Error closing TxEventQ connection:", error);
+      }
+      this.connection = null;
+      this.queue = null;
+    }
+  }
+
+  private async getOrCreateQueue(
+    queueName: string,
+    options: any
+  ): Promise<oracledb.AdvancedQueue<any>> {
+    if (!this.connection) {
+      throw new Error("TxEventQAdapter not connected");
+    }
+
+    if (this.queueCache.has(queueName)) {
+      return this.queueCache.get(queueName)!;
+    }
+
+    const queue = await this.connection.getQueue(queueName, options);
+    this.queueCache.set(queueName, queue);
+
+    console.log(`Queue ${queueName} cached`);
+
+    return queue;
+  }
+
+  async publish<T = object>(type: string, payload: T): Promise<void> {
+    if (!this.connection) {
+      throw new Error("TxEventQAdapter not connected");
+    }
+
+    const queueName = type;
+
+    this.queue = await this.getOrCreateQueue(queueName, {
+      payloadType: oracledb.DB_TYPE_JSON,
+    } as any);
+
+    const message = {
+      topic: type,
+      payload: payload,
+    };
+
+    this.queue
+      .enqOne({
+        payload: message,
+        correlation: type,
+        priority: 0,
+        delay: 0,
+        expiration: -1,
+        exceptionQueue: "",
+      } as any)
+      .then(() => {
+        this.connection.commit();
+      });
+  }
+
+  async subscribe(type: string): Promise<void> {
+    if (!this.connection) {
+      throw new Error("Subscriber not initialized");
+    }
+    this.isRunning = true;
+
+    const queueName = `TXEVENTQ_USER.${type}`;
+
+    this.queue = await this.getOrCreateQueue(queueName, {
+      payloadType: oracledb.DB_TYPE_JSON,
+    });
+
+    this.queue.deqOptions.wait = 5000;
+    this.queue.deqOptions.consumerName =
+      this.options.consumerName || `${type.toLowerCase()}_subscriber`;
+    try {
+      while (this.isRunning) {
+        let messages: oracledb.AdvancedQueueMessage[] = [];
+
+        const message = await this.queue.deqOne();
+        if (message) {
+          messages = [message];
+        }
+        if (messages && messages.length > 0) {
+          if (this.messageHandler) {
+            try {
+              const payload = message.payload.payload || {};
+              this.messageHandler(type, payload);
+            } catch (error) {
+              console.error(
+                `Error processing message for topic ${type}:`,
+                error
+              );
+            }
+          }
+          if (this.options.autoCommit) {
+            await this.connection.commit();
+            console.log(
+              `Transaction committed for ${messages.length} message(s)`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Fatal error during consumption:", error);
+      throw error;
+    }
+  }
+
+  async unsubscribe(type: string): Promise<void> {
+    if (!this.connection) {
+      throw new Error("Subscriber not initialized");
+    }
+    this.isRunning = false;
+    this.queue = null;
+  }
+
+  onMessage(handler: (type: string, payload: object) => void): void {
+    this.messageHandler = handler;
+  }
+
+  async getBacklog(topics: string[]): Promise<Map<string, number>> {
+    const backlogMap = new Map<string, number>();
+    if (!this.connection || !topics?.length) return backlogMap;
+
+    const sql = `
+      SELECT NVL(SUM(s.ENQUEUED_MSGS - s.DEQUEUED_MSGS), 0) AS BACKLOG
+        FROM GV$AQ_SHARDED_SUBSCRIBER_STAT s
+        JOIN USER_QUEUES q
+          ON q.QID = s.QUEUE_ID
+        JOIN USER_QUEUE_SUBSCRIBERS sub
+          ON sub.SUBSCRIBER_ID = s.SUBSCRIBER_ID
+         AND sub.QUEUE_NAME = q.NAME
+       WHERE q.NAME IN (:queueName1, :queueName2)
+         AND (:consumerName IS NULL OR sub.CONSUMER_NAME = :consumerName)
+    `;
+
+    const consumerName =
+      typeof this.options.consumerName === "string"
+        ? this.options.consumerName
+        : null;
+
+    for (const topic of topics) {
+      const queueName1 = `TXEVENTQ_USER.${topic}`;
+      const queueName2 = topic;
+
+      try {
+        const result = await this.connection.execute(
+          sql,
+          { queueName1, queueName2, consumerName },
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
+        );
+
+        const rows = (result.rows || []) as Array<{ BACKLOG: number }>;
+        const val = Number(rows?.[0]?.BACKLOG ?? 0);
+        backlogMap.set(topic, isNaN(val) ? 0 : val);
+      } catch (err) {
+        console.error(`Backlog query failed for topic ${topic}:`, err);
+        backlogMap.set(topic, 0);
+      }
+    }
+
+    return backlogMap;
+  }
+}

package/src/event/client/eventManager.ts

@@ -0,0 +1,244 @@
+import { Callback, EventAdapter, InitOptions } from "./types/types";
+import { EventMetrics, PushgatewayConfig } from "./metrics";
+
+import { KafkaAdapter } from "./adapters/KafkaAdapter";
+import { SocketAdapter } from "./adapters/SocketAdapter";
+import { TxEventQAdapter } from "./adapters/TxEventQAdapter";
+
+const TOPICS = [
+  "KNOWLEDGE_CREATED",
+  "MESSAGE_USER_MESSAGED",
+  "SESSION_USER_MESSAGED",
+  "TASK_CREATED",
+  "STEP_ADDED",
+  "STEP_COMPLETED",
+  "MESSAGE_USER_MESSAGED",
+  "MESSAGE_ASSISTANT_MESSAGED",
+  "RESPONSIBILITY_CREATED",
+  "RESPONSIBILITY_DESCRIPTION_GENERATED",
+  "SESSION_INITIATED",
+  "SESSION_USER_MESSAGED",
+  "SESSION_AI_MESSAGED",
+  "SUPERVISING_RAISED",
+  "SUPERVISING_ANSWERED",
+  "TASK_COMPLETED",
+  "KNOWLEDGES_LOADED",
+  "MESSAGES_LOADED",
+];
+export class EventManager {
+  private adapter: EventAdapter | null = null;
+  private callbacks: Map<string, Set<Callback>> = new Map();
+  private metrics = new EventMetrics();
+  private backlogInterval: NodeJS.Timeout | null = null;
+
+  async init(options: InitOptions): Promise<void> {
+    if (this.adapter) {
+      await this.disconnect();
+    }
+    switch (options.type) {
+      case "inMemory":
+        this.adapter = new SocketAdapter({
+          host: options.host,
+          port: options.port,
+          protocol: options.protocol,
+        });
+        break;
+      case "kafka":
+        this.adapter = new KafkaAdapter({
+          clientId: options.clientId,
+          brokers: options.brokers,
+          groupId: options.groupId,
+          topics: TOPICS,
+        });
+        this.startBacklogMonitoring();
+        break;
+
+      case "txeventq":
+        this.adapter = new TxEventQAdapter({
+          connectString: options.connectString,
+          user: options.user,
+          password: options.password,
+          instantClientPath: options.instantClientPath,
+          walletPath: options.walletPath,
+          consumerName: options.consumerName,
+          batchSize: options.batchSize,
+          waitTime: options.waitTime,
+        });
+        this.startBacklogMonitoring();
+        break;
+
+      default:
+        throw new Error(`Unknown adapter type`);
+    }
+    await this.adapter.connect();
+
+    this.adapter.onMessage((type, payload) => {
+      this.handleIncomingMessage(type, payload);
+    });
+  }
+
+  async publish<T extends object = object>(
+    ...args: [...string[], T]
+  ): Promise<void> {
+    if (args.length < 1) {
+      throw new Error("publish requires at least one event type and a payload");
+    }
+    if (!this.adapter) {
+      throw new Error("Event system not initialized");
+    }
+    const payload = args[args.length - 1] as T;
+    const type = args.slice(0, -1) as string[];
+    const mergedType = type.join("_");
+    this.validateEventType(mergedType);
+    const payloadSize = JSON.stringify(payload).length;
+    const endTimer = this.metrics.recordPublish(mergedType, payloadSize);
+    try {
+      await this.adapter.publish(mergedType, payload);
+      this.executeCallbacks(mergedType, payload);
+      endTimer();
+    } catch (error) {
+      this.metrics.recordPublishError(mergedType, "publish_error");
+      endTimer();
+      throw error;
+    }
+  }
+
+  async subscribe<T extends object = object>(
+    type: string,
+    callback: Callback<T>
+  ): Promise<() => void> {
+    if (!this.callbacks.has(type)) {
+      this.callbacks.set(type, new Set());
+    }
+
+    const callbackSet = this.callbacks.get(type)!;
+    callbackSet.add(callback as Callback);
+
+    this.metrics.updateSubscriptions(type, callbackSet.size);
+
+    if (this.adapter && callbackSet.size === 1) {
+      await this.adapter.subscribe(type);
+    }
+
+    return async () => {
+      callbackSet.delete(callback as Callback);
+
+      if (callbackSet.size === 0) {
+        this.callbacks.delete(type);
+        if (this.adapter) {
+          await this.adapter.unsubscribe(type);
+        }
+      }
+
+      this.metrics.updateSubscriptions(type, callbackSet.size);
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    this.stopBacklogMonitoring();
+
+    if (this.adapter) {
+      await this.adapter.disconnect();
+      this.adapter = null;
+    }
+
+    this.callbacks.clear();
+  }
+
+  private handleIncomingMessage(type: string, payload: object): void {
+    this.executeCallbacks(type, payload);
+  }
+
+  private executeCallbacks(type: string, payload: object): void {
+    const callbackSet = this.callbacks.get(type);
+    if (!callbackSet) return; // No callbacks for this topic - message ignored
+
+    callbackSet.forEach((callback) => {
+      setTimeout(() => {
+        const endTimer = this.metrics.recordCallback(type);
+        try {
+          callback(payload);
+        } catch (error) {
+          console.error(`Error in callback for ${type}:`, error);
+        }
+        endTimer();
+      }, 0);
+    });
+  }
+
+  private validateEventType(type: string): void {
+    if (
+      type === "__proto__" ||
+      type === "constructor" ||
+      type === "prototype"
+    ) {
+      throw new Error("Invalid event type");
+    }
+  }
+
+  private startBacklogMonitoring(intervalMs: number = 60000): void {
+    if (!this.adapter) return;
+
+    // Only monitor for adapters that implement meaningful backlog
+    const supportsBacklog =
+      this.adapter instanceof KafkaAdapter ||
+      this.adapter instanceof TxEventQAdapter;
+
+    if (!supportsBacklog) return;
+
+    this.updateBacklogMetrics();
+
+    this.backlogInterval = setInterval(() => {
+      this.updateBacklogMetrics();
+    }, intervalMs);
+  }
+
+  private stopBacklogMonitoring(): void {
+    if (this.backlogInterval) {
+      clearInterval(this.backlogInterval);
+      this.backlogInterval = null;
+    }
+  }
+
+  private async updateBacklogMetrics(): Promise<void> {
+    if (!this.adapter) return;
+
+    const supportsBacklog =
+      this.adapter instanceof KafkaAdapter ||
+      this.adapter instanceof TxEventQAdapter;
+
+    if (!supportsBacklog) return;
+
+    try {
+      const backlog = await (
+        this.adapter as KafkaAdapter | TxEventQAdapter
+      ).getBacklog(TOPICS);
+      backlog.forEach((size, topic) => {
+        this.metrics.updateEventBacklog(topic, size);
+        console.log(`Backlog for topic ${topic}: ${size} messages`);
+      });
+    } catch (error) {
+      console.error("Error updating backlog metrics:", error);
+    }
+  }
+
+  async checkBacklog(): Promise<void> {
+    await this.updateBacklogMetrics();
+  }
+
+  startPushgateway(config?: PushgatewayConfig): void {
+    this.metrics.startPushgateway(config);
+  }
+
+  stopPushgateway(): void {
+    this.metrics.stopPushgateway();
+  }
+
+  async pushMetricsToGateway(): Promise<void> {
+    await this.metrics.pushMetricsToGateway();
+  }
+
+  getPushgatewayConfig(): PushgatewayConfig | undefined {
+    return this.metrics.getPushgatewayConfig();
+  }
+}

package/src/event/client/index.ts

@@ -0,0 +1,50 @@
+import * as client from "prom-client";
+
+import { Callback, InitOptions } from "./types/types";
+import { EventMetrics, PushgatewayConfig } from "./metrics";
+
+import { EventManager } from "./eventManager";
+import { KafkaAdapter } from "./adapters/KafkaAdapter";
+import { SocketAdapter } from "./adapters/SocketAdapter";
+import { TxEventQAdapter } from "./adapters/TxEventQAdapter";
+
+const manager = new EventManager();
+
+export const event = {
+  init: (options: InitOptions) => manager.init(options),
+  publish: <T extends object = object>(...args: [...string[], T]) =>
+    manager.publish(...args),
+  subscribe: <T extends object = object>(type: string, callback: Callback<T>) =>
+    manager.subscribe(type, callback),
+  disconnect: () => manager.disconnect(),
+  checkBacklog: () => manager.checkBacklog(),
+
+  startBacklogMonitoring: () => {
+    console.log("Backlog monitoring starts automatically with Kafka adapter");
+  },
+  stopBacklogMonitoring: () => {
+    console.log("Backlog monitoring stops automatically on disconnect");
+  },
+  restartKafkaConsumer: async () => {
+    console.log("Consumer restart is handled automatically");
+  },
+
+  startPushgateway: (config?: PushgatewayConfig) =>
+    manager.startPushgateway(config),
+  stopPushgateway: () => manager.stopPushgateway(),
+  pushMetricsToGateway: () => manager.pushMetricsToGateway(),
+  getPushgatewayConfig: () => manager.getPushgatewayConfig(),
+};
+
+export { client };
+
+export {
+  EventManager,
+  EventMetrics,
+  SocketAdapter,
+  KafkaAdapter,
+  TxEventQAdapter,
+};
+export type { PushgatewayConfig };
+export * from "./types/types";
+

package/src/event/client/metrics.ts

@@ -0,0 +1,171 @@
+import * as client from "prom-client";
+
+export interface PushgatewayConfig {
+  url?: string;
+  jobName?: string;
+  instance?: string;
+  interval?: number;
+}
+
+export class EventMetrics {
+  private readonly registry: client.Registry;
+  private pushgatewayInterval?: NodeJS.Timeout;
+  private pushgatewayConfig?: PushgatewayConfig;
+
+  private readonly publishCounter: client.Counter<string>;
+  private readonly subscriptionGauge: client.Gauge<string>;
+  private readonly publishDuration: client.Histogram<string>;
+  private readonly payloadSize: client.Histogram<string>;
+  private readonly publishErrors: client.Counter<string>;
+  private readonly callbackDuration: client.Histogram<string>;
+  private readonly throughput: client.Counter<string>;
+  private readonly eventBacklog: client.Gauge<string>;
+
+  constructor() {
+    this.registry = new client.Registry();
+
+    this.publishCounter = new client.Counter({
+      name: "events_published_total",
+      help: "Total number of events published",
+      labelNames: ["event_type"],
+      registers: [this.registry],
+    });
+
+    this.subscriptionGauge = new client.Gauge({
+      name: "active_event_subscriptions",
+      help: "Number of active event subscriptions",
+      labelNames: ["event_type"],
+      registers: [this.registry],
+    });
+
+    this.publishDuration = new client.Histogram({
+      name: "event_publish_duration_seconds",
+      help: "Time taken to publish events",
+      labelNames: ["event_type"],
+      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5],
+      registers: [this.registry],
+    });
+
+    this.payloadSize = new client.Histogram({
+      name: "event_payload_size_bytes",
+      help: "Size of event payloads in bytes",
+      labelNames: ["event_type"],
+      buckets: [10, 100, 1000, 10000, 100000, 1000000],
+      registers: [this.registry],
+    });
+
+    this.publishErrors = new client.Counter({
+      name: "event_publish_errors_total",
+      help: "Total number of event publish errors",
+      labelNames: ["event_type", "error_type"],
+      registers: [this.registry],
+    });
+
+    this.callbackDuration = new client.Histogram({
+      name: "event_callback_duration_seconds",
+      help: "Time taken to process event callbacks",
+      labelNames: ["event_type"],
+      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5],
+      registers: [this.registry],
+    });
+
+    this.throughput = new client.Counter({
+      name: "event_callbacks_processed_total",
+      help: "Total number of event callbacks processed successfully",
+      labelNames: ["event_type"],
+      registers: [this.registry],
+    });
+
+    this.eventBacklog = new client.Gauge({
+      name: "backlog_events_total",
+      help: "Total number of events waiting to be processed",
+      labelNames: ["topic"],
+      registers: [this.registry],
+    });
+  }
+
+  recordPublish(type: string, payloadSizeBytes: number): () => void {
+    this.publishCounter.labels(type).inc();
+    this.payloadSize.labels(type).observe(payloadSizeBytes);
+    return this.publishDuration.labels(type).startTimer();
+  }
+
+  recordPublishError(type: string, errorType: string): void {
+    this.publishErrors.labels(type, errorType).inc();
+  }
+
+  recordCallback(type: string): () => void {
+    this.throughput.labels(type).inc();
+    return this.callbackDuration.labels(type).startTimer();
+  }
+
+  updateSubscriptions(type: string, count: number): void {
+    this.subscriptionGauge.labels(type).set(count);
+  }
+
+  updateEventBacklog(topic: string, size: number): void {
+    this.eventBacklog.labels(topic).set(size);
+  }
+
+  startPushgateway(config: PushgatewayConfig = {}): void {
+    this.pushgatewayConfig = {
+      url: config.url || "http://localhost:9091",
+      jobName: config.jobName || "node_events",
+      instance: config.instance || "default_instance",
+      interval: config.interval || 15000,
+    };
+
+    this.stopPushgateway();
+
+    this.pushgatewayInterval = setInterval(() => {
+      this.pushMetricsToGateway();
+    }, this.pushgatewayConfig.interval);
+
+    console.log(
+      `Started pushing metrics to Pushgateway every ${this.pushgatewayConfig.interval}ms`
+    );
+  }
+
+  stopPushgateway(): void {
+    if (this.pushgatewayInterval) {
+      clearInterval(this.pushgatewayInterval);
+      this.pushgatewayInterval = undefined;
+      console.log("Stopped pushing metrics to Pushgateway");
+    }
+  }
+
+  async pushMetricsToGateway(): Promise<void> {
+    if (!this.pushgatewayConfig) {
+      throw new Error(
+        "Pushgateway not configured. Call startPushgateway() first."
+      );
+    }
+
+    try {
+      const body = await this.registry.metrics();
+      let url = `${this.pushgatewayConfig.url}/metrics/job/${this.pushgatewayConfig.jobName}`;
+
+      if (this.pushgatewayConfig.instance) {
+        url += `/instance/${this.pushgatewayConfig.instance}`;
+      }
+
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body,
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      console.log("Metrics pushed to Pushgateway successfully");
+    } catch (err) {
+      console.error("Failed to push metrics to Pushgateway:", err);
+    }
+  }
+
+  getPushgatewayConfig(): PushgatewayConfig | undefined {
+    return this.pushgatewayConfig;
+  }
+}

package/src/event/client/types/types.ts

@@ -0,0 +1,43 @@
+export type Callback<T = object> = (payload: T) => void;
+
+export interface EventAdapter {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  publish(type: string, payload: object): Promise<void>;
+  subscribe(type: string): Promise<void>;
+  unsubscribe(type: string): Promise<void>;
+  onMessage(handler: (type: string, payload: object) => void): void;
+}
+
+export interface BaseInitOptions {
+  type: "inMemory" | "kafka" | "txeventq";
+}
+
+export interface InMemoryOptions extends BaseInitOptions {
+  type: "inMemory";
+  host: string;
+  port?: number;
+  protocol: string;
+}
+
+export interface KafkaOptions extends BaseInitOptions {
+  type: "kafka";
+  clientId: string;
+  brokers: string[];
+  groupId: string;
+}
+
+export interface TxEventQOptions extends BaseInitOptions {
+  type: "txeventq";
+  connectString: string;
+  user: string;
+  password: string;
+  instantClientPath?: string;
+  walletPath?: string;
+  consumerName?: string;
+  batchSize?: number;
+  waitTime?: number;
+  topics?: string[];
+}
+
+export type InitOptions = InMemoryOptions | KafkaOptions | TxEventQOptions;

package/src/event/index.ts

@@ -0,0 +1,3 @@
+import { subscribe, publish } from "./src/Event";
+
+export { subscribe, publish };

package/src/event/server/server.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { Server, Socket } from "socket.io";
+import http = require("http");
+
+const server = http.createServer();
+const io = new Server(server, {
+  cors: { origin: "*" },
+});
+
+type Subscriptions = Record<string, Set<string>>;
+const subscriptions: Subscriptions = {};
+
+io.on("connection", (socket: Socket) => {
+  console.log("Client connected:", socket.id);
+
+  socket.on("subscribe", (type: string) => {
+    if (!subscriptions[type]) subscriptions[type] = new Set();
+    subscriptions[type].add(socket.id);
+    console.log(`Socket ${socket.id} subscribed to ${type}`);
+  });
+
+  socket.on("unsubscribe", (type: string) => {
+    if (subscriptions[type]) {
+      subscriptions[type].delete(socket.id);
+      if (subscriptions[type].size === 0) delete subscriptions[type];
+      console.log(`Socket ${socket.id} unsubscribed from ${type}`);
+    }
+  });
+
+  socket.on(
+    "publish",
+    ({ type, payload }: { type: string; payload: object }) => {
+      console.log(`Publish: ${type}`, payload);
+      if (subscriptions[type]) {
+        subscriptions[type].forEach((sid) => {
+          if (sid !== socket.id) {
+            io.to(sid).emit("event", { type, payload });
+          }
+        });
+      }
+    }
+  );
+
+  socket.on("disconnect", () => {
+    Object.keys(subscriptions).forEach((type) => {
+      subscriptions[type].delete(socket.id);
+      if (subscriptions[type].size === 0) delete subscriptions[type];
+    });
+    console.log("Client disconnected:", socket.id);
+  });
+});
+
+const PORT = process.env.PORT || 8080;
+server.listen(PORT, () => {
+  console.log(`Event server listening on port ${PORT}`);
+});

package/src/event/src/Event.ts

@@ -0,0 +1,201 @@
+import client from "prom-client";
+import { v4 as uuid } from "uuid";
+
+const subscriptions = {};
+const messages = new Map();
+
+const eventPublishCounter = new client.Counter({
+  name: "events_published_total",
+  help: "Total number of events published",
+  labelNames: ["event_type"],
+});
+
+const eventSubscriptionGauge = new client.Gauge({
+  name: "active_event_subscriptions",
+  help: "Number of active event subscriptions",
+  labelNames: ["event_type"],
+});
+
+const eventPublishDuration = new client.Histogram({
+  name: "event_publish_duration_seconds",
+  help: "Time taken to publish events",
+  labelNames: ["event_type"],
+  buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5],
+});
+
+// Track payload size for analysis
+const eventPayloadSize = new client.Histogram({
+  name: "event_payload_size_bytes",
+  help: "Size of event payloads in bytes",
+  labelNames: ["event_type"],
+  buckets: [10, 100, 1000, 10000, 100000, 1000000],
+});
+
+// Track error rates
+const eventPublishErrors = new client.Counter({
+  name: "event_publish_errors_total",
+  help: "Total number of event publish errors",
+  labelNames: ["event_type", "error_type"],
+});
+
+// Track callback processing duration
+const callbackProcessingDuration = new client.Histogram({
+  name: "event_callback_duration_seconds",
+  help: "Time taken to process event callbacks",
+  labelNames: ["event_type"],
+  buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5],
+});
+
+// Track subscription rates
+const subscriptionRate = new client.Counter({
+  name: "event_subscriptions_total",
+  help: "Total number of event subscriptions created",
+  labelNames: ["event_type"],
+});
+
+// Track unsubscription rates
+const unsubscriptionRate = new client.Counter({
+  name: "event_unsubscriptions_total",
+  help: "Total number of event unsubscriptions",
+  labelNames: ["event_type"],
+});
+
+// Track throughput (events processed per second)
+const eventThroughput = new client.Counter({
+  name: "event_callbacks_processed_total",
+  help: "Total number of event callbacks processed successfully",
+  labelNames: ["event_type"],
+});
+
+const colors = [
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "gray",
+];
+
+function typeColor(type) {
+  const hash = (str) => {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  };
+
+  const colorIndex = hash(type) % colors.length;
+  return colors[colorIndex];
+}
+
+const subscribe = (...args) => {
+  if (args.length < 2) {
+    throw new Error("subscribe requires at least 2 arguments");
+  }
+
+  const callback = args.pop();
+  const type = args.join(".");
+  const id = uuid();
+
+  console.debug("node-event", "subscribe", type, id);
+
+  if (type === "__proto__" || type === "constructor" || type === "prototype") {
+    throw new Error("Invalid subscription type");
+  }
+  if (!subscriptions[type]) {
+    subscriptions[type] = {};
+  }
+
+  const registry = {
+    id,
+    type,
+    callback,
+    unsubscribe: () => {
+      console.debug("node-event", "unsubscribe", type, id);
+      delete subscriptions[type][id];
+
+      // Track unsubscription
+      unsubscriptionRate.labels(type).inc();
+
+      if (Object.keys(subscriptions[type]).length === 0) {
+        delete subscriptions[type];
+        eventSubscriptionGauge.labels(type).set(0);
+      } else {
+        eventSubscriptionGauge
+          .labels(type)
+          .set(Object.keys(subscriptions[type]).length);
+      }
+    },
+  };
+
+  subscriptions[type][id] = registry;
+
+  // Update subscription metrics
+  subscriptionRate.labels(type).inc();
+  eventSubscriptionGauge
+    .labels(type)
+    .set(Object.keys(subscriptions[type]).length);
+
+  return registry;
+};
+
+const publish = (...args) => {
+  if (args.length < 2) {
+    throw new Error("publish requires at least 2 arguments");
+  }
+
+  const payload = args.pop();
+  const type = args.join(".");
+
+  console.log("node-event", "publish", type, payload);
+  messages.set(type, payload);
+
+  if (type === "__proto__" || type === "constructor" || type === "prototype") {
+    throw new Error("Invalid publish type");
+  }
+
+  // Track metrics for event publishing
+  const endTimer = eventPublishDuration.labels(type).startTimer();
+  eventPublishCounter.labels(type).inc();
+
+  // Track payload size
+  const payloadSize = JSON.stringify(payload).length;
+  eventPayloadSize.labels(type).observe(payloadSize);
+
+  Object.keys(subscriptions[type] || {}).forEach((key) => {
+    const registry = subscriptions[type][key];
+
+    setTimeout(() => {
+      const callbackTimer = callbackProcessingDuration
+        .labels(type)
+        .startTimer();
+      try {
+        registry.callback(payload, registry);
+        eventThroughput.labels(type).inc();
+      } catch (err) {
+        console.error("node-event", "error", type, err);
+        const errorName = err instanceof Error ? err.name : "UnknownError";
+        eventPublishErrors.labels(type, errorName).inc();
+      } finally {
+        callbackTimer();
+      }
+    }, 0);
+  });
+
+  endTimer();
+};
+
+function last(type, init) {
+  if (messages.has(type)) {
+    return messages.get(type);
+  } else {
+    return init;
+  }
+}
+
+export { subscribe, publish, messages, last, client };