nvent 0.4.4 → 0.5.0

package/dist/runtime/scheduler/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Scheduler Types
+ *
+ * Unified scheduling system for all time-based operations in nvent:
+ * - Stall detection
+ * - Await timeouts
+ * - Trigger schedules
+ * - Cleanup jobs
+ */
+export interface ScheduledJob {
+    /**
+     * Unique job identifier
+     */
+    id: string;
+    /**
+     * Human-readable job name
+     */
+    name: string;
+    /**
+     * Job type
+     */
+    type: 'cron' | 'interval' | 'one-time';
+    /**
+     * Cron expression (for type: 'cron')
+     * @example '0 2 * * *' - Daily at 2 AM
+     * @example '* /5 * * * *' - Every 5 minutes
+     */
+    cron?: string;
+    /**
+     * Interval in milliseconds (for type: 'interval')
+     */
+    interval?: number;
+    /**
+     * Execution timestamp (for type: 'one-time')
+     */
+    executeAt?: number;
+    /**
+     * Job handler function
+     */
+    handler: () => Promise<void>;
+    /**
+     * Timezone for cron jobs
+     * @default 'UTC'
+     */
+    timezone?: string;
+    /**
+     * Whether the job is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Last execution timestamp
+     */
+    lastRun?: number;
+    /**
+     * Next scheduled execution timestamp
+     */
+    nextRun?: number;
+    /**
+     * Total execution count
+     */
+    runCount?: number;
+    /**
+     * Failure count
+     */
+    failCount?: number;
+}
+export interface SchedulerAdapter {
+    /**
+     * Schedule a job with distributed locking support
+     */
+    schedule(job: ScheduledJob): Promise<string>;
+    /**
+     * Unschedule a job
+     */
+    unschedule(jobId: string): Promise<boolean>;
+    /**
+     * Start the scheduler (begins processing scheduled jobs)
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scheduler and release all locks
+     */
+    stop(): Promise<void>;
+    /**
+     * Get all scheduled jobs (in-memory, for this instance)
+     */
+    getScheduledJobs(): Promise<ScheduledJob[]>;
+    /**
+     * Get all persisted jobs from store (across all instances)
+     * Useful for debugging and monitoring in horizontal setups
+     */
+    getAllPersistedJobs(): Promise<ScheduledJob[]>;
+    /**
+     * Check if scheduler is healthy
+     */
+    isHealthy(): Promise<boolean>;
+}
+export interface SchedulerLock {
+    jobId: string;
+    instanceId: string;
+    acquiredAt: number;
+    expiresAt: number;
+}
+export interface SchedulerStats {
+    jobId: string;
+    lastRun: number;
+    nextRun?: number;
+    runCount: number;
+    failCount: number;
+    lastError?: string;
+}

package/dist/runtime/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../../../playground/.nuxt/tsconfig.server.json",
+	"include": [
+		"./**/*.ts"
+  	],
+	"exclude": [
+	]
+}

package/dist/runtime/worker/node/runner.d.ts

