@nvent-addon/app 0.4.5 → 0.5.1

package/dist/runtime/server/api/_triggers/[name].patch.js

@@ -0,0 +1,117 @@
+import { defineEventHandler, getRouterParam, readBody, useTrigger } from "#imports";
+export default defineEventHandler(async (event) => {
+  const logger = {
+    info: console.log,
+    error: console.error
+  };
+  const trigger = useTrigger();
+  const name = getRouterParam(event, "name");
+  if (!name) {
+    return {
+      error: "Missing trigger name",
+      statusCode: 400
+    };
+  }
+  try {
+    const body = await readBody(event);
+    logger.info("Updating trigger", {
+      name,
+      updates: Object.keys(body)
+    });
+    if (!trigger.hasTrigger(name)) {
+      return {
+        error: "Trigger not found",
+        statusCode: 404
+      };
+    }
+    const existing = trigger.getTrigger(name);
+    if (!existing) {
+      return {
+        error: "Trigger not found",
+        statusCode: 404
+      };
+    }
+    const updateOpts = {
+      name,
+      type: existing.type,
+      scope: existing.scope,
+      status: body.status !== void 0 ? body.status : existing.status,
+      displayName: body.displayName !== void 0 ? body.displayName : existing.displayName,
+      description: body.description !== void 0 ? body.description : existing.description,
+      source: existing.source
+    };
+    if (existing.type === "webhook" && body.config) {
+      updateOpts.webhook = {
+        path: body.config.path !== void 0 ? body.config.path : existing.webhook?.path,
+        method: body.config.method !== void 0 ? body.config.method : existing.webhook?.method,
+        auth: body.config.requireAuth ? {
+          header: body.config.authHeader || existing.webhook?.auth?.header || "X-API-Key"
+        } : void 0
+      };
+    } else if (existing.webhook) {
+      updateOpts.webhook = existing.webhook;
+    }
+    if (existing.type === "schedule" && body.config) {
+      updateOpts.schedule = {
+        cron: body.config.cron !== void 0 ? body.config.cron : existing.schedule?.cron,
+        timezone: body.config.timezone !== void 0 ? body.config.timezone : existing.schedule?.timezone
+      };
+      if (body.config.interval !== void 0 || existing.schedule?.interval !== void 0) {
+        updateOpts.schedule.interval = body.config.interval !== void 0 ? body.config.interval : existing.schedule?.interval;
+      }
+    } else if (existing.schedule) {
+      updateOpts.schedule = existing.schedule;
+    }
+    if (existing.type === "event" && body.config) {
+      updateOpts.config = {
+        event: body.config.event !== void 0 ? body.config.event : existing.config?.event,
+        filter: body.config.filter !== void 0 ? body.config.filter ? JSON.parse(body.config.filter) : void 0 : existing.config?.filter
+      };
+    } else if (existing.config) {
+      updateOpts.config = existing.config;
+    }
+    await trigger.registerTrigger(updateOpts);
+    if (body.subscriptions !== void 0) {
+      const currentSubs = trigger.getSubscribedFlows(name);
+      const newSubs = Array.from(new Set(body.subscriptions));
+      logger.info("Processing subscription changes", {
+        trigger: name,
+        currentSubs,
+        newSubs,
+        toRemove: currentSubs.filter((f) => !newSubs.includes(f)),
+        toAdd: newSubs.filter((f) => !currentSubs.includes(f))
+      });
+      for (const flowName of currentSubs) {
+        if (!newSubs.includes(flowName)) {
+          logger.info(`Removing subscription: ${flowName} from ${name}`);
+          await trigger.unsubscribeTrigger(name, flowName);
+        }
+      }
+      for (const flowName of newSubs) {
+        if (!currentSubs.includes(flowName)) {
+          logger.info(`Adding new subscription: ${flowName} to ${name}`);
+          await trigger.subscribeTrigger({
+            trigger: name,
+            flow: flowName,
+            mode: "auto"
+          });
+        } else {
+          logger.info(`Subscription already exists: ${flowName}, skipping`);
+        }
+      }
+    }
+    logger.info(`Successfully updated trigger '${name}'`);
+    const updated = trigger.getTrigger(name);
+    return {
+      success: true,
+      trigger: updated
+    };
+  } catch (err) {
+    logger.error("Failed to update trigger", { error: err });
+    return {
+      error: "Failed to update trigger",
+      message: err instanceof Error ? err.message : String(err),
+      statusCode: 500
+    };
+  }
+});

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

