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

package/dist/runtime/server/api/_flows/[name]/runs/[runId]/cancel.post.js

@@ -1,21 +0,0 @@
-import { defineEventHandler, getRouterParam, createError, useFlow } from "#imports";
-export default defineEventHandler(async (event) => {
-  const flowName = getRouterParam(event, "name");
-  const runId = getRouterParam(event, "runId");
-  if (!flowName || !runId) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Flow name and run ID are required"
-    });
-  }
-  const flowEngine = useFlow();
-  try {
-    const result = await flowEngine.cancelFlow(flowName, runId);
-    return result;
-  } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `Failed to cancel flow: ${error.message}`
-    });
-  }
-});

package/dist/runtime/server/api/_flows/[name]/runs/[runId]/restart.post.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_flows/[name]/runs/[runId]/restart.post.js

@@ -1,21 +0,0 @@
-import { defineEventHandler, getRouterParam, createError, useFlow } from "#imports";
-export default defineEventHandler(async (event) => {
-  const flowName = getRouterParam(event, "name");
-  const runId = getRouterParam(event, "runId");
-  if (!flowName || !runId) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Flow name and run ID are required"
-    });
-  }
-  const flowEngine = useFlow();
-  try {
-    const result = await flowEngine.restartFlow(flowName, runId);
-    return result;
-  } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `Failed to restart flow: ${error.message}`
-    });
-  }
-});

package/dist/runtime/server/api/_flows/[name]/runs.get.d.ts

