nvent 0.5.6 → 0.5.8

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "configKey": "nvent",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -986,6 +986,7 @@ export type {
   FlowStats,
   StartFlowResult,
   CancelFlowResult,
+  RestartFlowResult,
   RunningFlow,
   FlowComposable,
 } from ${JSON.stringify(resolverFn("./runtime/nitro/utils/useFlow"))}

package/dist/runtime/events/utils/scheduleTrigger.js

@@ -6,6 +6,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
   const eventBus = getEventBus();
   try {
     const jobId = `trigger:${triggerName}`;
+    const isEnabled = triggerStatus === "active";
     const handler = async () => {
       logger.debug("Schedule trigger fired", { trigger: triggerName });
       await eventBus.publish({
@@ -28,7 +29,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
         type: "schedule-trigger",
         scheduleConfig
       },
-      enabled: triggerStatus === "active"
+      enabled: isEnabled
     };
     if (scheduleConfig.cron) {
       jobConfig.cron = scheduleConfig.cron;
@@ -39,6 +40,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
     await scheduler.schedule(jobConfig);
     logger.info("Scheduled trigger", {
       trigger: triggerName,
+      enabled: isEnabled,
       cron: scheduleConfig.cron,
       interval: scheduleConfig.interval,
       timezone: scheduleConfig.timezone

package/dist/runtime/events/utils/stallDetector.d.ts

@@ -39,8 +39,15 @@ export declare class FlowStallDetector {
     /**
      * Mark a flow as stalled
      * Emits a flow.stalled event and updates the flow status
+     * Also emits step.stalled events for any steps that were running when the flow stalled
      */
     markAsStalled(flowName: string, runId: string, reason?: string): Promise<void>;
+    /**
+     * Find steps that were running when the flow stalled
+     * A step is considered "running" if it has step.started but no terminal event
+     * (step.completed, step.failed, step.stalled)
+     */
+    private findStalledSteps;
     /**
      * Run startup recovery to clean up flows left in running state from previous server instance
      * This marks all running flows as stalled since their in-memory state is lost

package/dist/runtime/events/utils/stallDetector.js

@@ -34,6 +34,7 @@ export class FlowStallDetector {
   /**
    * Mark a flow as stalled
    * Emits a flow.stalled event and updates the flow status
+   * Also emits step.stalled events for any steps that were running when the flow stalled
    */
   async markAsStalled(flowName, runId, reason = "No activity timeout") {
     const { StoreSubjects } = useStreamTopics();
@@ -57,14 +58,46 @@ export class FlowStallDetector {
         });
       }
       const streamName = StoreSubjects.flowRun(runId);
+      const stalledAt = Date.now();
+      try {
+        const allEvents = await this.store.stream.read(streamName);
+        const stalledSteps = this.findStalledSteps(allEvents);
+        for (const stepName of stalledSteps) {
+          await this.store.stream.append(streamName, {
+            type: "step.stalled",
+            runId,
+            flowName,
+            stepName,
+            data: {
+              reason: "Flow stalled - step execution interrupted",
+              stalledAt
+            }
+          });
+          this.logger.debug(`Emitted step.stalled for step '${stepName}'`, { flowName, runId });
+        }
+        if (stalledSteps.length > 0) {
+          this.logger.info(`Marked ${stalledSteps.length} step(s) as stalled`, {
+            flowName,
+            runId,
+            steps: stalledSteps
+          });
+        }
+      } catch (err) {
+        this.logger.warn("Failed to emit step.stalled events", {
+          flowName,
+          runId,
+          error: err.message
+        });
+      }
       await this.store.stream.append(streamName, {
         type: "flow.stalled",
         runId,
         flowName,
         data: {
           reason,
-          previousStatus
+          previousStatus,
           // Include previous status so stats handler knows which counter to decrement
+          stalledAt
         }
       });
       this.logger.info(`Marked flow as stalled - '${flowName}' runId '${runId}': ${reason}`);
@@ -72,6 +105,39 @@ export class FlowStallDetector {
       this.logger.error(`Failed to mark flow as stalled for '${flowName}' runId '${runId}': ${error.message}`);
     }
   }
+  /**
+   * Find steps that were running when the flow stalled
+   * A step is considered "running" if it has step.started but no terminal event
+   * (step.completed, step.failed, step.stalled)
+   */
+  findStalledSteps(events) {
+    const stepStates = /* @__PURE__ */ new Map();
+    for (const e of events) {
+      const stepName = e.stepName;
+      if (!stepName) continue;
+      if (e.type === "step.started") {
+        if (!stepStates.has(stepName) || stepStates.get(stepName) === "started") {
+          stepStates.set(stepName, "started");
+        }
+      } else if (e.type === "step.completed") {
+        stepStates.set(stepName, "completed");
+      } else if (e.type === "step.failed") {
+        const willRetry = e.data?.willRetry || e.data?.retry;
+        if (!willRetry) {
+          stepStates.set(stepName, "failed");
+        }
+      } else if (e.type === "step.stalled") {
+        stepStates.set(stepName, "stalled");
+      }
+    }
+    const stalledSteps = [];
+    for (const [stepName, state] of stepStates) {
+      if (state === "started") {
+        stalledSteps.push(stepName);
+      }
+    }
+    return stalledSteps;
+  }
   /**
    * Run startup recovery to clean up flows left in running state from previous server instance
    * This marks all running flows as stalled since their in-memory state is lost

package/dist/runtime/nitro/utils/useFlow.d.ts

@@ -25,6 +25,12 @@ export interface CancelFlowResult {
     runId: string;
     flowName: string;
 }
+export interface RestartFlowResult {
+    success: boolean;
+    oldRunId: string;
+    newRunId: string;
+    flowName: string;
+}
 export interface RunningFlow {
     id: string;
     flowName: string;
@@ -37,6 +43,7 @@ export interface FlowComposable {
     startFlow: (flowName: string, payload?: any) => Promise<StartFlowResult>;
     emit: (trigger: string, payload?: any) => Promise<any[]>;
     cancelFlow: (flowName: string, runId: string) => Promise<CancelFlowResult>;
+    restartFlow: (flowName: string, runId: string) => Promise<RestartFlowResult>;
     isRunning: (flowName: string, runId?: string, options?: {
         excludeRunIds?: string[];
     }) => Promise<boolean>;

package/dist/runtime/nitro/utils/useFlow.js

@@ -94,6 +94,51 @@ export function useFlow() {
         throw err;
       }
     },
+    /**
+     * Restart a flow by canceling the current run and starting a new one with the same input
+     * @param flowName - The name of the flow
+     * @param runId - The run ID to restart
+     */
+    async restartFlow(flowName, runId) {
+      try {
+        const streamName = StoreSubjects.flowRun(runId);
+        const events = await store.stream.read(streamName);
+        const startEvent = events.find((e) => e.type === "flow.start" || e.type === "flow.started");
+        const originalInput = startEvent?.data?.input || {};
+        logger.debug("Found original input for restart", { flowName, runId, hasInput: !!startEvent });
+        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
+        const entry = await store.index.get(runIndexKey, runId);
+        const currentStatus = entry?.metadata?.status;
+        if (currentStatus === "running" || currentStatus === "awaiting") {
+          await eventsManager.publishBus({
+            type: "flow.cancel",
+            runId,
+            flowName,
+            data: {
+              canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
+              previousStatus: currentStatus,
+              reason: "Restarted"
+            }
+          });
+          logger.info("Canceled flow for restart", { flowName, runId, previousStatus: currentStatus });
+        }
+        const newResult = await this.startFlow(flowName, originalInput);
+        logger.info("Flow restarted", {
+          flowName,
+          oldRunId: runId,
+          newRunId: newResult.flowId
+        });
+        return {
+          success: true,
+          oldRunId: runId,
+          newRunId: newResult.flowId,
+          flowName
+        };
+      } catch (err) {
+        logger.error("Failed to restart flow", { flowName, runId, error: err });
+        throw err;
+      }
+    },
     /**
      * Check if a flow is currently running (includes 'running' and 'awaiting' status)
      * @param flowName - The name of the flow to check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Event-driven workflows for Nuxt",
   "repository": "DevJoghurt/nvent",
   "license": "MIT",