nvent 0.4.5 → 0.5.1

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

@@ -1,215 +0,0 @@
-import {
-  defineWebSocketHandler,
-  useQueueAdapter,
-  usePeerManager,
-  useNventLogger
-} 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({
-  open(peer) {
-    const logger = useNventLogger("api-queues-ws");
-    logger.info("[ws:queues] client connected:", 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-queues-ws");
-    const context = peerContexts.get(peer);
-    if (!context) {
-      logger.error("[ws:queues] no context for peer:", peer.id);
-      return;
-    }
-    let data;
-    try {
-      data = JSON.parse(message.text());
-    } catch {
-      safeSend(peer, {
-        type: "error",
-        message: "Invalid JSON"
-      });
-      return;
-    }
-    const { type, queueName } = data;
-    if (type === "subscribe") {
-      if (!queueName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing queueName"
-        });
-        return;
-      }
-      let queue;
-      try {
-        queue = useQueueAdapter();
-      } catch (err) {
-        logger.error("[ws:queues] Adapters not initialized yet:", err);
-        safeSend(peer, {
-          type: "error",
-          message: "Server initializing, please retry"
-        });
-        return;
-      }
-      const existingUnsub = context.subscriptions.get(queueName);
-      if (existingUnsub) {
-        try {
-          existingUnsub();
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing:", err);
-        }
-      }
-      const events = [
-        "waiting",
-        "active",
-        "completed",
-        "failed",
-        "progress"
-      ];
-      const unsubs = events.map(
-        (eventType) => queue.on(queueName, eventType, async (payload) => {
-          safeSend(peer, {
-            type: "event",
-            queueName,
-            event: {
-              eventType,
-              ...payload
-            }
-          });
-          if (["waiting", "active", "completed", "failed"].includes(eventType)) {
-            try {
-              const counts = await queue.getJobCounts(queueName);
-              safeSend(peer, {
-                type: "counts",
-                queueName,
-                counts
-              });
-            } catch (err) {
-              logger.error("[ws:queues] error fetching counts after event:", err);
-            }
-          }
-        })
-      );
-      const unsub = () => {
-        for (const u of unsubs) {
-          try {
-            u();
-          } catch (err) {
-            logger.error("[ws:queues] error unsubscribing:", err);
-          }
-        }
-      };
-      context.subscriptions.set(queueName, unsub);
-      try {
-        const counts = await queue.getJobCounts(queueName);
-        safeSend(peer, {
-          type: "counts",
-          queueName,
-          counts
-        });
-      } catch (err) {
-        logger.error("[ws:queues] error fetching counts:", err);
-      }
-      safeSend(peer, {
-        type: "subscribed",
-        queueName
-      });
-    } else if (type === "unsubscribe") {
-      if (!queueName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing queueName"
-        });
-        return;
-      }
-      const unsub = context.subscriptions.get(queueName);
-      if (unsub) {
-        try {
-          unsub();
-          context.subscriptions.delete(queueName);
-          safeSend(peer, {
-            type: "unsubscribed",
-            queueName
-          });
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing:", err);
-          safeSend(peer, {
-            type: "error",
-            message: "Failed to unsubscribe"
-          });
-        }
-      }
-    } else if (type === "ping") {
-      safeSend(peer, {
-        type: "pong",
-        timestamp: Date.now()
-      });
-    } else {
-      safeSend(peer, {
-        type: "error",
-        message: `Unknown message type: ${type}`
-      });
-    }
-  },
-  close(peer, event) {
-    const logger = useNventLogger("api-queues-ws");
-    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
-    if (!isNormalClosure) {
-      logger.info("[ws:queues] 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 unsub of Array.from(context.subscriptions.values())) {
-        try {
-          unsub();
-        } catch (err) {
-          if (!isNormalClosure) {
-            logger.error("[ws:queues] error unsubscribing on close:", err);
-          }
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  },
-  error(peer, error) {
-    const logger = useNventLogger("api-queues-ws");
-    logger.error("[ws:queues] error for peer:", {
-      peerId: peer.id,
-      error
-    });
-    const { unregisterWsPeer } = usePeerManager();
-    unregisterWsPeer(peer);
-    const context = peerContexts.get(peer);
-    if (context) {
-      for (const unsub of Array.from(context.subscriptions.values())) {
-        try {
-          unsub();
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing on error:", { error: err });
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  }
-});

package/dist/runtime/utils/useFlowEngine.d.ts

@@ -1,19 +0,0 @@
-/**
- * Flow Engine for starting and emitting flow events
- */
-export declare const useFlowEngine: () => {
-    startFlow: (flowName: string, payload?: any) => Promise<{
-        id: any;
-        queue: any;
-        step: any;
-        flowId: `${string}-${string}-${string}-${string}-${string}`;
-    }>;
-    emit: (trigger: string, payload?: any) => Promise<never[]>;
-    cancelFlow: (flowName: string, runId: string) => Promise<{
-        success: boolean;
-        runId: string;
-        flowName: string;
-    }>;
-    isRunning: (flowName: string, runId?: string) => Promise<any>;
-    getRunningFlows: (flowName: string) => Promise<any>;
-};

package/dist/runtime/utils/useFlowEngine.js

@@ -1,108 +0,0 @@
-import { $useQueueRegistry, useQueueAdapter, useEventManager, useNventLogger, useStoreAdapter, useStreamTopics } from "#imports";
-import { randomUUID } from "node:crypto";
-const logger = useNventLogger("flow-engine");
-export const useFlowEngine = () => {
-  const registry = $useQueueRegistry();
-  const queueAdapter = useQueueAdapter();
-  const eventsManager = useEventManager();
-  const startFlow = async (flowName, payload = {}) => {
-    const flow = registry?.flows?.[flowName];
-    if (!flow || !flow.entry) throw new Error("Flow not found");
-    const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
-    const entryWorker = registry?.workers?.find(
-      (w) => w?.flow?.step === flow.entry.step && w?.queue?.name === queueName
-    );
-    const opts = entryWorker?.queue?.defaultJobOptions || {};
-    const flowId = randomUUID();
-    const id = await queueAdapter.enqueue(queueName, { name: flow.entry.step, data: { ...payload, flowId, flowName }, opts });
-    try {
-      await eventsManager.publishBus({ type: "flow.start", runId: flowId, flowName, data: { input: payload } });
-    } catch {
-    }
-    return { id, queue: queueName, step: flow.entry.step, flowId };
-  };
-  const emit = async (trigger, payload = {}) => {
-    const flowId = payload?.flowId;
-    const flowName = payload?.flowName || "unknown";
-    if (!flowId) {
-      logger.warn("emit called without flowId, trigger may not work", { trigger });
-    }
-    const { flowId: _, flowName: __, ...actualPayload } = payload;
-    try {
-      await eventsManager.publishBus({
-        type: "emit",
-        runId: flowId || "unknown",
-        flowName,
-        data: {
-          name: trigger,
-          payload: actualPayload
-          // Store actual payload separately
-        }
-      });
-    } catch (err) {
-      logger.error("Failed to emit trigger event", { trigger, error: err });
-    }
-    return [];
-  };
-  const cancelFlow = async (flowName, runId) => {
-    try {
-      await eventsManager.publishBus({
-        type: "flow.cancel",
-        runId,
-        flowName,
-        data: {
-          canceledAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      });
-      logger.info("Flow canceled", { flowName, runId });
-      return { success: true, runId, flowName };
-    } catch (err) {
-      logger.error("Failed to cancel flow", { flowName, runId, error: err });
-      throw err;
-    }
-  };
-  const isRunning = async (flowName, runId) => {
-    try {
-      const store = useStoreAdapter();
-      const { SubjectPatterns } = useStreamTopics();
-      if (!store.indexRead) {
-        return false;
-      }
-      if (runId) {
-        const runIndexKey2 = SubjectPatterns.flowRunIndex(flowName);
-        const entries2 = await store.indexRead(runIndexKey2, { limit: 1e3 });
-        const run = entries2.find((e) => e.id === runId);
-        return run?.metadata?.status === "running";
-      }
-      const runIndexKey = SubjectPatterns.flowRunIndex(flowName);
-      const entries = await store.indexRead(runIndexKey, { limit: 1e3 });
-      return entries.some((e) => e.metadata?.status === "running");
-    } catch (err) {
-      logger.error("[isRunning] Error checking flow status:", err);
-      return false;
-    }
-  };
-  const getRunningFlows = async (flowName) => {
-    try {
-      const store = useStoreAdapter();
-      const { SubjectPatterns } = useStreamTopics();
-      if (!store.indexRead) {
-        return [];
-      }
-      const runIndexKey = SubjectPatterns.flowRunIndex(flowName);
-      const entries = await store.indexRead(runIndexKey, { limit: 1e3 });
-      return entries.filter((e) => e.metadata?.status === "running").map((e) => ({
-        id: e.id,
-        flowName,
-        status: e.metadata?.status,
-        startedAt: e.metadata?.startedAt,
-        stepCount: e.metadata?.stepCount || 0,
-        completedSteps: e.metadata?.completedSteps || 0
-      }));
-    } catch (err) {
-      logger.error("[getRunningFlows] Error getting running flows:", err);
-      return [];
-    }
-  };
-  return { startFlow, emit, cancelFlow, isRunning, getRunningFlows };
-};

package/dist/runtime/utils/useStreamTopics.d.ts

@@ -1,72 +0,0 @@
-/**
- * Stream topic naming utilities
- *
- * Standardized topic patterns for StreamAdapter pub/sub
- * These match the topics published by StoreAdapter mutations and wiring coordinators
- */
-/**
- * Get topic for store append events
- * Pattern: store:append:{subject}
- * Published when: StoreAdapter.append() adds an event to a subject
- * Used by: StreamCoordinator (store-sync channel)
- */
-declare function getStoreAppendTopic(subject: string): string;
-/**
- * Get topic for store save events
- * Pattern: store:save:{collection}
- * Published when: StoreAdapter.save() creates/updates a document
- */
-declare function getStoreSaveTopic(collection: string): string;
-/**
- * Get topic for store delete events
- * Pattern: store:delete:{collection}
- * Published when: StoreAdapter.delete() removes a document
- */
-declare function getStoreDeleteTopic(collection: string): string;
-/**
- * Get topic for KV store events
- * Pattern: store:kv:{key}
- * Published when: StoreAdapter.kvSet() updates a key
- */
-declare function getStoreKvTopic(key: string): string;
-/**
- * Get topic for flow orchestration events
- * Pattern: flow:event:{runId}
- * Published when: StreamCoordinator flow-events channel publishes flow lifecycle events
- * Used by: Future trigger system for cross-instance coordination
- */
-declare function getFlowEventTopic(runId: string): string;
-/**
- * Get topic for client messages (WebSocket/SSE)
- * Pattern: client:flow:{runId}
- * Published when: StreamCoordinator client-messages channel publishes UI updates
- * Used by: WebSocket handler for real-time UI updates
- */
-declare function getClientFlowTopic(runId: string): string;
-export declare function useStreamTopics(): {
-    getStoreAppendTopic: typeof getStoreAppendTopic;
-    getStoreSaveTopic: typeof getStoreSaveTopic;
-    getStoreDeleteTopic: typeof getStoreDeleteTopic;
-    getStoreKvTopic: typeof getStoreKvTopic;
-    getFlowEventTopic: typeof getFlowEventTopic;
-    getClientFlowTopic: typeof getClientFlowTopic;
-    SubjectPatterns: {
-        /**
-         * Flow run event stream subject
-         */
-        readonly flowRun: (runId: string) => string;
-        /**
-         * Flow run index (sorted set of runs by flow name)
-         */
-        readonly flowRunIndex: (flowName: string) => string;
-        /**
-         * Flow definition subject
-         */
-        readonly flowDefinition: (flowName: string) => string;
-        /**
-         * Worker heartbeat subject
-         */
-        readonly workerHeartbeat: (workerId: string) => string;
-    };
-};
-export {};

package/dist/runtime/utils/useStreamTopics.js

@@ -1,47 +0,0 @@
-function getStoreAppendTopic(subject) {
-  return `store:append:${subject}`;
-}
-function getStoreSaveTopic(collection) {
-  return `store:save:${collection}`;
-}
-function getStoreDeleteTopic(collection) {
-  return `store:delete:${collection}`;
-}
-function getStoreKvTopic(key) {
-  return `store:kv:${key}`;
-}
-function getFlowEventTopic(runId) {
-  return `flow:event:${runId}`;
-}
-function getClientFlowTopic(runId) {
-  return `client:flow:${runId}`;
-}
-const SubjectPatterns = {
-  /**
-   * Flow run event stream subject
-   */
-  flowRun: (runId) => `nq:flow:${runId}`,
-  /**
-   * Flow run index (sorted set of runs by flow name)
-   */
-  flowRunIndex: (flowName) => `nq:flows:${flowName}`,
-  /**
-   * Flow definition subject
-   */
-  flowDefinition: (flowName) => `flow-def:${flowName}`,
-  /**
-   * Worker heartbeat subject
-   */
-  workerHeartbeat: (workerId) => `worker:${workerId}`
-};
-export function useStreamTopics() {
-  return {
-    getStoreAppendTopic,
-    getStoreSaveTopic,
-    getStoreDeleteTopic,
-    getStoreKvTopic,
-    getFlowEventTopic,
-    getClientFlowTopic,
-    SubjectPatterns
-  };
-}