@burdenoff/be-sdk 2026.510.79

package/dist/chunk-ELLX3K54.js

@@ -0,0 +1,613 @@
+import { EventQueueFactory } from './chunk-3O2RQOPV.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __name } from './chunk-XE4OXN2W.js';
+import { randomUUID } from 'crypto';
+
+var MemoryEventBus = class {
+  static {
+    __name(this, "MemoryEventBus");
+  }
+  handlers = /* @__PURE__ */ new Map();
+  /**
+  * Emit an event to all handlers
+  */
+  emit(event, data) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.forEach((handler) => {
+        void Promise.resolve(handler(data));
+      });
+    }
+    for (const [pattern, handlers] of this.handlers) {
+      if (this.matchesPattern(event, pattern)) {
+        handlers.forEach((handler) => {
+          void Promise.resolve(handler(data));
+        });
+      }
+    }
+  }
+  /**
+  * Register a handler for an event
+  */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+  }
+  /**
+  * Remove a handler for an event
+  */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+    }
+  }
+  /**
+  * Check if pattern matches event (supports wildcards)
+  */
+  matchesPattern(event, pattern) {
+    if (pattern === event) return false;
+    if (pattern.endsWith(".*")) {
+      const prefix = pattern.slice(0, -2);
+      return event.startsWith(prefix + ".");
+    }
+    if (pattern.endsWith(".>")) {
+      const prefix = pattern.slice(0, -2);
+      return event.startsWith(prefix + ".");
+    }
+    return false;
+  }
+  /**
+  * Clear all handlers
+  */
+  clear() {
+    this.handlers.clear();
+  }
+};
+var MemoryEventQueue = class {
+  static {
+    __name(this, "MemoryEventQueue");
+  }
+  queue = [];
+  processing = false;
+  handlers = /* @__PURE__ */ new Map();
+  maxRetries;
+  retryDelay;
+  constructor(options) {
+    this.maxRetries = options?.maxRetries ?? 3;
+    this.retryDelay = options?.retryDelay ?? 1e3;
+  }
+  /**
+  * Publish entity event (implements GraphEventEmitter)
+  */
+  async publishEntityEvent(eventType, entity, context) {
+    const subject = `graph.${context.productName}.${entity.type}.${eventType.split(".")[1]}`;
+    logger.debug("[MemoryEventQueue] Publishing entity event", {
+      eventType,
+      entityId: entity.id,
+      entityType: entity.type,
+      subject
+    });
+    this.enqueue(subject, {
+      eventType,
+      entity,
+      context
+    });
+  }
+  /**
+  * Add an event to the queue
+  */
+  enqueue(subject, data, metadata = {}) {
+    const id = `evt_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const event = {
+      id,
+      subject,
+      data,
+      metadata,
+      timestamp: /* @__PURE__ */ new Date(),
+      retries: 0,
+      maxRetries: this.maxRetries
+    };
+    this.queue.push(event);
+    void this.processQueue();
+    return id;
+  }
+  /**
+  * Register a handler for a subject
+  */
+  registerHandler(subject, handler) {
+    this.handlers.set(subject, handler);
+  }
+  /**
+  * Process the queue
+  */
+  async processQueue() {
+    if (this.processing || this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const event = this.queue.shift();
+      if (!event) continue;
+      const handler = this.handlers.get(event.subject);
+      if (handler) {
+        try {
+          const ackEvent = {
+            id: event.id,
+            subject: event.subject,
+            data: event.data,
+            metadata: {
+              correlationId: event.id,
+              ...event.metadata
+            },
+            timestamp: event.timestamp.toISOString(),
+            ack: /* @__PURE__ */ __name(async () => {
+              logger.debug("[MemoryEventQueue] Event acknowledged", {
+                id: event.id
+              });
+            }, "ack"),
+            nak: /* @__PURE__ */ __name(async () => {
+              logger.debug("[MemoryEventQueue] Event negatively acknowledged", {
+                id: event.id
+              });
+              if (event.retries < event.maxRetries) {
+                event.retries++;
+                this.queue.push(event);
+              }
+            }, "nak"),
+            term: /* @__PURE__ */ __name(async () => {
+              logger.debug("[MemoryEventQueue] Event terminated", {
+                id: event.id
+              });
+            }, "term"),
+            isRedelivered: /* @__PURE__ */ __name(() => event.retries > 0, "isRedelivered"),
+            getDeliveryAttempt: /* @__PURE__ */ __name(() => event.retries + 1, "getDeliveryAttempt")
+          };
+          await handler(ackEvent);
+        } catch {
+          if (event.retries < event.maxRetries) {
+            event.retries++;
+            await new Promise((resolve) => setTimeout(resolve, this.retryDelay));
+            this.queue.push(event);
+          }
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+  * Get queue length
+  */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+  * Clear the queue
+  */
+  clear() {
+    this.queue = [];
+  }
+  /**
+  * Publish an event (fire-and-forget)
+  */
+  async publish(subject, data, metadata = {}) {
+    this.enqueue(subject, data, metadata);
+    logger.debug("[MemoryEventQueue] Published event", {
+      subject
+    });
+  }
+  /**
+  * Close the event queue
+  */
+  async close() {
+    this.clear();
+    this.handlers.clear();
+    logger.debug("[MemoryEventQueue] Event queue closed");
+  }
+};
+var MemoryEventPublisher = class {
+  static {
+    __name(this, "MemoryEventPublisher");
+  }
+  queue;
+  _connected = false;
+  publishCount = 0;
+  constructor() {
+    this.queue = new MemoryEventQueue();
+  }
+  async connect() {
+    this._connected = true;
+    logger.info("[MemoryEventPublisher] Connected (in-memory mode)");
+  }
+  async disconnect() {
+    await this.queue.close();
+    this._connected = false;
+    logger.info("[MemoryEventPublisher] Disconnected");
+  }
+  isConnected() {
+    return this._connected;
+  }
+  async ensureStream() {
+    logger.debug("[MemoryEventPublisher] ensureStream called (no-op for in-memory)");
+  }
+  async publish(options) {
+    if (!this._connected) {
+      throw new Error("Publisher not connected");
+    }
+    const messageId = this.queue.enqueue(options.subject, options.data, options.metadata);
+    this.publishCount++;
+    logger.debug("[MemoryEventPublisher] Published", {
+      subject: options.subject,
+      messageId
+    });
+    return messageId;
+  }
+  async publishBatch(events) {
+    const messageIds = [];
+    for (const event of events) {
+      const id = await this.publish(event);
+      messageIds.push(id);
+    }
+    return messageIds;
+  }
+  async publishWithAck(options) {
+    await this.publish({
+      subject: options.subject,
+      data: options.data,
+      metadata: options.metadata
+    });
+    return {};
+  }
+  async healthCheck() {
+    return {
+      status: this._connected ? "healthy" : "unhealthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      connected: this._connected,
+      latencyMs: 0
+    };
+  }
+  async getStatistics() {
+    return {
+      messagesPublished: this.publishCount,
+      messagesConsumed: 0,
+      messagesPending: this.queue.length,
+      messagesFailed: 0
+    };
+  }
+  /**
+  * Get the underlying queue (for testing/debugging)
+  */
+  getQueue() {
+    return this.queue;
+  }
+};
+var MemoryEventConsumer = class {
+  static {
+    __name(this, "MemoryEventConsumer");
+  }
+  streamName;
+  consumerName;
+  queue;
+  bus;
+  _connected = false;
+  _subscriptions = /* @__PURE__ */ new Map();
+  consumeCount = 0;
+  subIdCounter = 0;
+  constructor(streamName, consumerName) {
+    this.streamName = streamName;
+    this.consumerName = consumerName;
+    this.queue = new MemoryEventQueue();
+    this.bus = new MemoryEventBus();
+  }
+  async connect() {
+    this._connected = true;
+    logger.info("[MemoryEventConsumer] Connected (in-memory mode)", {
+      stream: this.streamName,
+      consumer: this.consumerName
+    });
+  }
+  async disconnect() {
+    for (const sub of this._subscriptions.values()) {
+      await sub.unsubscribe();
+    }
+    this._subscriptions.clear();
+    await this.queue.close();
+    this.bus.clear();
+    this._connected = false;
+    logger.info("[MemoryEventConsumer] Disconnected");
+  }
+  isConnected() {
+    return this._connected;
+  }
+  async ensureStream() {
+    logger.debug("[MemoryEventConsumer] ensureStream called (no-op for in-memory)");
+  }
+  async ensureConsumer() {
+    logger.debug("[MemoryEventConsumer] ensureConsumer called (no-op for in-memory)");
+  }
+  async subscribe(options) {
+    if (!this._connected) {
+      throw new Error("Consumer not connected");
+    }
+    const { subject, handler } = options;
+    const subId = `sub_${++this.subIdCounter}`;
+    let messagesReceived = 0;
+    let messagesProcessed = 0;
+    let messagesFailed = 0;
+    let lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    let active = true;
+    this.queue.registerHandler(subject, async (event) => {
+      messagesReceived++;
+      lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        this.consumeCount++;
+        await handler(event);
+        messagesProcessed++;
+      } catch {
+        messagesFailed++;
+      }
+    });
+    this.bus.on(subject, async (data) => {
+      messagesReceived++;
+      lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        this.consumeCount++;
+        await handler(data);
+        messagesProcessed++;
+      } catch {
+        messagesFailed++;
+      }
+    });
+    const subscription = {
+      id: subId,
+      subject,
+      unsubscribe: /* @__PURE__ */ __name(async () => {
+        active = false;
+        this._subscriptions.delete(subId);
+        logger.debug("[MemoryEventConsumer] Unsubscribed", {
+          subject
+        });
+      }, "unsubscribe"),
+      isActive: /* @__PURE__ */ __name(() => active, "isActive"),
+      getStats: /* @__PURE__ */ __name(() => ({
+        messagesReceived,
+        messagesProcessed,
+        messagesFailed,
+        lastActivity
+      }), "getStats")
+    };
+    this._subscriptions.set(subId, subscription);
+    logger.info("[MemoryEventConsumer] Subscribed", {
+      subject,
+      subscriptionId: subId
+    });
+    return subscription;
+  }
+  async subscribeMultiple(subjects, handler) {
+    const subscriptions = [];
+    for (const subject of subjects) {
+      const sub = await this.subscribe({
+        subject,
+        handler
+      });
+      subscriptions.push(sub);
+    }
+    return subscriptions;
+  }
+  async pull() {
+    logger.debug("[MemoryEventConsumer] pull called (returning empty for in-memory)");
+    return [];
+  }
+  async unsubscribeAll() {
+    for (const sub of this._subscriptions.values()) {
+      await sub.unsubscribe();
+    }
+    this._subscriptions.clear();
+  }
+  getSubscriptions() {
+    return Array.from(this._subscriptions.values());
+  }
+  async processDLQ(_handler) {
+    logger.debug("[MemoryEventConsumer] processDLQ called (no-op for in-memory)");
+  }
+  // eslint-disable-next-line sonarjs/no-identical-functions -- Same implementation needed for both Publisher and Consumer
+  async healthCheck() {
+    return {
+      status: this._connected ? "healthy" : "unhealthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      connected: this._connected,
+      latencyMs: 0
+    };
+  }
+  async getStatistics() {
+    return {
+      messagesPublished: 0,
+      messagesConsumed: this.consumeCount,
+      messagesPending: this.queue.length,
+      messagesFailed: 0
+    };
+  }
+  /**
+  * Get the underlying bus (for testing/debugging)
+  */
+  getBus() {
+    return this.bus;
+  }
+  /**
+  * Get the underlying queue (for testing/debugging)
+  */
+  getQueue() {
+    return this.queue;
+  }
+};
+function createMemoryPublisher() {
+  return new MemoryEventPublisher();
+}
+__name(createMemoryPublisher, "createMemoryPublisher");
+function createMemoryConsumer(stream, consumer) {
+  return new MemoryEventConsumer(stream, consumer);
+}
+__name(createMemoryConsumer, "createMemoryConsumer");
+function createGraphEventEmitter() {
+  return new MemoryEventQueue();
+}
+__name(createGraphEventEmitter, "createGraphEventEmitter");
+
+// src/event-queue/graph-emitter.ts
+var uuidv4 = /* @__PURE__ */ __name(() => crypto.randomUUID(), "uuidv4");
+var NatsGraphEventEmitter = class {
+  static {
+    __name(this, "NatsGraphEventEmitter");
+  }
+  publisher;
+  connected = false;
+  connecting = null;
+  constructor() {
+    const graphNatsUrl = process.env["GRAPH_NATS_URL"];
+    const natsServers = graphNatsUrl || process.env["NATS_SERVERS"] || process.env["NATS_URL"];
+    if (natsServers) {
+      const originalNatsServers = process.env["NATS_SERVERS"];
+      if (graphNatsUrl) {
+        process.env["NATS_SERVERS"] = graphNatsUrl;
+        logger.info("[NatsGraphEventEmitter] Using GRAPH_NATS_URL for graph events", {
+          url: graphNatsUrl
+        });
+      } else if (!process.env["NATS_SERVERS"] && process.env["NATS_URL"]) {
+        process.env["NATS_SERVERS"] = process.env["NATS_URL"];
+      }
+      this.publisher = EventQueueFactory.createPublisherFromEnv();
+      if (graphNatsUrl && originalNatsServers !== void 0) {
+        process.env["NATS_SERVERS"] = originalNatsServers;
+      } else if (graphNatsUrl) {
+        delete process.env["NATS_SERVERS"];
+      }
+      logger.info("[NatsGraphEventEmitter] Using NATS publisher");
+    } else {
+      this.publisher = new MemoryEventPublisher();
+      logger.info("[NatsGraphEventEmitter] Using in-memory publisher (NATS not configured)");
+    }
+  }
+  /**
+  * Ensure publisher is connected
+  */
+  async ensureConnected() {
+    if (this.connected) {
+      return;
+    }
+    if (this.connecting) {
+      await this.connecting;
+      return;
+    }
+    this.connecting = this.publisher.connect().then(() => {
+      this.connected = true;
+      this.connecting = null;
+      logger.info("[NatsGraphEventEmitter] Publisher connected");
+    });
+    await this.connecting;
+  }
+  /**
+  * Publish entity event to graph queue
+  *
+  * @param eventType - The lifecycle event type
+  * @param entity - Entity data (id, type, data)
+  * @param context - Event context (product, org, user, workspace)
+  * @param rbac - Optional RBAC metadata. When present, the RBAC consumer will
+  *               create/update/delete resources. When absent, only graph consumer processes.
+  */
+  async publishEntityEvent(eventType, entity, context, rbac) {
+    await this.ensureConnected();
+    const eventId = uuidv4();
+    const action = eventType.split(".")[1];
+    const subject = `graph.${context.productName}.${entity.type}.${action}`;
+    logger.debug("[NatsGraphEventEmitter] Publishing entity event", {
+      eventId,
+      eventType,
+      entityId: entity.id,
+      entityType: entity.type,
+      subject,
+      hasRbac: !!rbac
+    });
+    const streamName = "WSPACE_GRAPH_EVENTS";
+    const streamSubjects = [
+      "graph.>"
+    ];
+    await this.publisher.publish({
+      subject,
+      data: {
+        eventId,
+        eventType,
+        productSource: context.productName,
+        organizationId: context.organizationId,
+        entity,
+        context: {
+          actorId: context.actorId,
+          workspaceId: context.workspaceId
+        },
+        // Include RBAC metadata when configured (consumed by rbac-entity-consumer)
+        ...rbac && {
+          rbac
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        eventId,
+        productName: context.productName,
+        organizationId: context.organizationId,
+        actorId: context.actorId,
+        workspaceId: context.workspaceId,
+        entityType: entity.type,
+        entityId: entity.id
+      },
+      options: {
+        stream: streamName,
+        streamSubjects
+      }
+    });
+  }
+  /**
+  * Disconnect the publisher
+  */
+  async disconnect() {
+    if (this.connected) {
+      await this.publisher.disconnect();
+      this.connected = false;
+      logger.info("[NatsGraphEventEmitter] Publisher disconnected");
+    }
+  }
+  /**
+  * Get health check status
+  */
+  async healthCheck() {
+    const result = await this.publisher.healthCheck();
+    const isHealthy = result.status === "healthy";
+    return {
+      healthy: isHealthy,
+      message: result.error || (isHealthy ? "Healthy" : "Unhealthy")
+    };
+  }
+};
+var _graphEventEmitter = null;
+function getGraphEventEmitter() {
+  if (!_graphEventEmitter) {
+    _graphEventEmitter = new NatsGraphEventEmitter();
+  }
+  return _graphEventEmitter;
+}
+__name(getGraphEventEmitter, "getGraphEventEmitter");
+function createGraphEventEmitter2() {
+  return new NatsGraphEventEmitter();
+}
+__name(createGraphEventEmitter2, "createGraphEventEmitter");
+async function resetGraphEventEmitter() {
+  if (_graphEventEmitter) {
+    await _graphEventEmitter.disconnect();
+    _graphEventEmitter = null;
+  }
+}
+__name(resetGraphEventEmitter, "resetGraphEventEmitter");
+
+export { MemoryEventBus, MemoryEventConsumer, MemoryEventPublisher, MemoryEventQueue, NatsGraphEventEmitter, createGraphEventEmitter, createGraphEventEmitter2, createMemoryConsumer, createMemoryPublisher, getGraphEventEmitter, resetGraphEventEmitter };
+//# sourceMappingURL=chunk-ELLX3K54.js.map
+//# sourceMappingURL=chunk-ELLX3K54.js.map