@@ -0,0 +1,6 @@
+/**
+ * Get all triggers with their subscriptions and stats
+ * Returns comprehensive trigger data for the UI
+ */
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,44 @@
+import { defineEventHandler, useTrigger } from "#imports";
+export default defineEventHandler(async () => {
+  const { getAllTriggers, getSubscribedFlows, getTriggerStats } = useTrigger();
+  const triggers = getAllTriggers({
+    sortBy: "registeredAt",
+    order: "desc"
+  });
+  const enhancedTriggers = await Promise.all(
+    triggers.map(async (trigger) => {
+      const subscribedFlows = getSubscribedFlows(trigger.name);
+      const stats = await getTriggerStats(trigger.name);
+      return {
+        name: trigger.name,
+        type: trigger.type,
+        scope: trigger.scope,
+        displayName: trigger.displayName,
+        description: trigger.description,
+        source: trigger.source,
+        status: trigger.status || "active",
+        registeredAt: trigger.registeredAt,
+        lastActivityAt: trigger.lastActivityAt,
+        webhook: trigger.webhook,
+        schedule: trigger.schedule,
+        config: trigger.config,
+        subscribedFlows,
+        subscriptionCount: subscribedFlows.length,
+        stats: {
+          totalFires: stats?.totalFires || 0,
+          last24h: 0,
+          // Not tracked yet in current implementation
+          successCount: 0,
+          // Not tracked yet
+          failureCount: 0,
+          // Not tracked yet
+          activeSubscribers: stats?.activeSubscribers || subscribedFlows.length,
+          successRate: 100,
+          // Default since failures not tracked yet
+          lastFiredAt: stats?.lastFiredAt
+        }
+      };
+    })
+  );
+  return enhancedTriggers;
+});

package/dist/runtime/server/api/_triggers/index.post.d.ts