@@ -1,17 +0,0 @@
-/**
- * GET /api/_flows/:flowName/runs
- *
- * Returns a list of flow runs with their metadata from the sorted set index.
- * Supports pagination via offset/limit query params.
- *
- * Query params:
- * - limit: number (default: 50)
- * - offset: number (default: 0)
- *
- * Returns:
- * {
- *   runs: Array<{ id, score, metadata }>
- * }
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_flows/[name]/runs.get.js

@@ -1,64 +0,0 @@
-import { defineEventHandler, getRouterParam, getQuery, useStoreAdapter, useNventLogger, useStreamTopics } from "#imports";
-export default defineEventHandler(async (event) => {
-  const logger = useNventLogger("api-flows-runs");
-  const flowName = getRouterParam(event, "name");
-  const query = getQuery(event);
-  const limit = Math.min(Number.parseInt(query.limit) || 50, 100);
-  const offset = Math.max(Number.parseInt(query.offset) || 0, 0);
-  const status = query.status;
-  event.node.res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
-  event.node.res.setHeader("Pragma", "no-cache");
-  if (!flowName) {
-    return { error: "Missing flow name" };
-  }
-  let store;
-  let StoreSubjects;
-  try {
-    store = useStoreAdapter();
-    const topics = useStreamTopics();
-    StoreSubjects = topics.StoreSubjects;
-  } catch (err) {
-    logger.error("[flows/runs] Adapters not initialized yet:", { error: err });
-    return {
-      error: "Server initializing",
-      message: "Please retry in a moment"
-    };
-  }
-  try {
-    const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-    let totalCount = 0;
-    try {
-      const allEntries = await store.index.read(runIndexKey, { limit: 1e4 });
-      totalCount = allEntries.length;
-    } catch {
-      totalCount = 0;
-    }
-    const entries = await store.index.read(runIndexKey, { offset, limit });
-    const filteredEntries = status ? entries.filter((e) => e.metadata?.status === status) : entries;
-    const items = filteredEntries.map((entry) => ({
-      id: entry.id,
-      flowName,
-      status: entry.metadata?.status || "unknown",
-      createdAt: new Date(entry.score).toISOString(),
-      startedAt: entry.metadata?.startedAt ? new Date(entry.metadata.startedAt).toISOString() : void 0,
-      completedAt: entry.metadata?.completedAt ? new Date(entry.metadata.completedAt).toISOString() : void 0,
-      stepCount: entry.metadata?.stepCount || 0,
-      completedSteps: entry.metadata?.completedSteps || 0
-    }));
-    return {
-      flowName,
-      count: items.length,
-      total: totalCount,
-      offset,
-      limit,
-      hasMore: offset + items.length < totalCount,
-      items
-    };
-  } catch (err) {
-    logger.error("[flows/runs] error:", { error: err });
-    return {
-      error: "Failed to list runs",
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-});

package/dist/runtime/server/api/_flows/[name]/start.post.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_flows/[name]/start.post.js

@@ -1,9 +0,0 @@
-import { defineEventHandler, getRouterParam, createError, readBody, useFlow } from "#imports";
-export default defineEventHandler(async (event) => {
-  const flowName = getRouterParam(event, "name");
-  if (!flowName) throw createError({ statusCode: 400, statusMessage: "Flow name is required" });
-  const { startFlow } = useFlow();
-  const body = await readBody(event);
-  const result = await startFlow(flowName, body || {});
-  return result;
-});

package/dist/runtime/server/api/_flows/index.get.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns pre-analyzed flows from the build-time registry.
- * Flows are analyzed during the build process for optimal performance.
- * Runtime statistics are provided via WebSocket (see ws.ts).
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_flows/index.get.js

@@ -1,5 +0,0 @@
-import { defineEventHandler, $useAnalyzedFlows } from "#imports";
-export default defineEventHandler(() => {
-  const analyzedFlows = $useAnalyzedFlows();
-  return analyzedFlows || [];
-});

package/dist/runtime/server/api/_flows/recent-runs.get.d.ts

@@ -1,15 +0,0 @@
-/**
- * GET /api/_flows/recent-runs
- *
- * Returns a list of recent flow runs across all flows.
- *
- * Query params:
- * - limit: number (default: 10)
- *
- * Returns:
- * {
- *   runs: Array<{ id, flowName, status, createdAt, ... }>
- * }
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_flows/recent-runs.get.js

@@ -1,67 +0,0 @@
-import { defineEventHandler, getQuery, useStoreAdapter, useNventLogger, useStreamTopics, $useAnalyzedFlows } from "#imports";
-export default defineEventHandler(async (event) => {
-  const logger = useNventLogger("api-flows-recent-runs");
-  const query = getQuery(event);
-  const limit = Math.min(Number.parseInt(query.limit) || 10, 50);
-  event.node.res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
-  event.node.res.setHeader("Pragma", "no-cache");
-  let store;
-  let StoreSubjects;
-  let flows;
-  try {
-    store = useStoreAdapter();
-    const topics = useStreamTopics();
-    StoreSubjects = topics.StoreSubjects;
-    flows = $useAnalyzedFlows();
-  } catch (err) {
-    logger.error("[flows/recent-runs] Adapters not initialized yet:", { error: err });
-    return {
-      error: "Server initializing",
-      message: "Please retry in a moment"
-    };
-  }
-  try {
-    const flowsList = flows || [];
-    const allRuns = [];
-    for (const flow of flowsList) {
-      try {
-        const flowName = flow.id || flow.name;
-        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const entries = await store.index.read(runIndexKey, { offset: 0, limit: 5 });
-        const flowRuns = entries.map((entry) => ({
-          id: entry.id,
-          flowName,
-          flowDisplayName: flow.displayName || flowName,
-          status: entry.metadata?.status || "unknown",
-          createdAt: entry.score,
-          // timestamp
-          startedAt: entry.metadata?.startedAt,
-          completedAt: entry.metadata?.completedAt,
-          stepCount: entry.metadata?.stepCount || 0,
-          completedSteps: entry.metadata?.completedSteps || 0
-        }));
-        allRuns.push(...flowRuns);
-      } catch (err) {
-        const flowName = flow.id || flow.name;
-        logger.debug(`No runs found for flow ${flowName}`, { error: err });
-      }
-    }
-    allRuns.sort((a, b) => b.createdAt - a.createdAt);
-    const recentRuns = allRuns.slice(0, limit);
-    return {
-      count: recentRuns.length,
-      items: recentRuns.map((run) => ({
-        ...run,
-        createdAt: new Date(run.createdAt).toISOString(),
-        startedAt: run.startedAt ? new Date(run.startedAt).toISOString() : void 0,
-        completedAt: run.completedAt ? new Date(run.completedAt).toISOString() : void 0
-      }))
-    };
-  } catch (err) {
-    logger.error("[flows/recent-runs] error:", { error: err });
-    return {
-      error: "Failed to list recent runs",
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-});

package/dist/runtime/server/api/_flows/ws.d.ts

@@ -1,80 +0,0 @@
-/**
- * WebSocket endpoint for flow run events
- * Supports subscribing to specific flow runs and receiving real-time updates
- *
- * Message format (client -> server):
- * {
- *   "type": "subscribe",
- *   "flowName": "example",
- *   "runId": "abc123"
- * }
- *
- * {
- *   "type": "unsubscribe",
- *   "flowName": "example",
- *   "runId": "abc123"
- * }
- *
- * {
- *   "type": "subscribe.stats"
- * }
- *
- * {
- *   "type": "unsubscribe.stats"
- * }
- *
- * {
- *   "type": "ping"
- * }
- *
- * Message format (server -> client):
- * {
- *   "type": "event",
- *   "flowName": "example",
- *   "runId": "abc123",
- *   "event": { v: 1, eventType: "...", record: {...} }
- * }
- *
- * {
- *   "type": "history",
- *   "flowName": "example",
- *   "runId": "abc123",
- *   "events": [ ...historicalEvents ]
- * }
- *
- * {
- *   "type": "subscribed",
- *   "flowName": "example",
- *   "runId": "abc123"
- * }
- *
- * {
- *   "type": "unsubscribed",
- *   "flowName": "example",
- *   "runId": "abc123"
- * }
- *
- * {
- *   "type": "pong",
- *   "timestamp": 1234567890
- * }
- *
- * {
- *   "type": "flow.stats.initial",
- *   "data": { id: "flowName", metadata: {...} },
- *   "timestamp": 1234567890
- * }
- *
- * {
- *   "type": "flow.stats.update",
- *   "data": { id: "flowName", metadata: {...} },
- *   "timestamp": 1234567890
- * }
- *
- * {
- *   "type": "error",
- *   "message": "error description"
- * }
- */
-declare const _default: any;
-export default _default;

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

