@canmingir/link-express 1.6.11 → 1.7.1

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,55 @@
+#!/usr/bin/env node
+
+import { Server } from 'socket.io';
+import { Socket } from 'socket.io';
+import http from '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 };

package/src/express.ts

@@ -0,0 +1,66 @@
+import express, { Request, Response, NextFunction } from "express";
+import "express-async-errors";
+import cors from "cors";
+import morgan from "morgan";
+import helmet from "helmet";
+import * as error from "./error";
+import * as authorization from "./authorization";
+import settings from "./routes/settings";
+import metrics from "./routes/metrics";
+import { getConfig } from "./config";
+
+const app = express();
+
+const appConfig = getConfig();
+
+app.use(helmet());
+app.use(cors());
+app.use(morgan("tiny"));
+
+app.use(
+  express.json(),
+  (err: Error, _req: Request, res: Response, next: NextFunction) =>
+    err ? res.status(422).end() : next()
+);
+
+if (appConfig.project) {
+  import("./routes/oauth.ts").then((oauthModule) => {
+    const oauth = oauthModule.default || oauthModule;
+    app.use(
+      "/oauth",
+      express.urlencoded(),
+      (err: Error, _req: Request, res: Response, next: NextFunction) =>
+        err ? res.status(422).end() : next(),
+      oauth
+    );
+  });
+}
+
+app.use("/metrics", metrics);
+
+setImmediate(async () => {
+  process.env.PROFILE === "TEST" && app.use(authorization.verify);
+
+  if (appConfig.project) {
+    const [permissionsModule, organizationsModule, projectsModule] =
+      await Promise.all([
+        import("./routes/permissions.ts"),
+        import("./routes/organizations.ts"),
+        import("./routes/projects.ts"),
+      ]);
+
+    const permissions = permissionsModule.default || permissionsModule;
+    const organizations = organizationsModule.default || organizationsModule;
+    const projects = projectsModule.default || projectsModule;
+
+    app.use("/projects", projects);
+    app.use("/organizations", organizations);
+    app.use("/permissions", permissions);
+    app.use("/projects/:projectId/settings", settings);
+  }
+
+  app.use((_req: Request, res: Response) => res.status(404).end());
+  app.use(error.handle);
+});
+
+export default app;

package/src/lib/{settings.js → settings.ts}

@@ -1,6 +1,10 @@
-const Settings = require("../models/Settings");
+import Settings from "../models/Settings.model";
 
-async function get({ projectId }) {
+async function get({
+  projectId,
+}: {
+  projectId: string;
+}): Promise<Record<string, unknown>> {
   const settingsInstance = await Settings.findOne({
     where: { projectId },
   });
@@ -12,7 +16,15 @@ async function get({ projectId }) {
   }
 }
 
-async function upsert({ projectId }, settings) {
+async function upsert(
+  {
+    projectId,
+  }: {
+    projectId: string;
+  },
+  settings: Record<string, unknown>,
+  _params?: Record<string, unknown>
+): Promise<void> {
   const settingsInstance = await Settings.findOne({
     where: { projectId },
   });
@@ -33,4 +45,4 @@ async function upsert({ projectId }, settings) {
   }
 }
 
-module.exports = { get, upsert };
+export { get, upsert };

package/src/lib/test.ts

@@ -0,0 +1,68 @@
+import dotenv from "dotenv";
+import platform from "../platform";
+import { Sequelize } from "sequelize";
+
+dotenv.config({ path: ".env.test" });
+
+platform.init({
+  project: {
+    name: "test",
+    version: "1.0.0",
+    oauth: {
+      jwt: {
+        identifier: "email",
+      },
+      providers: {
+        github: {
+          tokenUrl: "https://github.com/login/oauth/access_token",
+          userUrl: "https://api.github.com/user",
+          clientId: "0c2844d3d19dc9293fc5",
+          redirectUri: "http://localhost:5173/callback",
+          userIdentifier: "id",
+          userFields: {
+            name: "name",
+            displayName: "login",
+            avatarUrl: "avatar_url",
+            email: "email",
+          },
+        },
+      },
+    },
+  },
+  postgres: {
+    uri: "sqlite::memory:",
+    debug: true,
+    sync: false,
+  },
+});
+
+import { init } from "../models";
+
+async function reset(): Promise<void> {
+  const { sequelize }: { sequelize: Sequelize } = await import("../postgres");
+
+  if (await init()) {
+    await sequelize.sync({ force: true });
+  }
+
+  await sequelize.models.Organization.destroy({ truncate: true });
+  await sequelize.models.Project.destroy({ truncate: true });
+  await sequelize.models.Permission.destroy({ truncate: true });
+  await sequelize.models.Settings.destroy({ truncate: true });
+
+  async function seed(): Promise<void> {
+    const { seed: organizations } = await import("../seeds/Organization.json");
+    const { seed: permissions } = await import("../seeds/Permission.json");
+    const { seed: projects } = await import("../seeds/Project.json");
+    const { seed: settings } = await import("../seeds/Settings.json");
+
+    await sequelize.models.Organization.bulkCreate(organizations);
+    await sequelize.models.Project.bulkCreate(projects);
+    await sequelize.models.Permission.bulkCreate(permissions);
+    await sequelize.models.Settings.bulkCreate(settings);
+  }
+
+  await seed();
+}
+
+export { reset };

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

@@ -1,20 +1,22 @@
-const { ecsFormat } = require("@elastic/ecs-pino-format");
-const pino = require("pino");
-const pinoElastic = require("pino-elasticsearch");
+import { ecsFormat } from "@elastic/ecs-pino-format";
+import pino from "pino";
+import pinoElastic from "pino-elasticsearch";
+import { getConfig } from "./config";
 
-const config = require("./config");
+const { logger: loggerConfig, project } = getConfig();
 
-const { logger: loggerConfig, project } = config();
+if (!loggerConfig || !project) {
+  throw new Error("Logger and project configuration are required");
+}
 
-const streams = [{ stream: process.stdout }];
+const streams: pino.StreamEntry[] = [{ stream: process.stdout }];
 
 const streamToElastic = pinoElastic({
   index: loggerConfig.elasticsearch.index,
-  consistency: loggerConfig.elasticsearch.consistency || "one",
   node: loggerConfig.elasticsearch.node,
   esVersion: loggerConfig.elasticsearch.esVersion || 8,
   flushBytes: loggerConfig.elasticsearch.flushBytes || 1000,
-});
+} as Parameters<typeof pinoElastic>[0]);
 
 streams.push({ stream: streamToElastic });
 