@@ -0,0 +1,53 @@
+import { useFlow } from '#imports';
+/**
+ * Generic job interface that works with any queue adapter
+ * Adapters should provide jobs in this format
+ */
+export interface QueueJob {
+    id: string;
+    name: string;
+    data: any;
+    attemptsMade?: number;
+    opts?: {
+        attempts?: number;
+    };
+}
+export interface RunLogger {
+    log: (level: 'debug' | 'info' | 'warn' | 'error', msg: string, meta?: any) => void;
+}
+export interface RunState {
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, opts?: {
+        ttl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export interface RunContext {
+    jobId?: string;
+    queue?: string;
+    flowId?: string;
+    flowName?: string;
+    stepName?: string;
+    stepId?: string;
+    attempt?: number;
+    logger: RunLogger;
+    state: RunState;
+    flow: ReturnType<typeof useFlow>;
+    /**
+     * Resolved data from await pattern (awaitBefore only)
+     * Available when step resumes after await resolution
+     */
+    trigger?: any;
+    /**
+     * Current step's await configuration
+     * Useful for conditional logic based on await settings
+     */
+    awaitConfig?: any;
+}
+export declare function buildContext(partial?: Partial<RunContext>): RunContext;
+export type NodeHandler = (input: any, ctx: RunContext) => Promise<any>;
+/**
+ * Wraps a NodeHandler with full RunContext building and event emission
+ * Works with any queue adapter by accepting a job-like object
+ */
+export declare function createJobProcessor(handler: NodeHandler, queueName: string): (job: QueueJob) => Promise<any>;

package/dist/runtime/worker/node/runner.js

@@ -0,0 +1,327 @@
+import { randomUUID } from "node:crypto";
+import {
+  useRuntimeConfig,
+  useFlow,
+  useEventManager,
+  useNventLogger,
+  $useFunctionRegistry,
+  useAwait,
+  useHookRegistry,
+  useStreamTopics,
+  useStateAdapter,
+  useStoreAdapter,
+  useRunContext
+} from "#imports";
+const logger = useNventLogger("node-runner");
+const defaultState = {
+  async get() {
+    return null;
+  },
+  async set() {
+  },
+  async delete() {
+  }
+};
+function scopeKey(baseKey, flowId) {
+  if (!flowId) return baseKey;
+  return `flow:${flowId}:${baseKey}`;
+}
+export function buildContext(partial) {
+  const state = partial?.state || (() => {
+    try {
+      const stateAdapter = useStateAdapter();
+      const rc = useRuntimeConfig();
+      const cleanupCfg = rc?.nvent?.state?.cleanup || { strategy: "never" };
+      return {
+        async get(key) {
+          return stateAdapter.get(scopeKey(key, partial?.flowId));
+        },
+        async set(key, value, opts) {
+          const ttl = opts?.ttl ?? (cleanupCfg?.strategy === "ttl" ? cleanupCfg?.ttlMs : void 0);
+          return stateAdapter.set(scopeKey(key, partial?.flowId), value, ttl ? { ttl } : void 0);
+        },
+        async delete(key) {
+          return stateAdapter.delete(scopeKey(key, partial?.flowId));
+        }
+      };
+    } catch {
+      return defaultState;
+    }
+  })();
+  const logger2 = partial?.logger || (() => {
+    const eventManager = useEventManager();
+    return {
+      log: (level, msg, meta) => {
+        const runId = partial?.flowId || "unknown";
+        const flowName = meta?.flowName || "unknown";
+        void eventManager.publishBus({
+          type: "log",
+          runId,
+          flowName,
+          stepName: meta?.stepName,
+          stepId: meta?.stepId || meta?.stepRunId,
+          attempt: meta?.attempt,
+          data: { level, message: msg, ...meta }
+        });
+      }
+    };
+  })();
+  const baseFlowEngine = useFlow();
+  const flow = {
+    ...baseFlowEngine,
+    emit: async (trigger, payload = {}) => {
+      const enrichedPayload = {
+        ...payload,
+        flowId: payload.flowId || partial?.flowId,
+        flowName: payload.flowName || partial?.flowName,
+        stepName: payload.stepName || partial?.stepName
+      };
+      return baseFlowEngine.emit(trigger, enrichedPayload);
+    },
+    cancel: async () => {
+      if (!partial?.flowName || !partial?.flowId) {
+        throw new Error("Cannot cancel flow: flowName or flowId not available in context");
+      }
+      return baseFlowEngine.cancelFlow(partial.flowName, partial.flowId);
+    },
+    isRunning: async (flowName, runId) => {
+      const targetFlowName = flowName || partial?.flowName;
+      if (!targetFlowName) {
+        throw new Error("flowName is required to check if flow is running");
+      }
+      return baseFlowEngine.isRunning(targetFlowName, runId);
+    },
+    getRunningFlows: async (flowName) => {
+      const targetFlowName = flowName || partial?.flowName;
+      if (!targetFlowName) {
+        throw new Error("flowName is required to get running flows");
+      }
+      return baseFlowEngine.getRunningFlows(targetFlowName);
+    }
+  };
+  return {
+    jobId: partial?.jobId,
+    queue: partial?.queue,
+    flowId: partial?.flowId,
+    flowName: partial?.flowName,
+    stepName: partial?.stepName,
+    stepId: partial?.stepId,
+    attempt: partial?.attempt,
+    logger: logger2,
+    state,
+    flow,
+    trigger: partial?.trigger,
+    awaitConfig: partial?.awaitConfig
+  };
+}
+export function createJobProcessor(handler, queueName) {
+  return async function processor(job) {
+    const eventMgr = useEventManager();
+    const rc = useRuntimeConfig();
+    const autoScope = rc?.nvent?.store?.state?.autoScope || "always";
+    const providedFlow = job.data?.flowId;
+    const flowId = providedFlow || (autoScope === "always" ? randomUUID() : void 0);
+    const attempt = (job.attemptsMade || 0) + 1;
+    const maxAttempts = job.opts?.attempts || 1;
+    const isFinalAttempt = attempt >= maxAttempts;
+    const stepRunId = `${String(flowId || job.id)}__${job.name}__attempt-${attempt}`;
+    const flowName = job.data?.flowName || "unknown";
+    const registry = $useFunctionRegistry();
+    const flowRegistry = (registry?.flows || {})[flowName];
+    let stepMeta = flowRegistry?.steps?.[job.name];
+    if (!stepMeta && flowRegistry?.entry?.step === job.name) {
+      stepMeta = flowRegistry?.entry;
+    }
+    const awaitBefore = stepMeta?.awaitBefore;
+    const awaitAfter = stepMeta?.awaitAfter;
+    const isAwaitResume = job.data?.awaitResolved === true;
+    const awaitData = job.data?.awaitData;
+    if (awaitBefore && !isAwaitResume) {
+      const awaitLogger = useNventLogger("await-before");
+      awaitLogger.info("Step has awaitBefore, registering await pattern", {
+        flowName,
+        runId: flowId,
+        stepName: job.name,
+        awaitType: awaitBefore.type
+      });
+      try {
+        const { register } = useAwait();
+        const awaitResult = await register(
+          flowId || "unknown",
+          job.name,
+          flowName,
+          awaitBefore,
+          "before"
+          // Position: awaitBefore means wait before execution
+        );
+        const hookRegistry = useHookRegistry();
+        const hooks = hookRegistry.load(flowName, job.name);
+        if (hooks?.onAwaitRegister) {
+          try {
+            await hooks.onAwaitRegister(
+              awaitResult.webhookUrl || awaitResult.eventName || "",
+              job.data,
+              useRunContext({ flowId, flowName, stepName: job.name })
+            );
+          } catch (err) {
+            awaitLogger.error("onAwaitRegister hook failed", { error: err.message });
+          }
+        }
+        return {
+          awaiting: true,
+          awaitType: awaitBefore.type,
+          awaitConfig: awaitBefore
+        };
+      } catch (err) {
+        awaitLogger.error("Failed to register await pattern", {
+          error: err.message,
+          stack: err.stack
+        });
+      }
+    }
+    const ctx = buildContext({
+      jobId: job.id,
+      queue: queueName,
+      flowId,
+      flowName,
+      stepName: job.name,
+      stepId: stepRunId,
+      attempt,
+      trigger: isAwaitResume ? awaitData : void 0,
+      awaitConfig: awaitBefore || awaitAfter || void 0
+    });
+    const attemptLogger = {
+      log: (level, msg, meta) => {
+        const enriched = { ...meta || {}, stepName: job.name, attempt, stepRunId, flowName };
+        ctx.logger.log(level, msg, enriched);
+      }
+    };
+    try {
+      await eventMgr.publishBus({
+        type: "step.started",
+        runId: flowId || "unknown",
+        flowName,
+        stepName: job.name,
+        stepId: stepRunId,
+        attempt,
+        data: { jobId: job.id, name: job.name, queue: queueName }
+      });
+    } catch {
+    }
+    let result;
+    try {
+      const workerInput = job.data?.input !== void 0 ? job.data.input : job.data;
+      result = await handler(workerInput, { ...ctx, logger: attemptLogger });
+    } catch (err) {
+      logger.error(`[worker] Job failed: ${job.name} (${job.id})`, {
+        queue: queueName,
+        flowId,
+        flowName,
+        stepName: job.name,
+        error: err?.message || String(err),
+        stack: err?.stack
+      });
+      const willRetry = !isFinalAttempt;
+      if (willRetry) {
+        try {
+          await eventMgr.publishBus({
+            type: "step.retry",
+            runId: flowId || "unknown",
+            flowName,
+            stepName: job.name,
+            stepId: stepRunId,
+            attempt,
+            data: {
+              stepName: job.name,
+              queue: queueName,
+              attempt,
+              maxAttempts,
+              nextAttempt: attempt + 1,
+              error: String(err?.message || err),
+              stack: err?.stack
+            }
+          });
+        } catch {
+        }
+      } else {
+        try {
+          await eventMgr.publishBus({
+            type: "step.failed",
+            runId: flowId || "unknown",
+            flowName,
+            stepName: job.name,
+            stepId: stepRunId,
+            attempt,
+            data: {
+              error: String(err?.message || err),
+              stack: err?.stack
+            }
+          });
+        } catch {
+        }
+      }
+      throw err;
+    }
+    try {
+      const eventMgr2 = useEventManager();
+      await eventMgr2.publishBus({
+        type: "step.completed",
+        runId: flowId || "unknown",
+        flowName,
+        stepName: job.name,
+        stepId: stepRunId,
+        attempt,
+        data: { result }
+      });
+    } catch {
+    }
+    if (awaitAfter && !isAwaitResume) {
+      const awaitLogger = useNventLogger("await-after");
+      awaitLogger.info("Step has awaitAfter, registering await pattern", {
+        flowName,
+        runId: flowId,
+        stepName: job.name,
+        awaitType: awaitAfter.type
+      });
+      try {
+        const store = useStoreAdapter();
+        const { StoreSubjects } = useStreamTopics();
+        const streamName = StoreSubjects.flowRun(flowId || "unknown");
+        let _emitEvents = [];
+        if (store.stream.read) {
+          const recentEvents = await store.stream.read(streamName, { limit: 100 });
+          _emitEvents = recentEvents.filter(
+            (evt) => evt.type === "emit" && evt.stepName === job.name && evt.stepId === stepRunId
+          );
+        }
+        const { register } = useAwait();
+        const awaitResult = await register(
+          flowId || "unknown",
+          job.name,
+          flowName,
+          awaitAfter,
+          "after"
+        );
+        const hookRegistry = useHookRegistry();
+        const hooks = hookRegistry.load(flowName, job.name);
+        if (hooks?.onAwaitRegister) {
+          try {
+            await hooks.onAwaitRegister(
+              awaitResult.webhookUrl || awaitResult.eventName || "",
+              { ...job.data, result },
+              ctx
+            );
+          } catch (err) {
+            awaitLogger.error("onAwaitRegister hook failed", { error: err.message });
+          }
+        }
+      } catch (err) {
+        awaitLogger.error("Failed to register awaitAfter pattern", {
+          error: err.message,
+          stack: err.stack
+        });
+      }
+    }
+    return result;
+  };
+}

package/dist/types.d.mts

@@ -1,3 +1,3 @@
-export { default } from './module.mjs'
+export { type ModuleOptions } from '../dist/runtime/config/types.js'
 
-export { type ModuleOptions } from './module.mjs'
+export { default } from './module.mjs'

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nvent",
-  "version": "0.4.4",
-  "description": "Nuxt queue service based on Bullmq",
-  "repository": "DevJoghurt/nuxt-queue",
+  "version": "0.5.0",
+  "description": "Event-driven workflows for Nuxt",
+  "repository": "DevJoghurt/nvent",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -12,64 +12,34 @@
     }
   },
   "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "yarn dev:prepare && nuxt-module-build build",
