nvent 0.4.3 → 0.4.5

package/dist/runtime/utils/registerAdapter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Adapter Registration Utilities
+ *
+ * Used by external adapter modules to register their adapters with nvent
+ */
+import type { QueueAdapter } from '../adapters/interfaces/queue.js';
+import type { StreamAdapter } from '../adapters/interfaces/stream.js';
+import type { StoreAdapter } from '../adapters/interfaces/store.js';
+/**
+ * Register a queue adapter
+ *
+ * Called by external adapter modules (e.g., @nvent/adapter-queue-redis)
+ * to register their adapter implementation.
+ *
+ * @param name - Adapter name (e.g., 'redis', 'postgres', 'rabbitmq')
+ * @param adapter - QueueAdapter implementation
+ *
+ * @example
+ * import { registerQueueAdapter } from '#imports'
+ * import { RedisQueueAdapter } from './adapter'
+ *
+ * const adapter = new RedisQueueAdapter({ connection })
+ * registerQueueAdapter('redis', adapter)
+ */
+export declare function registerQueueAdapter(name: string, adapter: QueueAdapter): void;
+/**
+ * Register a stream adapter
+ *
+ * Called by external adapter modules (e.g., @nvent/adapter-stream-redis)
+ * to register their adapter implementation.
+ *
+ * @param name - Adapter name (e.g., 'redis', 'rabbitmq', 'kafka')
+ * @param adapter - StreamAdapter implementation
+ *
+ * @example
+ * import { registerStreamAdapter } from '#imports'
+ * import { RedisStreamAdapter } from './adapter'
+ *
+ * const adapter = new RedisStreamAdapter({ connection })
+ * registerStreamAdapter('redis', adapter)
+ */
+export declare function registerStreamAdapter(name: string, adapter: StreamAdapter): void;
+/**
+ * Register a store adapter
+ *
+ * Called by external adapter modules (e.g., @nvent/adapter-store-redis)
+ * to register their adapter implementation.
+ *
+ * @param name - Adapter name (e.g., 'redis', 'postgres')
+ * @param adapter - StoreAdapter implementation
+ *
+ * @example
+ * import { registerStoreAdapter } from '#imports'
+ * import { RedisStoreAdapter } from './adapter'
+ *
+ * const adapter = new RedisStoreAdapter({ connection })
+ * registerStoreAdapter('redis', adapter)
+ */
+export declare function registerStoreAdapter(name: string, adapter: StoreAdapter): void;

package/dist/runtime/utils/registerAdapter.js

@@ -0,0 +1,13 @@
+import { useAdapterRegistry } from "../adapters/registry.js";
+export function registerQueueAdapter(name, adapter) {
+  const registry = useAdapterRegistry();
+  registry.registerQueue(name, adapter);
+}
+export function registerStreamAdapter(name, adapter) {
+  const registry = useAdapterRegistry();
+  registry.registerStream(name, adapter);
+}
+export function registerStoreAdapter(name, adapter) {
+  const registry = useAdapterRegistry();
+  registry.registerStore(name, adapter);
+}

