@canmingir/link-express 1.6.11 → 1.7.1

package/.eslintrc.ts

@@ -0,0 +1,29 @@
+export default {
+  env: {
+    es6: true,
+    node: true,
+    mocha: true,
+  },
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    project: "./tsconfig.json",
+  },
+  plugins: ["@typescript-eslint"],
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended",
+  ],
+  ignorePatterns: ["/node_modules", "/dist"],
+  rules: {
+    eqeqeq: ["error", "always"],
+    "no-console": "off",
+    "no-eval": "error",
+    "no-var": "error",
+    "prefer-arrow-callback": "error",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+  },
+};

package/bin/event-listener.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+require('ts-node').register({
+  transpileOnly: true,
+  compilerOptions: {
+    module: 'commonjs'
+  }
+});
+
+require('../src/event/server/server.ts');

package/index.ts

@@ -0,0 +1,2 @@
+import * as platform from "./src/platform";
+export default platform;

package/package.json

@@ -1,22 +1,57 @@
 {
   "name": "@canmingir/link-express",
-  "version": "1.6.11",
+  "version": "1.7.1",
   "description": "",
-  "main": "index.js",
+  "main": "index.ts",
+  "types": "index.ts",
+  "typesVersions": {
+    "*": {
+      "models": [
+        "src/models/index.ts"
+      ],
+      "test": [
+        "src/test.ts"
+      ],
+      "authorization": [
+        "src/authorization.ts"
+      ],
+      "error": [
+        "src/error.ts"
+      ],
+      "types": [
+        "src/types/index.ts"
+      ],
+      "sequelize": [
+        "src/sequelize.ts"
+      ],
+      "event": [
+        "src/event/index.ts"
+      ]
+    }
+  },
   "author": "NucTeam",
+  "bin": {
+    "event-listener": "./bin/event-listener.ts"
+  },
   "exports": {
-    ".": "./index.js",
-    "./models": "./src/models/index.js",
-    "./test": "./src/test.js",
-    "./authorization": "./src/authorization.js",
-    "./error": "./src/error.js"
+    ".": "./index.ts",
+    "./models": "./src/models/index.ts",
+    "./test": "./src/test.ts",
+    "./authorization": "./src/authorization.ts",
+    "./error": "./src/error.ts",
+    "./types": "./src/types/index.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": "node prepare.js",
+    "prepare": "tsx prepare.ts",
+    "build": "tsc",
     "dev": "node server --dev",
     "start": "node server",
     "test": "echo 'No tests'",
-    "lint": "eslint . --ext .js"
+    "lint": "eslint . --ext .ts"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.614.0",
@@ -31,18 +66,35 @@
     "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.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",
-    "swagger-ui-express": "^5.0.1",
+    "ts-node": "^10.9.2",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.5",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/lodash": "^4.17.21",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^24.10.1",
+    "@types/pg": "^8.15.6",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.8",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.0",
+    "@typescript-eslint/parser": "^8.48.0",
     "axios-mock-adapter": "^1.21.1",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^8.5.0",
@@ -50,6 +102,8 @@
     "mocha": "10.8.2",
     "prettier": "^2.6.2",
     "sqlite3": "^5.1.6",
-    "supertest": "^7.0.0"
+    "supertest": "^7.0.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
   }
 }

package/{prepare.js → prepare.ts}

