@nvent-addon/app 0.4.5 → 0.5.1

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

@@ -0,0 +1,315 @@
+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);
+    }
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../../../playground/.nuxt/tsconfig.server.json",
+  "exclude": [
+    "node_modules", 
+    "dist"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nvent-addon/app",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "nvent app module for Nuxt.js",
   "repository": "DevJoghurt/nvent",
   "license": "MIT",
@@ -19,29 +19,29 @@
   "scripts": {
     "build": "nuxt-module-build build",
     "dev": "nuxt-module-build build --stub",
-    "prepack": "pnpm build",
-    "test": "vitest"
+    "prepack": "pnpm build"
   },
   "dependencies": {
-    "@iconify-json/devicon": "^1.2.49",
+    "@iconify-json/devicon": "^1.2.51",
     "@iconify-json/heroicons": "1.2.3",
-    "@iconify-json/lucide": "^1.2.73",
+    "@iconify-json/lucide": "^1.2.76",
     "@nuxt/kit": "4.2.1",
+    "@nuxt/ui": "4.2.1",
     "@vue-flow/background": "^1.3.2",
     "@vue-flow/controls": "^1.1.3",
-    "@vue-flow/core": "^1.47.0",
+    "@vue-flow/core": "^1.48.0",
     "@vue-flow/minimap": "^1.5.4",
     "defu": "^6.1.4",
     "json-editor-vue": "^0.18.1",
     "nuxt": "4.2.1",
     "pathe": "^2.0.3",
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "4.2.1",
     "@types/node": "^24.10.1",
     "typescript": "latest",
-    "vitest": "^4.0.10"
+    "vitest": "^4.0.14"
   }
 }

package/dist/runtime/app/components/FlowScheduleDialog.vue

@@ -1,226 +0,0 @@
-<template>
-  <UModal v-model:open="isOpen">
-    <template #header>
-      <div class="flex items-center justify-between">
-        <div>
-          <h3 class="text-lg font-semibold">
-            Schedule Flow
-          </h3>
-          <p class="text-sm text-gray-500 mt-1">
-            {{ flowName }}
-          </p>
-        </div>
-      </div>
-    </template>
-    <template #body>
-      <div class="space-y-4">
-        <!-- Schedule Type -->
-        <div>
-          <label class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2 block">
-            Schedule Type
-          </label>
-          <UTabs
-            v-model="scheduleType"
-            :items="typeOptions"
-            size="sm"
-            variant="pill"
-            color="neutral"
-          />
-        </div>
-
-        <!-- Cron Pattern -->
-        <div v-if="scheduleType === 'cron'">
-          <label class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2 block">
-            Pattern
-          </label>
-          <USelectMenu
-            v-model="selectedPreset"
-            :items="cronPresets"
-            class="w-full"
-            placeholder="Select preset or custom"
-          />
-          <UInput
-            v-if="selectedPreset?.value === 'custom'"
-            v-model="customCron"
-            placeholder="0 2 * * *"
-            class="mt-2 w-full"
-          />
-        </div>
-
-        <!-- Delay -->
-        <div v-else-if="scheduleType === 'delay'">
-          <label class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2 block">
-            Delay
-          </label>
-          <div class="flex gap-2">
-            <UInput
-              v-model="delayValue"
-              type="number"
-              placeholder="5"
-              class="flex-1"
-            />
-            <USelectMenu
-              v-model="delayUnit"
-              :items="delayUnits"
-              class="w-32"
-            />
-          </div>
-        </div>
-
-        <!-- Input Data -->
-        <div>
-          <label class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2 block">
-            Input Data (JSON)
-          </label>
-          <UTextarea
-            v-model="inputJson"
-            placeholder="{ &quot;key&quot;: &quot;value&quot; }"
-            :rows="4"
-            class="font-mono text-sm w-full"
-          />
-          <p
-            v-if="jsonError"
-            class="text-xs text-red-500 mt-1"
-          >
-            {{ jsonError }}
-          </p>
-        </div>
-
-        <!-- Description -->
-        <div>
-          <label class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2 block">
-            Description (optional)
-          </label>
-          <UInput
-            v-model="description"
-            class="w-full"
-            placeholder="Daily cleanup job"
-          />
-        </div>
-      </div>
-    </template>
-    <template #footer>
-      <div class="flex justify-end gap-2">
-        <UButton
-          color="neutral"
-          variant="ghost"
-          @click="isOpen = false"
-        >
-          Cancel
-        </UButton>
-        <UButton
-          color="primary"
-          :loading="isSubmitting"
-          :disabled="!canSubmit"
-          @click="handleSubmit"
-        >
-          Schedule Flow
-        </UButton>
-      </div>
-    </template>
-  </UModal>
-</template>
-
-<script setup>
-import { ref, computed, watch } from "#imports";
-import { UModal, UButton, UTabs, USelectMenu, UInput, UTextarea } from "#components";
-const props = defineProps({
-  flowName: { type: String, required: true }
-});
-const emit = defineEmits(["scheduled"]);
-const isOpen = defineModel({ type: Boolean, ...{ default: false } });
-const scheduleType = ref("cron");
-const typeOptions = [
-  { label: "Recurring (Cron)", value: "cron" },
-  { label: "One-time (Delay)", value: "delay" }
-];
-const cronPresets = [
-  { label: "Every minute", value: "* * * * *" },
-  { label: "Every 5 minutes", value: "*/5 * * * *" },
-  { label: "Every hour", value: "0 * * * *" },
-  { label: "Daily at 2 AM", value: "0 2 * * *" },
-  { label: "Daily at noon", value: "0 12 * * *" },
-  { label: "Weekly (Monday 9 AM)", value: "0 9 * * 1" },
-  { label: "Monthly (1st at midnight)", value: "0 0 1 * *" },
-  { label: "Custom", value: "custom" }
-];
-const selectedPreset = ref(cronPresets[3]);
-const customCron = ref("");
-const delayValue = ref("5");
-const delayUnit = ref({ label: "Minutes", value: 6e4 });
-const delayUnits = [
-  { label: "Seconds", value: 1e3 },
-  { label: "Minutes", value: 6e4 },
-  { label: "Hours", value: 36e5 },
-  { label: "Days", value: 864e5 }
-];
-const inputJson = ref("");
-const description = ref("");
-const isSubmitting = ref(false);
-const jsonError = computed(() => {
-  if (!inputJson.value)
-    return null;
-  try {
-    JSON.parse(inputJson.value);
-    return null;
-  } catch (e) {
-    return `Invalid JSON: ${e.message}`;
-  }
-});
-const canSubmit = computed(() => {
-  if (jsonError.value)
-    return false;
-  if (scheduleType.value === "cron") {
-    if (selectedPreset.value?.value === "custom") {
-      return customCron.value.trim().length > 0;
-    }
-    return selectedPreset.value?.value != null;
-  } else {
-    const num = Number.parseInt(delayValue.value);
-    return !Number.isNaN(num) && num > 0;
-  }
-});
-const handleSubmit = async () => {
-  isSubmitting.value = true;
-  try {
-    let input = {};
-    if (inputJson.value) {
-      input = JSON.parse(inputJson.value);
-    }
-    const body = {
-      input,
-      metadata: {
-        description: description.value || void 0
-      }
-    };
-    if (scheduleType.value === "cron") {
-      body.cron = selectedPreset.value?.value === "custom" ? customCron.value : selectedPreset.value?.value;
-    } else {
-      const num = Number.parseInt(delayValue.value);
-      body.delay = num * delayUnit.value.value;
-    }
-    await $fetch(`/api/_flows/${props.flowName}/schedule`, {
-      method: "POST",
-      body
-    });
-    emit("scheduled");
-    isOpen.value = false;
-    inputJson.value = "";
-    description.value = "";
-    customCron.value = "";
-    delayValue.value = "5";
-  } finally {
-    isSubmitting.value = false;
-  }
-};
-watch(isOpen, (newVal) => {
-  if (!newVal) {
-    scheduleType.value = "cron";
-    selectedPreset.value = cronPresets[3];
-    inputJson.value = "";
-    description.value = "";
-    customCron.value = "";
-    delayValue.value = "5";
-  }
-});
-</script>