@@ -1,309 +0,0 @@
-import {
-  defineWebSocketHandler,
-  usePeerManager,
-  useNventLogger,
-  useStreamAdapter,
-  useStoreAdapter,
-  useStreamTopics,
-  useFlow
-} 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-flows-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-flows-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, flowName, runId } = data;
-    if (type === "subscribe") {
-      if (!flowName || !runId) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing flowName or runId"
-        });
-        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 subscriptionKey = `flow:${flowName}:${runId}`;
-      const existingUnsub = context.subscriptions.get(subscriptionKey);
-      if (existingUnsub) {
-        try {
-          existingUnsub();
-        } catch (err) {
-          logger.error("[ws] error unsubscribing:", { error: err });
-        }
-      }
-      const { StoreSubjects, StreamTopics } = useStreamTopics();
-      const subject = StoreSubjects.flowRun(runId);
-      const topic = StreamTopics.flowEvents(runId);
-      const handle = await stream.subscribe(topic, async (message2) => {
-        const event = message2.data?.event;
-        if (!event) {
-          logger.warn("[ws] Received message without event data:", message2);
-          return;
-        }
-        safeSend(peer, {
-          type: "event",
-          flowName,
-          runId,
-          event: {
-            v: 1,
-            eventType: event.type,
-            record: event
-          }
-        });
-      });
-      const unsub = async () => {
-        try {
-          await handle.unsubscribe();
-        } catch (err) {
-          logger.error("[ws] error in unsub:", { error: err });
-        }
-      };
-      context.subscriptions.set(subscriptionKey, unsub);
-      try {
-        const historicalEvents = await store.stream.read(subject, {
-          limit: 100,
-          order: "asc"
-          // forward order
-        });
-        safeSend(peer, {
-          type: "history",
-          flowName,
-          runId,
-          events: historicalEvents.map((e) => ({
-            v: 1,
-            eventType: e.kind || e.type,
-            record: e
-          }))
-        });
-      } catch (err) {
-        logger.error("[ws] error sending history:", { error: err });
-        safeSend(peer, {
-          type: "error",
-          message: "Failed to load history"
-        });
-      }
-      safeSend(peer, {
-        type: "subscribed",
-        flowName,
-        runId
-      });
-    } else if (type === "unsubscribe") {
-      if (!flowName || !runId) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing flowName or runId"
-        });
-        return;
-      }
-      const subscriptionKey = `flow:${flowName}:${runId}`;
-      const unsub = context.subscriptions.get(subscriptionKey);
-      if (unsub) {
-        try {
-          await unsub();
-          context.subscriptions.delete(subscriptionKey);
-          safeSend(peer, {
-            type: "unsubscribed",
-            flowName,
-            runId
-          });
-        } 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.flowStats();
-        const handle = await stream.subscribe(topic, (message2) => {
-          safeSend(peer, {
-            type: "flow.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 flow = useFlow();
-          const allFlowStats = await flow.getAllFlowStats();
-          if (allFlowStats && allFlowStats.length > 0) {
-            for (const flowStat of allFlowStats) {
-              safeSend(peer, {
-                type: "flow.stats.initial",
-                data: {
-                  id: flowStat.name,
-                  metadata: {
-                    name: flowStat.name,
-                    displayName: flowStat.displayName,
-                    registeredAt: flowStat.registeredAt,
-                    lastRunAt: flowStat.lastRunAt,
-                    lastCompletedAt: flowStat.lastCompletedAt,
-                    stats: {
-                      total: flowStat.stats.total,
-                      success: flowStat.stats.success,
-                      failure: flowStat.stats.failure,
-                      cancel: flowStat.stats.cancel,
-                      running: flowStat.stats.running,
-                      awaiting: flowStat.stats.awaiting
-                    },
-                    version: flowStat.version
-                  }
-                },
-                timestamp: Date.now()
-              });
-            }
-          }
-        } catch (err) {
-          logger.error("[ws] error fetching initial 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 {
-          await unsub();
-          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-flows-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 unsub of Array.from(context.subscriptions.values())) {
-        try {
-          await unsub();
-        } 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-flows-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 unsub of Array.from(context.subscriptions.values())) {
-        try {
-          await unsub();
-        } catch (err) {
-          logger.error("[ws] error unsubscribing on error:", { error: err });
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  }
-});

package/dist/runtime/server/api/_queues/[name]/job/[id].get.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/server/api/_queues/[name]/job/[id].get.js

@@ -1,14 +0,0 @@
-import { defineEventHandler, getRouterParam, useQueueAdapter } from "#imports";
-export default defineEventHandler(async (event) => {
-  const name = getRouterParam(event, "name") || "";
-  const id = getRouterParam(event, "id") || "";
-  let queue;
-  try {
-    queue = useQueueAdapter();
-  } catch {
-    return null;
-  }
-  const job = await queue.getJob(name, id);
-  if (!job) return null;
-  return { ...job, queue: name };
-});

package/dist/runtime/server/api/_queues/[name]/job/index.get.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;