@canmingir/link-express 1.7.5 → 1.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canmingir/link-express",
-  "version": "1.7.5",
+  "version": "1.7.7",
   "description": "",
   "main": "index.ts",
   "types": "index.ts",

package/src/event/client/eventManager.ts

@@ -4,6 +4,7 @@ import { EventMetrics, PushgatewayConfig } from "./metrics";
 import { KafkaAdapter } from "./adapters/KafkaAdapter";
 import { SocketAdapter } from "./adapters/SocketAdapter";
 import { TxEventQAdapter } from "./adapters/TxEventQAdapter";
+import { logEvent } from "../eventLogger";
 
 const TOPICS = [
   "KNOWLEDGE_CREATED",
@@ -90,6 +91,9 @@ export class EventManager {
     const type = args.slice(0, -1) as string[];
     const mergedType = type.join("_");
     this.validateEventType(mergedType);
+
+    logEvent("publish", mergedType, payload);
+
     const payloadSize = JSON.stringify(payload).length;
     const endTimer = this.metrics.recordPublish(mergedType, payloadSize);
     try {
@@ -107,6 +111,8 @@ export class EventManager {
     type: string,
     callback: Callback<T>
   ): Promise<() => void> {
+    logEvent("subscribe", type);
+
     if (!this.callbacks.has(type)) {
       this.callbacks.set(type, new Set());
     }

package/src/event/eventLogger.ts

@@ -0,0 +1,74 @@
+import { ecsFormat } from "@elastic/ecs-pino-format";
+import pino from "pino";
+import pinoElastic from "pino-elasticsearch";
+import { getConfig } from "../config";
+
+let logger: pino.Logger | null = null;
+let isElasticsearchConfigured = false;
+
+function getLogger(): pino.Logger | null {
+  const { logger: loggerConfig, project } = getConfig();
+
+  if (!loggerConfig || !project) {
+    isElasticsearchConfigured = false;
+    return null;
+  }
+
+  if (!logger || !isElasticsearchConfigured) {
+    const streams: pino.StreamEntry[] = [{ stream: process.stdout }];
+
+    const eventsIndex = `${loggerConfig.elasticsearch.index}-events`;
+
+    const streamToElastic = pinoElastic({
+      index: eventsIndex,
+      node: loggerConfig.elasticsearch.node,
+      esVersion: loggerConfig.elasticsearch.esVersion || 8,
+      flushBytes: loggerConfig.elasticsearch.flushBytes || 1000,
+    } as Parameters<typeof pinoElastic>[0]);
+
+    streamToElastic.on("error", (err: Error) => {
+      console.error("[EventLogger] Elasticsearch error:", err.message);
+    });
+
+    streamToElastic.on("insertError", (err: Error) => {
+      console.error("[EventLogger] Elasticsearch insert error:", err);
+    });
+
+    streams.push({ stream: streamToElastic });
+
+    logger = pino(
+      {
+        ...ecsFormat(),
+        base: {
+          service: {
+            name: project.name,
+            version: project.version,
+          },
+        },
+      },
+      pino.multistream(streams)
+    );
+
+    isElasticsearchConfigured = true;
+  }
+
+  return logger;
+}
+
+export function logEvent(
+  action: "publish" | "subscribe",
+  topic: string,
+  payload?: any
+) {
+  const log = getLogger();
+
+  if (log) {
+    log.info({
+      action,
+      topic,
+      event_payload: payload ? JSON.stringify(payload) : undefined,
+    });
+  } else {
+    console.log(`[Event] ${action}:`, topic, payload || "");
+  }
+}

package/src/event/src/Event.ts

@@ -1,5 +1,6 @@
 import client from "prom-client";
 import { v4 as uuid } from "uuid";
+import { logEvent } from "../eventLogger";
 
 const subscriptions = {};
 const messages = new Map();
@@ -102,7 +103,7 @@ const subscribe = (...args) => {
   const type = args.join(".");
   const id = uuid();
 
-  console.debug("node-event", "subscribe", type, id);
+  logEvent("subscribe", type);
 
   if (type === "__proto__" || type === "constructor" || type === "prototype") {
     throw new Error("Invalid subscription type");
@@ -116,7 +117,6 @@ const subscribe = (...args) => {
     type,
     callback,
     unsubscribe: () => {
-      console.debug("node-event", "unsubscribe", type, id);
       delete subscriptions[type][id];
 
       // Track unsubscription
@@ -152,7 +152,7 @@ const publish = (...args) => {
   const payload = args.pop();
   const type = args.join(".");
 
-  console.log("node-event", "publish", type, payload);
+  logEvent("publish", type, payload);
   messages.set(type, payload);
 
   if (type === "__proto__" || type === "constructor" || type === "prototype") {
@@ -178,7 +178,6 @@ const publish = (...args) => {
         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 {

package/src/routes/oauth.ts

@@ -230,6 +230,22 @@ router.get("/user", async (req: Request, res: Response): Promise<Response> => {
     return res.status(401).end();
   }
 
+  if (identityProvider.toUpperCase() === "DEMO") {
+    const avatarSeed = userId || "1001";
+    const avatarUrl = `https://api.dicebear.com/7.x/bottts/svg?seed=${avatarSeed}`;
+
+    return res.status(200).json({
+      user: {
+        id: userId || "1001",
+        identityProvider: "DEMO",
+        name: "admin",
+        displayName: "Demo Admin",
+        avatarUrl,
+        email: "admin@demo.local",
+      },
+    });
+  }
+
   const providerConfig = project.oauth?.providers[identityProvider] as {
     userUrl: string;
     userFields: {
@@ -271,4 +287,97 @@ router.get("/user", async (req: Request, res: Response): Promise<Response> => {
   });
 });
 
+router.post("/demo", async (req: Request, res: Response): Promise<Response> => {
+  const { appId, projectId, username, password } = Joi.attempt(
+    req.body,
+    Joi.object({
+      appId: Joi.string().required(),
+      projectId: Joi.string().optional(),
+      username: Joi.string().required(),
+      password: Joi.string().required(),
+    })
+      .required()
+      .options({ stripUnknown: true })
+  ) as {
+    appId: string;
+    projectId?: string;
+    username: string;
+    password: string;
+  };
+
+  if (username !== "admin" || password !== "admin") {
+    throw new AuthenticationError("Invalid demo credentials");
+  }
+
+  const userId = "1001";
+
+  let accessToken: string;
+
+  if (projectId) {
+    const permissions = await Permission.findAll({
+      where: { userId, projectId, appId },
+    });
+
+    if (!permissions.length) {
+      accessToken = jwt.sign(
+        {
+          sub: userId,
+          iss: "nuc",
+          aid: appId,
+          aud: projectId,
+          oid: "dfb990bb-81dd-4584-82ce-050eb8f6a12f",
+          rls: "OWNER",
+          identityProvider: "DEMO",
+          iat: Math.floor(Date.now() / 1000),
+        },
+        process.env.JWT_SECRET as string,
+        { expiresIn: "12h" }
+      );
+    } else {
+      accessToken = jwt.sign(
+        {
+          sub: userId,
+          iss: "nuc",
+          aud: projectId,
+          oid: permissions[0].organizationId,
+          aid: appId,
+          rls: permissions.map((p) => p.role),
+          identityProvider: "DEMO",
+          iat: Math.floor(Date.now() / 1000),
+        },
+        process.env.JWT_SECRET as string,
+        { expiresIn: "12h" }
+      );
+    }
+  } else {
+    accessToken = jwt.sign(
+      {
+        sub: userId,
+        iss: "nuc",
+        aid: appId,
+        identityProvider: "DEMO",
+        iat: Math.floor(Date.now() / 1000),
+      },
+      process.env.JWT_SECRET as string,
+      { expiresIn: "12h" }
+    );
+  }
+
+  const refreshToken = jwt.sign(
+    {
+      sub: userId,
+      type: "refresh",
+      identityProvider: "DEMO",
+      iat: Math.floor(Date.now() / 1000),
+    },
+    process.env.JWT_SECRET as string,
+    { expiresIn: "30d" }
+  );
+
+  return res.status(200).json({
+    accessToken,
+    refreshToken,
+  });
+});
+
 export default router;