package/dist/runtime/utils/useFlowEngine.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Flow Engine for starting and emitting flow events
+ */
+export declare const useFlowEngine: () => {
+    startFlow: (flowName: string, payload?: any) => Promise<{
+        id: any;
+        queue: any;
+        step: any;
+        flowId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    emit: (trigger: string, payload?: any) => Promise<never[]>;
+    cancelFlow: (flowName: string, runId: string) => Promise<{
+        success: boolean;
+        runId: string;
+        flowName: string;
+    }>;
+    isRunning: (flowName: string, runId?: string) => Promise<any>;
+    getRunningFlows: (flowName: string) => Promise<any>;
+};

package/dist/runtime/utils/useFlowEngine.js

@@ -0,0 +1,108 @@
+import { $useQueueRegistry, useQueueAdapter, useEventManager, useNventLogger, useStoreAdapter, useStreamTopics } from "#imports";
+import { randomUUID } from "node:crypto";
+const logger = useNventLogger("flow-engine");
+export const useFlowEngine = () => {
+  const registry = $useQueueRegistry();
+  const queueAdapter = useQueueAdapter();
+  const eventsManager = useEventManager();
+  const startFlow = async (flowName, payload = {}) => {
+    const flow = registry?.flows?.[flowName];
+    if (!flow || !flow.entry) throw new Error("Flow not found");
+    const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
+    const entryWorker = registry?.workers?.find(
+      (w) => w?.flow?.step === flow.entry.step && w?.queue?.name === queueName
+    );
+    const opts = entryWorker?.queue?.defaultJobOptions || {};
+    const flowId = randomUUID();
+    const id = await queueAdapter.enqueue(queueName, { name: flow.entry.step, data: { ...payload, flowId, flowName }, opts });
+    try {
+      await eventsManager.publishBus({ type: "flow.start", runId: flowId, flowName, data: { input: payload } });
+    } catch {
+    }
+    return { id, queue: queueName, step: flow.entry.step, flowId };
+  };
+  const emit = async (trigger, payload = {}) => {
+    const flowId = payload?.flowId;
+    const flowName = payload?.flowName || "unknown";
+    if (!flowId) {
+      logger.warn("emit called without flowId, trigger may not work", { trigger });
+    }
+    const { flowId: _, flowName: __, ...actualPayload } = payload;
+    try {
+      await eventsManager.publishBus({
+        type: "emit",
+        runId: flowId || "unknown",
+        flowName,
+        data: {
+          name: trigger,
+          payload: actualPayload
+          // Store actual payload separately
+        }
+      });
+    } catch (err) {
+      logger.error("Failed to emit trigger event", { trigger, error: err });
+    }
+    return [];
+  };
+  const cancelFlow = async (flowName, runId) => {
+    try {
+      await eventsManager.publishBus({
+        type: "flow.cancel",
+        runId,
+        flowName,
+        data: {
+          canceledAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      logger.info("Flow canceled", { flowName, runId });
+      return { success: true, runId, flowName };
+    } catch (err) {
+      logger.error("Failed to cancel flow", { flowName, runId, error: err });
+      throw err;
+    }
+  };
+  const isRunning = async (flowName, runId) => {
+    try {
+      const store = useStoreAdapter();
+      const { SubjectPatterns } = useStreamTopics();
+      if (!store.indexRead) {
+        return false;
+      }
+      if (runId) {
+        const runIndexKey2 = SubjectPatterns.flowRunIndex(flowName);
+        const entries2 = await store.indexRead(runIndexKey2, { limit: 1e3 });
+        const run = entries2.find((e) => e.id === runId);
+        return run?.metadata?.status === "running";
+      }
+      const runIndexKey = SubjectPatterns.flowRunIndex(flowName);
+      const entries = await store.indexRead(runIndexKey, { limit: 1e3 });
+      return entries.some((e) => e.metadata?.status === "running");
+    } catch (err) {
+      logger.error("[isRunning] Error checking flow status:", err);
+      return false;
+    }
+  };
+  const getRunningFlows = async (flowName) => {
+    try {
+      const store = useStoreAdapter();
+      const { SubjectPatterns } = useStreamTopics();
+      if (!store.indexRead) {
+        return [];
+      }
+      const runIndexKey = SubjectPatterns.flowRunIndex(flowName);
+      const entries = await store.indexRead(runIndexKey, { limit: 1e3 });
+      return entries.filter((e) => e.metadata?.status === "running").map((e) => ({
+        id: e.id,
+        flowName,
+        status: e.metadata?.status,
+        startedAt: e.metadata?.startedAt,
+        stepCount: e.metadata?.stepCount || 0,
+        completedSteps: e.metadata?.completedSteps || 0
+      }));
+    } catch (err) {
+      logger.error("[getRunningFlows] Error getting running flows:", err);
+      return [];
+    }
+  };
+  return { startFlow, emit, cancelFlow, isRunning, getRunningFlows };
+};

package/dist/runtime/{server-utils/utils → utils}/useNventLogger.js

@@ -9,7 +9,7 @@ const LOG_LEVELS = {
 const loggerCache = /* @__PURE__ */ new Map();
 export function useNventLogger(scope) {
   const rc = useRuntimeConfig();
-  const debugConfig = rc?.queue?.debug;
+  const debugConfig = rc?.nvent?.debug;
   const configLevel = debugConfig?.level || process.env.NQ_DEBUG_LEVEL || "info";
   const globalLevelNum = configLevel === "silent" ? Infinity : LOG_LEVELS[configLevel] ?? LOG_LEVELS.info;
   const scopeKey = scope.replace(/[^a-z0-9]/gi, "_").toLowerCase();
@@ -48,7 +48,7 @@ export function useNventLogger(scope) {
 }
 export function isDebugEnabled() {
   const rc = useRuntimeConfig();
-  const debugConfig = rc?.queue?.debug;
+  const debugConfig = rc?.nvent?.debug;
   const level = debugConfig?.level || process.env.NQ_DEBUG_LEVEL;
   return level === "debug" || Object.keys(debugConfig || {}).some((key) => key !== "level");
 }

package/dist/runtime/utils/useStreamTopics.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Stream topic naming utilities
+ *
+ * Standardized topic patterns for StreamAdapter pub/sub
+ * These match the topics published by StoreAdapter mutations and wiring coordinators
+ */
+/**
+ * Get topic for store append events
+ * Pattern: store:append:{subject}
+ * Published when: StoreAdapter.append() adds an event to a subject
+ * Used by: StreamCoordinator (store-sync channel)
+ */
+declare function getStoreAppendTopic(subject: string): string;
+/**
+ * Get topic for store save events
+ * Pattern: store:save:{collection}
+ * Published when: StoreAdapter.save() creates/updates a document
+ */
+declare function getStoreSaveTopic(collection: string): string;
+/**
+ * Get topic for store delete events
+ * Pattern: store:delete:{collection}
+ * Published when: StoreAdapter.delete() removes a document
+ */
+declare function getStoreDeleteTopic(collection: string): string;
+/**
+ * Get topic for KV store events
+ * Pattern: store:kv:{key}
+ * Published when: StoreAdapter.kvSet() updates a key
+ */
+declare function getStoreKvTopic(key: string): string;
+/**
+ * Get topic for flow orchestration events
+ * Pattern: flow:event:{runId}
+ * Published when: StreamCoordinator flow-events channel publishes flow lifecycle events
+ * Used by: Future trigger system for cross-instance coordination
+ */
+declare function getFlowEventTopic(runId: string): string;
+/**
+ * Get topic for client messages (WebSocket/SSE)
+ * Pattern: client:flow:{runId}
+ * Published when: StreamCoordinator client-messages channel publishes UI updates
+ * Used by: WebSocket handler for real-time UI updates
+ */
+declare function getClientFlowTopic(runId: string): string;
+export declare function useStreamTopics(): {
+    getStoreAppendTopic: typeof getStoreAppendTopic;
+    getStoreSaveTopic: typeof getStoreSaveTopic;
+    getStoreDeleteTopic: typeof getStoreDeleteTopic;
+    getStoreKvTopic: typeof getStoreKvTopic;
+    getFlowEventTopic: typeof getFlowEventTopic;
+    getClientFlowTopic: typeof getClientFlowTopic;
+    SubjectPatterns: {
+        /**
+         * Flow run event stream subject
+         */
+        readonly flowRun: (runId: string) => string;
+        /**
+         * Flow run index (sorted set of runs by flow name)
+         */
+        readonly flowRunIndex: (flowName: string) => string;
+        /**
+         * Flow definition subject
+         */
+        readonly flowDefinition: (flowName: string) => string;
+        /**
+         * Worker heartbeat subject
+         */
+        readonly workerHeartbeat: (workerId: string) => string;
+    };
+};
+export {};

package/dist/runtime/utils/useStreamTopics.js

@@ -0,0 +1,47 @@
+function getStoreAppendTopic(subject) {
+  return `store:append:${subject}`;
+}
+function getStoreSaveTopic(collection) {
+  return `store:save:${collection}`;
+}
+function getStoreDeleteTopic(collection) {
+  return `store:delete:${collection}`;
+}
+function getStoreKvTopic(key) {
+  return `store:kv:${key}`;
+}
+function getFlowEventTopic(runId) {
+  return `flow:event:${runId}`;
+}
+function getClientFlowTopic(runId) {
+  return `client:flow:${runId}`;
+}
+const SubjectPatterns = {
+  /**
+   * Flow run event stream subject
+   */
+  flowRun: (runId) => `nq:flow:${runId}`,
+  /**
+   * Flow run index (sorted set of runs by flow name)
+   */
+  flowRunIndex: (flowName) => `nq:flows:${flowName}`,
+  /**
+   * Flow definition subject
+   */
+  flowDefinition: (flowName) => `flow-def:${flowName}`,
+  /**
+   * Worker heartbeat subject
+   */
+  workerHeartbeat: (workerId) => `worker:${workerId}`
+};
+export function useStreamTopics() {
+  return {
+    getStoreAppendTopic,
+    getStoreSaveTopic,
+    getStoreDeleteTopic,
+    getStoreKvTopic,
+    getFlowEventTopic,
+    getClientFlowTopic,
+    SubjectPatterns
+  };
+}

package/dist/runtime/{server-utils/worker/runner/node.d.ts → worker/node/runner.d.ts}

@@ -1,5 +1,17 @@
-import type { Job as BullJob } from 'bullmq';
 import { useFlowEngine } 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;
 }
@@ -24,4 +36,8 @@ export interface RunContext {
 }
 export declare function buildContext(partial?: Partial<RunContext>): RunContext;
 export type NodeHandler = (input: any, ctx: RunContext) => Promise<any>;
-export declare function createBullMQProcessor(handler: NodeHandler, queueName: string): (job: BullJob) => 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/{server-utils/worker/runner/node.js → worker/node/runner.js}

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { getStateProvider } from "../../state/stateFactory.js";
-import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useNventLogger } from "#imports";
+import { useStateAdapter } from "../../utils/adapters.js";
+import { useRuntimeConfig, useFlowEngine, useEventManager, useNventLogger } from "#imports";
+const logger = useNventLogger("node-runner");
 const defaultState = {
   async get() {
     return null;
@@ -17,31 +18,40 @@ function scopeKey(baseKey, flowId) {
 export function buildContext(partial) {
   const state = partial?.state || (() => {
     try {
-      const state2 = getStateProvider();
+      const stateAdapter = useStateAdapter();
       const rc = useRuntimeConfig();
-      const cleanupCfg = rc?.queue?.state?.cleanup || { strategy: "never" };
+      const cleanupCfg = rc?.nvent?.state?.cleanup || { strategy: "never" };
       return {
         async get(key) {
-          return state2.get(scopeKey(key, partial?.flowId));
+          return stateAdapter.get(scopeKey(key, partial?.flowId));
         },
         async set(key, value, opts) {
           const ttl = opts?.ttl ?? (cleanupCfg?.strategy === "ttl" ? cleanupCfg?.ttlMs : void 0);
-          return state2.set(scopeKey(key, partial?.flowId), value, ttl ? { ttl } : void 0);
+          return stateAdapter.set(scopeKey(key, partial?.flowId), value, ttl ? { ttl } : void 0);
         },
         async delete(key) {
-          return state2.delete(scopeKey(key, partial?.flowId));
+          return stateAdapter.delete(scopeKey(key, partial?.flowId));
         }
       };
     } catch {
       return defaultState;
     }
   })();
-  const logger = partial?.logger || (() => {
-    const logs = useLogs();
+  const logger2 = partial?.logger || (() => {
+    const eventManager = useEventManager();
     return {
       log: (level, msg, meta) => {
-        const mergedMeta = { ...meta || {} };
-        void logs.publishLog(level, msg, mergedMeta, { queue: partial?.queue, jobId: partial?.jobId, flowId: partial?.flowId });
+        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 }
+        });
       }
     };
   })();
@@ -55,6 +65,26 @@ export function buildContext(partial) {
         flowName: payload.flowName || partial?.flowName
       };
       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 {
@@ -65,13 +95,12 @@ export function buildContext(partial) {
     stepName: partial?.stepName,
     stepId: partial?.stepId,
     attempt: partial?.attempt,
-    logger,
+    logger: logger2,
     state,
     flow
   };
 }
-export function createBullMQProcessor(handler, queueName) {
-  const logger = useNventLogger("node-runner");
+export function createJobProcessor(handler, queueName) {
   return async function processor(job) {
     if (job.data?.__scheduledFlowStart) {
       const { __flowName, __flowInput } = job.data;
@@ -90,7 +119,7 @@ export function createBullMQProcessor(handler, queueName) {
     }
     const eventMgr = useEventManager();
     const rc = useRuntimeConfig();
-    const autoScope = rc?.queue?.state?.autoScope || "always";
+    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;
@@ -166,8 +195,6 @@ export function createBullMQProcessor(handler, queueName) {
             data: {
               stepName: job.name,
               queue: queueName,
-              error: String(err?.message || err),
-              stack: err?.stack,
               attempt,
               maxAttempts,
               nextAttempt: attempt + 1

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.3",
-  "description": "Nuxt queue service based on Bullmq",
-  "repository": "DevJoghurt/nuxt-queue",
+  "version": "0.4.5",
+  "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",
+    "test": "vitest"
   },
   "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",
+    "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"
   },
   "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.10"
+  }
 }

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.