@nvent-addon/app 0.5.15 → 1.0.0-alpha.10

package/dist/runtime/server/api/_triggers/ws.js

@@ -1,315 +0,0 @@
-import {
-  defineWebSocketHandler,
-  usePeerManager,
-  useNventLogger,
-  useStreamAdapter,
-  useStoreAdapter,
-  useStreamTopics,
-  useTrigger
-} from "#imports";
-const peerContexts = /* @__PURE__ */ new WeakMap();
-function safeSend(peer, data) {
-  try {
-    peer.send(JSON.stringify(data));
-    return true;
-  } catch {
-    return false;
-  }
-}
-export default defineWebSocketHandler({
-  async open(peer) {
-    const logger = useNventLogger("api-triggers-ws");
-    logger.info("[ws] client connected:", { peerId: peer.id });
-    const { registerWsPeer } = usePeerManager();
-    registerWsPeer(peer);
-    peerContexts.set(peer, {
-      subscriptions: /* @__PURE__ */ new Map()
-    });
-    safeSend(peer, {
-      type: "connected",
-      timestamp: Date.now()
-    });
-  },
-  async message(peer, message) {
-    const logger = useNventLogger("api-triggers-ws");
-    const context = peerContexts.get(peer);
-    if (!context) {
-      logger.error("[ws] no context for peer:", { peerId: peer.id });
-      return;
-    }
-    let data;
-    try {
-      data = JSON.parse(message.text());
-    } catch {
-      safeSend(peer, {
-        type: "error",
-        message: "Invalid JSON"
-      });
-      return;
-    }
-    const { type, triggerName } = data;
-    if (type === "subscribe") {
-      if (!triggerName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing triggerName"
-        });
-        return;
-      }
-      let stream;
-      let store;
-      try {
-        stream = useStreamAdapter();
-        store = useStoreAdapter();
-      } catch (err) {
-        logger.error("[ws] Adapters not initialized yet:", { error: err });
-        safeSend(peer, {
-          type: "error",
-          message: "Server initializing, please retry"
-        });
-        return;
-      }
-      const existingHandle = context.subscriptions.get(triggerName);
-      if (existingHandle) {
-        try {
-          if (typeof existingHandle === "function") {
-            await existingHandle();
-          } else {
-            await existingHandle.unsubscribe();
-          }
-        } catch (err) {
-          logger.error("[ws] error unsubscribing:", { error: err });
-        }
-      }
-      const { StoreSubjects, StreamTopics } = useStreamTopics();
-      const streamTopic = StreamTopics.triggerEvents(triggerName);
-      const storeSubject = StoreSubjects.triggerStream(triggerName);
-      const handle = await stream.subscribe(streamTopic, async (message2) => {
-        const event = message2.data?.event;
-        if (!event) {
-          logger.warn("[ws] Received message without event data:", message2);
-          return;
-        }
-        safeSend(peer, {
-          type: "event",
-          triggerName,
-          event
-        });
-      });
-      context.subscriptions.set(triggerName, handle);
-      try {
-        const historicalEvents = await store.stream.read(storeSubject, {
-          limit: 100,
-          order: "asc"
-          // Forward order to match flows
-        });
-        safeSend(peer, {
-          type: "history",
-          triggerName,
-          events: historicalEvents || []
-        });
-      } catch (err) {
-        logger.error("[ws] error sending history:", { error: err });
-        safeSend(peer, {
-          type: "error",
-          message: "Failed to load history"
-        });
-      }
-      safeSend(peer, {
-        type: "subscribed",
-        triggerName
-      });
-    } else if (type === "unsubscribe") {
-      if (!triggerName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing triggerName"
-        });
-        return;
-      }
-      const handle = context.subscriptions.get(triggerName);
-      if (handle) {
-        try {
-          if (typeof handle === "function") {
-            await handle();
-          } else {
-            await handle.unsubscribe();
-          }
-          context.subscriptions.delete(triggerName);
-          safeSend(peer, {
-            type: "unsubscribed",
-            triggerName
-          });
-        } catch (err) {
-          logger.error("[ws] error unsubscribing:", { error: err });
-          safeSend(peer, {
-            type: "error",
-            message: "Failed to unsubscribe"
-          });
-        }
-      }
-    } else if (type === "subscribe.stats") {
-      const statsKey = "stats";
-      const existingUnsub = context.subscriptions.get(statsKey);
-      if (existingUnsub) {
-        safeSend(peer, {
-          type: "error",
-          message: "Already subscribed to stats"
-        });
-        return;
-      }
-      try {
-        const stream = useStreamAdapter();
-        const { StreamTopics } = useStreamTopics();
-        const topic = StreamTopics.triggerStats();
-        const handle = await stream.subscribe(topic, (message2) => {
-          safeSend(peer, {
-            type: "trigger.stats.update",
-            data: message2,
-            timestamp: Date.now()
-          });
-        });
-        const unsub = async () => {
-          try {
-            await handle.unsubscribe();
-          } catch (err) {
-            logger.error("[ws] error in stats unsub:", { error: err });
-          }
-        };
-        context.subscriptions.set(statsKey, unsub);
-        try {
-          const trigger = useTrigger();
-          const allTriggers = trigger.getAllTriggers();
-          const { getSubscribedFlows, getTriggerStats } = trigger;
-          if (allTriggers && allTriggers.length > 0) {
-            for (const triggerEntry of allTriggers) {
-              const subscribedFlows = getSubscribedFlows(triggerEntry.name);
-              const stats = await getTriggerStats(triggerEntry.name);
-              safeSend(peer, {
-                type: "trigger.stats.initial",
-                data: {
-                  id: triggerEntry.name,
-                  metadata: {
-                    "name": triggerEntry.name,
-                    "type": triggerEntry.type,
-                    "scope": triggerEntry.scope,
-                    "displayName": triggerEntry.displayName,
-                    "description": triggerEntry.description,
-                    "source": triggerEntry.source,
-                    "status": triggerEntry.status || "active",
-                    "registeredAt": triggerEntry.registeredAt,
-                    "lastActivityAt": triggerEntry.lastActivityAt,
-                    "webhook": triggerEntry.webhook,
-                    "schedule": triggerEntry.schedule,
-                    "config": triggerEntry.config,
-                    "subscribedFlows": subscribedFlows,
-                    "subscriptionCount": subscribedFlows.length,
-                    "stats.totalFires": stats?.totalFires || 0,
-                    "stats.totalFlowsStarted": stats?.totalFlowsStarted || 0,
-                    "stats.activeSubscribers": stats?.activeSubscribers || subscribedFlows.length,
-                    "stats.lastFiredAt": stats?.lastFiredAt
-                  }
-                },
-                timestamp: Date.now()
-              });
-            }
-          }
-        } catch (err) {
-          logger.error("[ws] error fetching initial trigger stats:", { error: err });
-        }
-        safeSend(peer, {
-          type: "stats.subscribed",
-          timestamp: Date.now()
-        });
-      } catch (err) {
-        logger.error("[ws] error subscribing to stats:", { error: err });
-        safeSend(peer, {
-          type: "error",
-          message: "Failed to subscribe to stats"
-        });
-      }
-    } else if (type === "unsubscribe.stats") {
-      const statsKey = "stats";
-      const unsub = context.subscriptions.get(statsKey);
-      if (unsub) {
-        try {
-          if (typeof unsub === "function") {
-            await unsub();
-          } else {
-            await unsub.unsubscribe();
-          }
-          context.subscriptions.delete(statsKey);
-          safeSend(peer, {
-            type: "stats.unsubscribed",
-            timestamp: Date.now()
-          });
-        } catch (err) {
-          logger.error("[ws] error unsubscribing from stats:", { error: err });
-          safeSend(peer, {
-            type: "error",
-            message: "Failed to unsubscribe from stats"
-          });
-        }
-      }
-    } else if (type === "ping") {
-      safeSend(peer, {
-        type: "pong",
-        timestamp: Date.now()
-      });
-    } else {
-      safeSend(peer, {
-        type: "error",
-        message: `Unknown message type: ${type}`
-      });
-    }
-  },
-  async close(peer, event) {
-    const logger = useNventLogger("api-triggers-ws");
-    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
-    if (!isNormalClosure) {
-      logger.info("[ws] client disconnected:", { peerId: peer.id, code: event?.code, reason: event?.reason });
-    }
-    const { unregisterWsPeer } = usePeerManager();
-    unregisterWsPeer(peer);
-    const context = peerContexts.get(peer);
-    if (context) {
-      for (const handleOrUnsub of Array.from(context.subscriptions.values())) {
-        try {
-          if (typeof handleOrUnsub === "function") {
-            await handleOrUnsub();
-          } else {
-            await handleOrUnsub.unsubscribe();
-          }
-        } catch (err) {
-          if (!isNormalClosure) {
-            logger.error("[ws] error unsubscribing on close:", { error: err });
-          }
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  },
-  async error(peer, error) {
-    const logger = useNventLogger("api-triggers-ws");
-    logger.error("[ws] error for peer:", { peerId: peer.id, error });
-    const { unregisterWsPeer } = usePeerManager();
-    unregisterWsPeer(peer);
-    const context = peerContexts.get(peer);
-    if (context) {
-      for (const handleOrUnsub of Array.from(context.subscriptions.values())) {
-        try {
-          if (typeof handleOrUnsub === "function") {
-            await handleOrUnsub();
-          } else {
-            await handleOrUnsub.unsubscribe();
-          }
-        } catch (err) {
-          logger.error("[ws] error unsubscribing on error:", { error: err });
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  }
-});