-    "dev": "nuxi dev playground",
-    "dev:build": "nuxi build playground",
-    "dev:preview": "nuxi preview playground",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
-    "test": "vitest",
-    "lint": "eslint --ext .ts,.js,.mjs,.cjs,.vue .",
-    "cleanup": "rimraf dist*/ **/node_modules .nuxt* playground/.data",
-    "bumpp": "bumpp"
+    "build": "nuxt-module-build build",
+    "dev": "nuxt-module-build build --stub",
+    "prepack": "pnpm build"
   },
   "dependencies": {
-    "@babel/parser": "^7.28.5",
-    "@iconify-json/devicon": "^1.2.46",
-    "@iconify-json/heroicons": "1.2.3",
-    "@iconify-json/lucide": "^1.2.72",
     "@nuxt/kit": "4.2.1",
-    "@vue-flow/background": "^1.3.2",
-    "@vue-flow/controls": "^1.1.3",
-    "@vue-flow/core": "^1.47.0",
-    "@vue-flow/minimap": "^1.5.4",
-    "bullmq": "^5.63.0",
-    "chokidar": "^4.0.3",
+    "chokidar": "^5.0.0",
+    "cron": "^4.3.5",
+    "cron-parser": "^5.4.0",
     "defu": "^6.1.4",
-    "globby": "15.0.0",
-    "ioredis": "^5.8.2",
-    "json-editor-vue": "^0.18.1",
+    "fastq": "^1.19.1",
+    "globby": "16.0.0",
     "magicast": "^0.5.1",
-    "mlly": "^1.8.0",
-    "node-ts": "8.0.8",
     "nuxt": "4.2.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.0.0",
-    "pkg-types": "^2.3.0",
-    "semver": "^7.7.3",
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^3.0.1",
-    "@nuxt/eslint-config": "^1.10.0",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "4.2.1",
-    "@nuxt/test-utils": "^3.20.1",
-    "@nuxt/ui": "4.1.0",
-    "@types/node": "^24.10.0",
-    "bumpp": "10.3.1",
-    "changelogen": "^0.6.2",
-    "eslint": "^9.39.1",
-    "nuxi": "^3.30.0",
-    "nuxt-mcp": "0.2.6",
-    "rimraf": "^6.1.0",
+    "@types/node": "^24.10.1",
     "typescript": "latest",
-    "vitest": "^4.0.7",
-    "vue-tsc": "^3.1.3"
-  },
-  "packageManager": "yarn@4.10.3"
+    "vitest": "^4.0.15"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Johannes Hof
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.