@@ -31,4 +33,4 @@ const logger = pino(
   pino.multistream(streams)
 );
 
-module.exports = logger;
+export default logger;

package/src/metrics/{dbMetrics.js → dbMetrics.ts}

@@ -1,6 +1,30 @@
-const promClient = require("prom-client");
+import promClient from "prom-client";
+
+interface PushgatewayConfig {
+  url: string;
+  jobName: string;
+  instance?: string;
+  interval: number;
+}
+
+interface MetricsConfig {
+  url?: string;
+  pushGateway: {
+    jobName?: string;
+    instance?: string;
+  };
+  interval?: number;
+}
 
 class DBMetrics {
+  registry: promClient.Registry;
+  pushgatewayInterval: NodeJS.Timeout | null;
+  pushgatewayConfig: PushgatewayConfig | null;
+  dbReadOps: promClient.Counter<string>;
+  dbWriteOps: promClient.Counter<string>;
+  dbReadLatency: promClient.Histogram<string>;
+  dbWriteLatency: promClient.Histogram<string>;
+
   constructor() {
     this.registry = new promClient.Registry();
     this.pushgatewayInterval = null;
@@ -33,17 +57,17 @@ class DBMetrics {
     });
   }
 
-  recordDbRead() {
+  recordDbRead(): () => number {
     this.dbReadOps.inc();
     return this.dbReadLatency.startTimer();
   }
 
-  recordDbWrite() {
+  recordDbWrite(): () => number {
     this.dbWriteOps.inc();
     return this.dbWriteLatency.startTimer();
   }
 
-  startPushgateway(metrics = {}) {
+  startPushgateway(metrics: MetricsConfig): void {
     this.pushgatewayConfig = {
       url: metrics.url || "http://localhost:9091",
       jobName: metrics.pushGateway.jobName || "api",
@@ -62,19 +86,18 @@ class DBMetrics {
     );
   }
 
-  stopPushgateway() {
+  stopPushgateway(): void {
     if (this.pushgatewayInterval) {
       clearInterval(this.pushgatewayInterval);
-      this.pushgatewayInterval = undefined;
+      this.pushgatewayInterval = null;
       console.log("Stopped pushing metrics to Pushgateway");
     }
   }
 
-  async pushMetricsToGateway() {
+  async pushMetricsToGateway(): Promise<void> {
     if (!this.pushgatewayConfig) {
-      throw new Error(
-        "Pushgateway not configured. Call startPushgateway() first."
-      );
+      console.error("[DBMetrics] Pushgateway not configured");
+      return;
     }
 
     try {
@@ -95,15 +118,15 @@ class DBMetrics {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
 
-      console.log("Metrics pushed to Pushgateway successfully");
+      console.log("[DBMetrics] Metrics pushed to Pushgateway successfully");
     } catch (err) {
-      console.error("Failed to push metrics to Pushgateway:", err);
+      console.error("[DBMetrics] Failed to push metrics to Pushgateway:", err);
     }
   }
 
-  getPushgatewayConfig() {
+  getPushgatewayConfig(): PushgatewayConfig | null {
     return this.pushgatewayConfig;
   }
 }
 
-module.exports = { DBMetrics };
+export { DBMetrics };

package/src/models/Organization.model.ts

@@ -0,0 +1,27 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+} from "sequelize-typescript";
+
+@Table({
+  tableName: "Organization",
+  timestamps: false,
+  underscored: true,
+})
+class Organization extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare name: string;
+}
+
+export default Organization;

package/src/models/Permission.model.ts

@@ -0,0 +1,48 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+  ForeignKey,
+} from "sequelize-typescript";
+import Organization from "./Organization.model";
+import Project from "./Project.model";
+
+@Table({
+  tableName: "Permission",
+  timestamps: false,
+  underscored: true,
+})
+class Permission extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.UUID)
+  declare appId: string;
+
+  @AllowNull(false)
+  @ForeignKey(() => Organization)
+  @Column(DataType.UUID)
+  declare organizationId: string;
+
+  @AllowNull(false)
+  @ForeignKey(() => Project)
+  @Column(DataType.UUID)
+  declare projectId: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare userId: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare role: string;
+}
+
+export default Permission;