package/dist/runtime/app/components/FlowSchedulesList.vue

@@ -1,99 +0,0 @@
-<template>
-  <div class="space-y-4">
-    <div v-if="!schedules || schedules.length === 0">
-      <UAlert
-        color="info"
-        title="No schedules configured"
-        variant="subtle"
-        icon="i-lucide-info"
-        description="Create a schedule to run this flow automatically"
-      />
-    </div>
-
-    <div
-      v-for="schedule in schedules"
-      :key="schedule.id"
-      class="border border-gray-200 dark:border-gray-800 rounded-lg p-4"
-    >
-      <div class="flex items-start justify-between">
-        <div class="flex-1">
-          <div class="flex items-center gap-2 mb-2">
-            <UIcon
-              name="i-lucide-clock"
-              class="text-blue-500"
-            />
-            <span class="font-medium text-sm">
-              {{ schedule.schedule.cron || "One-time delay" }}
-            </span>
-          </div>
-          <div class="text-xs text-gray-500 space-y-1">
-            <div>
-              <span class="font-medium">Next run:</span>
-              {{ formatDate(schedule.nextRun) }}
-            </div>
-            <div v-if="schedule.metadata?.description">
-              <span class="font-medium">Description:</span>
-              {{ schedule.metadata.description }}
-            </div>
-          </div>
-        </div>
-        <UButton
-          icon="i-lucide-trash-2"
-          color="error"
-          variant="ghost"
-          size="xs"
-          :loading="deletingId === schedule.id"
-          @click="handleDelete(schedule.id)"
-        />
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, onMounted } from "#imports";
-import { UAlert, UButton, UIcon } from "#components";
-const props = defineProps({
-  flowName: { type: String, required: true }
-});
-const emit = defineEmits(["updated"]);
-const schedules = ref([]);
-const deletingId = ref(null);
-const loadSchedules = async () => {
-  try {
-    const data = await $fetch(`/api/_flows/${props.flowName}/schedules`);
-    schedules.value = data;
-  } catch (error) {
-    console.error("Failed to load schedules:", error);
-    schedules.value = [];
-  }
-};
-const handleDelete = async (id) => {
-  deletingId.value = id;
-  try {
-    await $fetch(`/api/_flows/${props.flowName}/schedules/${id}`, {
-      method: "DELETE"
-    });
-    await loadSchedules();
-    emit("updated");
-  } catch (error) {
-    console.error("Failed to delete schedule:", error);
-  } finally {
-    deletingId.value = null;
-  }
-};
-const formatDate = (date) => {
-  if (!date)
-    return "N/A";
-  return new Date(date).toLocaleString("en-US", {
-    dateStyle: "medium",
-    timeStyle: "short"
-  });
-};
-onMounted(() => {
-  loadSchedules();
-});
-defineExpose({
-  loadSchedules
-});
-</script>