@@ -0,0 +1,7 @@
+/**
+ * POST /api/_triggers
+ *
+ * Register a new trigger with subscriptions
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_triggers/index.post.js

@@ -0,0 +1,124 @@
+import { defineEventHandler, readBody, useTrigger } from "#imports";
+export default defineEventHandler(async (event) => {
+  const logger = {
+    info: console.log,
+    error: console.error
+  };
+  const trigger = useTrigger();
+  try {
+    const body = await readBody(event);
+    if (!body.name) {
+      return {
+        error: "Missing required field: name",
+        statusCode: 400
+      };
+    }
+    if (!body.type) {
+      return {
+        error: "Missing required field: type",
+        statusCode: 400
+      };
+    }
+    if (!["event", "webhook", "schedule", "manual"].includes(body.type)) {
+      return {
+        error: "Invalid trigger type",
+        statusCode: 400
+      };
+    }
+    if (body.type === "event" && !body.config?.event) {
+      return {
+        error: "Event triggers require config.event",
+        statusCode: 400
+      };
+    }
+    if (body.type === "webhook" && !body.config?.path) {
+      return {
+        error: "Webhook triggers require config.path",
+        statusCode: 400
+      };
+    }
+    if (body.type === "schedule") {
+      if (!body.config?.cron && !body.config?.interval) {
+        return {
+          error: "Schedule triggers require config.cron or config.interval",
+          statusCode: 400
+        };
+      }
+    }
+    logger.info("Registering new trigger", {
+      name: body.name,
+      type: body.type,
+      subscriptions: body.subscriptions?.length || 0
+    });
+    if (trigger.hasTrigger(body.name)) {
+      return {
+        error: "Trigger already exists",
+        statusCode: 409
+      };
+    }
+    const triggerOpts = {
+      name: body.name,
+      type: body.type,
+      scope: body.scope || "flow",
+      displayName: body.displayName || body.name,
+      description: body.description,
+      source: "ui"
+    };
+    if (body.type === "webhook") {
+      triggerOpts.webhook = {
+        path: body.config.path,
+        method: body.config.method || "POST",
+        auth: body.config.requireAuth ? {
+          header: body.config.authHeader || "X-API-Key"
+        } : void 0
+      };
+    } else if (body.type === "schedule") {
+      triggerOpts.schedule = {
+        cron: body.config.cron || void 0,
+        interval: body.config.interval || void 0,
+        timezone: body.config.timezone || "UTC"
+      };
+      if (body.config.runImmediately) {
+        triggerOpts.config = { runImmediately: true };
+      }
+    } else if (body.type === "event") {
+      triggerOpts.config = {
+        event: body.config.event,
+        filter: body.config.filter ? JSON.parse(body.config.filter) : void 0
+      };
+    }
+    await trigger.registerTrigger(triggerOpts);
+    if (body.subscriptions && body.subscriptions.length > 0) {
+      for (const flowName of body.subscriptions) {
+        await trigger.subscribeTrigger({
+          trigger: body.name,
+          flow: flowName,
+          mode: "auto"
+        });
+      }
+    }
+    logger.info(
+      `Successfully registered trigger '${body.name}' with ${body.subscriptions?.length || 0} subscriptions`
+    );
+    return {
+      success: true,
+      trigger: {
+        name: body.name,
+        displayName: body.displayName || body.name,
+        type: body.type,
+        scope: body.scope || "flow",
+        config: body.config || {},
+        subscriptions: body.subscriptions || [],
+        status: "active",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  } catch (err) {
+    logger.error("Failed to create trigger", { error: err });
+    return {
+      error: "Failed to create trigger",
+      message: err instanceof Error ? err.message : String(err),
+      statusCode: 500
+    };
+  }
+});

package/dist/runtime/server/api/_triggers/stats.get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get aggregate trigger statistics
+ * Returns overview stats for the triggers page
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_triggers/stats.get.js

@@ -0,0 +1,41 @@
+import { defineEventHandler, useTrigger } from "#imports";
+export default defineEventHandler(async () => {
+  const { getAllTriggers, getAllSubscriptions } = useTrigger();
+  const triggers = getAllTriggers();
+  const subscriptions = getAllSubscriptions();
+  const byType = triggers.reduce((acc, trigger) => {
+    acc[trigger.type] = (acc[trigger.type] || 0) + 1;
+    return acc;
+  }, {});
+  const byScope = triggers.reduce((acc, trigger) => {
+    acc[trigger.scope] = (acc[trigger.scope] || 0) + 1;
+    return acc;
+  }, {});
+  const byStatus = triggers.reduce((acc, trigger) => {
+    const status = trigger.status || "active";
+    acc[status] = (acc[status] || 0) + 1;
+    return acc;
+  }, {});
+  const { getTriggerStats } = useTrigger();
+  let totalFires = 0;
+  for (const trigger of triggers) {
+    const stats = await getTriggerStats(trigger.name);
+    totalFires += stats?.totalFires || 0;
+  }
+  return {
+    total: triggers.length,
+    active: byStatus.active || 0,
+    inactive: byStatus.inactive || 0,
+    retired: byStatus.retired || 0,
+    byType,
+    byScope,
+    byStatus,
+    totalSubscriptions: subscriptions.length,
+    totalFires,
+    // Count triggers with active subscriptions
+    withSubscribers: triggers.filter((t) => {
+      const triggerSubs = subscriptions.filter((s) => s.triggerName === t.name);
+      return triggerSubs.length > 0;
+    }).length
+  };
+});

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

@@ -0,0 +1,74 @@
+/**
+ * WebSocket endpoint for trigger events
+ * Supports subscribing to specific triggers and receiving real-time updates
+ *
+ * Message format (client -> server):
+ * {
+ *   "type": "subscribe",
+ *   "triggerName": "user.created"
+ * }
+ *
+ * {
+ *   "type": "unsubscribe",
+ *   "triggerName": "user.created"
+ * }
+ *
+ * {
+ *   "type": "ping"
+ * }
+ *
+ * {
+ *   "type": "subscribe.stats"
+ * }
+ *
+ * {
+ *   "type": "unsubscribe.stats"
+ * }
+ *
+ * Message format (server -> client):
+ * {
+ *   "type": "event",
+ *   "triggerName": "user.created",
+ *   "event": { type: "...", data: {...}, timestamp: ... }
+ * }
+ *
+ * {
+ *   "type": "history",
+ *   "triggerName": "user.created",
+ *   "events": [ ...historicalEvents ]
+ * }
+ *
+ * {
+ *   "type": "subscribed",
+ *   "triggerName": "user.created"
+ * }
+ *
+ * {
+ *   "type": "unsubscribed",
+ *   "triggerName": "user.created"
+ * }
+ *
+ * {
+ *   "type": "trigger.stats.initial",
+ *   "data": { id: "triggerName", metadata: {...} },
+ *   "timestamp": 1234567890
+ * }
+ *
+ * {
+ *   "type": "trigger.stats.update",
+ *   "data": { id: "triggerName", metadata: {...} },
+ *   "timestamp": 1234567890
+ * }
+ *
+ * {
+ *   "type": "pong",
+ *   "timestamp": 1234567890
+ * }
+ *
+ * {
+ *   "type": "error",
+ *   "message": "error description"
+ * }
+ */
+declare const _default: any;
+export default _default;