@@ -1,4 +1,4 @@
-const fs = require("fs");
+import fs from "fs";
 
 const prePush = `#!/usr/bin/env node
 const { execSync } = require("child_process");

package/src/{authorization.js → authorization.ts}

@@ -1,6 +1,22 @@
-const jwt = require("jsonwebtoken");
-const { AuthorizationError } = require("./error");
-function verify(req, res, next) {
+import jwt from "jsonwebtoken";
+import { Request, Response, NextFunction } from "express";
+import { AuthorizationError } from "./error";
+
+interface Session {
+  projectId: string;
+  userId: string;
+  roles: string[];
+  appId: string;
+  organizationId: string;
+}
+
+declare module "express-serve-static-core" {
+  interface Request {
+    session: Session;
+  }
+}
+
+function verify(req: Request, _res: Response, next: NextFunction): void {
   if (process.env.PROFILE === "TEST") {
     switch (process.env.PROJECT_ID) {
       case "0c756054-2d28-4f87-9b12-8023a79136a5":
@@ -69,8 +85,15 @@ function verify(req, res, next) {
   try {
     const { sub, aud, rls, aid, oid } = jwt.verify(
       token,
-      process.env.JWT_SECRET
-    );
+      process.env.JWT_SECRET as string
+    ) as {
+      sub: string;
+      aud: string;
+      rls: string[];
+      aid: string;
+      oid: string;
+    };
+
     req.session = {
       projectId: aud,
       userId: sub,
@@ -85,9 +108,8 @@ function verify(req, res, next) {
   next();
 }
 
-// eslint-disable-next-line no-unused-vars
-function authorize(role) {
-  return (req, res, next) => {
+function authorize(_role: string) {
+  return (req: Request, _res: Response, next: NextFunction): void => {
     const { roles } = req.session;
 
     // TODO Add expression check for role
@@ -99,4 +121,4 @@ function authorize(role) {
   };
 }
 
-module.exports = { verify, authorize };
+export { verify, authorize };

package/src/config.ts

@@ -0,0 +1,112 @@
+import _ from "lodash";
+
+interface LoggerConfig {
+  elasticsearch: {
+    index: string;
+    consistency?: string;
+    node: string;
+    esVersion?: number;
+    flushBytes?: number;
+  };
+}
+
+interface ProjectConfig {
+  name: string;
+  version: string;
+  oauth?: {
+    jwt: {
+      identifier: string;
+    };
+    providers: Record<
+      string,
+      {
+        tokenUrl: string;
+        userUrl: string;
+        clientId: string;
+        redirectUri?: string;
+        userIdentifier: string;
+        userFields: {
+          name: string;
+          displayName: string;
+          avatarUrl: string;
+          email: string;
+        };
+      }
+    >;
+  };
+}
+
+interface LinkConfig {
+  [key: string]: unknown;
+}
+
+interface OpenapiConfig {
+  [key: string]: unknown;
+}
+
+interface PostgresConfig {
+  uri: string;
+  debug?: boolean;
+  sync?: boolean;
+}
+
+interface DynamodbConfig {
+  region: string;
+}
+
+interface PushGatewayConfig {
+  url?: string;
+  jobName?: string;
+  instance?: string;
+  interval?: number;
+}
+
+interface MetricsConfig {
+  enabled: boolean;
+  url?: string;
+  pushGateway: PushGatewayConfig;
+  interval?: number;
+}
+
+interface Config {
+  link: LinkConfig;
+  project: ProjectConfig | null;
+  openapi: OpenapiConfig;
+  postgres: PostgresConfig | null;
+  dynamodb: DynamodbConfig | null;
+  pushGateway: PushGatewayConfig;
+  title?: string;
+  version?: string;
+  logger?: LoggerConfig;
+  metrics?: MetricsConfig;
+}
+
+let _config: Config = {
+  link: {},
+  project: null,
+  openapi: {},
+  postgres: null,
+  dynamodb: null,
+  pushGateway: {},
+};
+
+function init(config: Partial<Config> = {}): Config {
+  _config = _.merge(
+    {
+      link: {},
+      project: null,
+      openapi: {},
+      postgres: null,
+      dynamodb: null,
+      pushGateway: {},
+    },
+    config
+  );
+
+  return _config;
+}
+
+const getConfig = (): Config => _config;
+
+export { getConfig, init, Config };
+export default getConfig;

package/src/dynamodb.ts

@@ -0,0 +1,24 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { getConfig } from "./config";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const { dynamodb } = getConfig();
+
+if (!dynamodb) {
+  throw new Error("DynamoDB configuration is required");
+}
+
+const client = new DynamoDBClient({
+  region: dynamodb.region,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID as string,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY as string,
+  },
+});
+
+const docClient = DynamoDBDocumentClient.from(client);
+
+export { docClient };

package/src/{error.js → error.ts}

@@ -1,7 +1,31 @@
-const { ValidationError } = require("joi");
+import { ValidationError } from "joi";
+import { Request, Response, NextFunction } from "express";
 
-// eslint-disable-next-line no-unused-vars
-const handle = (err, req, res, next) => {
+interface AxiosError extends Error {
+  isAxiosError: boolean;
+  response?: {
+    status: number;
+  };
+}
+
+interface ErrorWithError {
+  error: unknown;
+}
+
+const handle = (
+  err:
+    | string
+    | ValidationError
+    | AuthorizationError
+    | AuthenticationError
+    | NotFoundError
+    | AxiosError
+    | ErrorWithError
+    | Error,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+): Response => {
   if (typeof err === "string") {
     return res.status(400).json({ error: err });
   }
@@ -22,11 +46,11 @@ const handle = (err, req, res, next) => {
     return res.status(404).end();
   }
 
-  if (err.isAxiosError) {
+  if ("isAxiosError" in err && err.isAxiosError) {
     return res.status(err.response?.status || 503).end();
   }
 
-  if (err.error) {
+  if ("error" in err && err.error) {
     return res.status(400).json(err);
   } else {
     console.error(err);
@@ -38,9 +62,4 @@ class AuthorizationError extends Error {}
 class AuthenticationError extends Error {}
 class NotFoundError extends Error {}
 
-module.exports = {
-  handle,
-  AuthorizationError,
-  NotFoundError,
-  AuthenticationError,
-};
+export { handle, AuthorizationError, NotFoundError, AuthenticationError };

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;
+  }
+}