nvent 0.4.1 → 0.4.2

package/dist/module.mjs

@@ -840,7 +840,7 @@ const module = defineNuxtModule({
       nuxt.options.css = nuxt.options.css || [];
       nuxt.options.css.push(resolve("./runtime/app/assets/vueflow.css"));
       addPlugin({
-        src: resolve("./runtime/app/plugins/vueflow.client.ts"),
+        src: resolve("./runtime/app/plugins/vueflow.client"),
         mode: "client"
       });
       addComponentsDir({
@@ -958,10 +958,6 @@ const module = defineNuxtModule({
         name: "useEventStore",
         from: resolve("./runtime/server-utils/utils/useEventStore")
       },
-      {
-        name: "useServerLogger",
-        from: resolve("./runtime/server-utils/utils/useServerLogger")
-      },
       {
         name: "useLogs",
         from: resolve("./runtime/server-utils/utils/useLogs")
@@ -970,7 +966,14 @@ const module = defineNuxtModule({
         name: "useEventManager",
         from: resolve("./runtime/server-utils/utils/useEventManager")
       },
-      { name: "usePeerManager", from: resolve("./runtime/server-utils/utils/wsPeerManager") }
+      {
+        name: "usePeerManager",
+        from: resolve("./runtime/server-utils/utils/wsPeerManager")
+      },
+      {
+        name: "useNventLogger",
+        from: resolve("./runtime/server-utils/utils/useNventLogger")
+      }
     ]);
     const refreshRegistry = async (reason, changedPath) => {
       const queuesRel = config.dir || "queues";

package/dist/runtime/server/api/_flows/[name]/runs.get.js

@@ -1,6 +1,6 @@
-import { defineEventHandler, getRouterParam, getQuery, useEventStore, useServerLogger } from "#imports";
-const logger = useServerLogger("api-flows-runs");
+import { defineEventHandler, getRouterParam, getQuery, useEventStore, useNventLogger } from "#imports";
 export default defineEventHandler(async (event) => {
+  const logger = useNventLogger("api-flows-runs");
   const flowName = getRouterParam(event, "name");
   const query = getQuery(event);
   const limit = Math.min(Number.parseInt(query.limit) || 50, 100);

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

@@ -2,9 +2,8 @@ import {
   defineWebSocketHandler,
   useEventStore,
   usePeerManager,
-  useServerLogger
+  useNventLogger
 } from "#imports";
-const logger = useServerLogger("api-flows-ws");
 const peerContexts = /* @__PURE__ */ new WeakMap();
 function safeSend(peer, data) {
   try {
@@ -16,6 +15,7 @@ function safeSend(peer, data) {
 }
 export default defineWebSocketHandler({
   open(peer) {
+    const logger = useNventLogger("api-flows-ws");
     logger.info("[ws] client connected:", { peerId: peer.id });
     const { registerWsPeer } = usePeerManager();
     registerWsPeer(peer);
@@ -28,6 +28,7 @@ export default defineWebSocketHandler({
     });
   },
   async message(peer, message) {
+    const logger = useNventLogger("api-flows-ws");
     const context = peerContexts.get(peer);
     if (!context) {
       logger.error("[ws] no context for peer:", { peerId: peer.id });
@@ -144,6 +145,7 @@ export default defineWebSocketHandler({
     }
   },
   close(peer, event) {
+    const logger = useNventLogger("api-flows-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 });
@@ -166,6 +168,7 @@ export default defineWebSocketHandler({
     }
   },
   error(peer, error) {
+    const logger = useNventLogger("api-flows-ws");
     logger.error("[ws] error for peer:", { peerId: peer.id, error });
     const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);

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

@@ -1,7 +1,7 @@
-import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
-const logger = useServerLogger("api-queues-index");
+import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export default defineEventHandler(async () => {
   const rc = useRuntimeConfig();
+  const logger = useNventLogger("api-queues-index");
   const cfgQueues = rc?.queue?.queues || {};
   const registry = $useQueueRegistry();
   const queue = useQueue();

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

@@ -2,10 +2,9 @@ import {
   defineWebSocketHandler,
   useQueue,
   usePeerManager,
-  useServerLogger
+  useNventLogger
 } from "#imports";
 const peerContexts = /* @__PURE__ */ new WeakMap();
-const logger = useServerLogger("api-queues-ws");
 function safeSend(peer, data) {
   try {
     peer.send(JSON.stringify(data));
@@ -16,6 +15,7 @@ function safeSend(peer, data) {
 }
 export default defineWebSocketHandler({
   open(peer) {
+    const logger = useNventLogger("api-queues-ws");
     logger.info("[ws:queues] client connected:", peer.id);
     const { registerWsPeer } = usePeerManager();
     registerWsPeer(peer);
@@ -28,6 +28,7 @@ export default defineWebSocketHandler({
     });
   },
   async message(peer, message) {
+    const logger = useNventLogger("api-queues-ws");
     const context = peerContexts.get(peer);
     if (!context) {
       logger.error("[ws:queues] no context for peer:", peer.id);
@@ -154,6 +155,7 @@ export default defineWebSocketHandler({
     }
   },
   close(peer, event) {
+    const logger = useNventLogger("api-queues-ws");
     const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
     if (!isNormalClosure) {
       logger.info("[ws:queues] client disconnected:", {
@@ -180,6 +182,7 @@ export default defineWebSocketHandler({
     }
   },
   error(peer, error) {
+    const logger = useNventLogger("api-queues-ws");
     logger.error("[ws:queues] error for peer:", {
       peerId: peer.id,
       error

package/dist/runtime/server/plugins/00.ws-lifecycle.js

@@ -1,10 +1,10 @@
 import {
   defineNitroPlugin,
-  useServerLogger,
+  useNventLogger,
   usePeerManager
 } from "#imports";
-const logger = useServerLogger("plugin-ws-lifecycle");
 export default defineNitroPlugin((nitroApp) => {
+  const logger = useNventLogger("plugin-ws-lifecycle");
   logger.info("[ws-lifecycle] WebSocket lifecycle plugin initialized");
   const {
     getActivePeers,

package/dist/runtime/server/plugins/flow-management.js

@@ -1,6 +1,6 @@
-import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
-const logger = useServerLogger("plugin-flow-management");
+import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export default defineNitroPlugin((nitro) => {
+  const logger = useNventLogger("plugin-flow-management");
   const { onType, publishBus } = useEventManager();
   const registry = $useQueueRegistry();
   const flowIdToName = /* @__PURE__ */ new Map();

package/dist/runtime/server/plugins/queue-management.js

@@ -1,8 +1,8 @@
-import { defineNitroPlugin, useServerLogger } from "#imports";
+import { defineNitroPlugin, useNventLogger } from "#imports";
 import { BullMQProvider } from "../../server-utils/queue/adapters/bullmq.js";
 import { setQueueProvider, getQueueProvider } from "../../server-utils/queue/queueFactory.js";
-const logger = useServerLogger("plugin-queue-management");
 export default defineNitroPlugin(async (nitroApp) => {
+  const logger = useNventLogger("plugin-queue-management");
   try {
     const existingProvider = getQueueProvider();
     if (existingProvider) {

package/dist/runtime/server/plugins/state-cleanup.js

@@ -1,7 +1,7 @@
-import { useServerLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
+import { useNventLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
 import { getStateProvider } from "../../server-utils/state/stateFactory.js";
-const logger = useServerLogger("plugin-state-cleanup");
 export default defineNitroPlugin(() => {
+  const logger = useNventLogger("plugin-state-cleanup");
   const rc = useRuntimeConfig();
   const cleanup = rc?.queue?.state?.cleanup || { strategy: "never" };
   if (cleanup.strategy === "never" || cleanup.strategy === "ttl") {

package/dist/runtime/server-utils/events/adapters/redis/redisAdapter.js

@@ -1,12 +1,12 @@
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 import IORedis from "ioredis";
 import { RedisPubSubGateway } from "./redisPubSubGateway.js";
-const logger = useServerLogger("redis-adapter");
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 export function createRedisAdapter() {
   const rc = useRuntimeConfig();
+  const logger = useNventLogger("redis-adapter");
   const conn = rc?.queue?.eventStore?.redis || {};
   const rsOpts = rc?.queue?.eventStore?.options?.redisStreams || {};
   const redis = new IORedis({

package/dist/runtime/server-utils/events/adapters/redis/redisPubSubGateway.d.ts

@@ -7,6 +7,7 @@ export declare class RedisPubSubGateway {
     private subscriber;
     private channelSubscribers;
     private initialized;
+    private logger;
     constructor(subscriber: IORedis);
     private initialize;
     /**

package/dist/runtime/server-utils/events/adapters/redis/redisPubSubGateway.js

@@ -1,11 +1,11 @@
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("redis-adapter");
+import { useNventLogger } from "#imports";
 export class RedisPubSubGateway {
   constructor(subscriber) {
     this.subscriber = subscriber;
   }
   channelSubscribers = /* @__PURE__ */ new Map();
   initialized = false;
+  logger = useNventLogger("redis-pubsub-gateway");
   initialize() {
     if (this.initialized) return;
     this.initialized = true;
@@ -17,7 +17,7 @@ export class RedisPubSubGateway {
           handler(messageId);
         } catch (err) {
           if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.error("[redis-pubsub-gateway] Handler error:", err);
+            this.logger.error("[redis-pubsub-gateway] Handler error:", err);
           }
         }
       }
@@ -33,7 +33,7 @@ export class RedisPubSubGateway {
       this.channelSubscribers.set(channel, /* @__PURE__ */ new Set());
       await this.subscriber.subscribe(channel);
       if (process.env.NQ_DEBUG_EVENTS === "1") {
-        logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
+        this.logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
       }
     }
     this.channelSubscribers.get(channel).add(handler);
@@ -46,7 +46,7 @@ export class RedisPubSubGateway {
           this.subscriber.unsubscribe(channel).catch(() => {
           });
           if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
+            this.logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
           }
         }
       }

package/dist/runtime/server-utils/events/eventStoreFactory.js

@@ -1,13 +1,13 @@
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 import { getStreamNames } from "./streamNames.js";
 import { createRedisAdapter } from "./adapters/redis/redisAdapter.js";
 import { createMemoryAdapter } from "./adapters/memoryAdapter.js";
 import { createFileAdapter } from "./adapters/fileAdapter.js";
 import { createWiringRegistry } from "./wiring/registry.js";
-const logger = useServerLogger("event-store-factory");
 let cachedFactory = null;
 export function getEventStoreFactory() {
   if (cachedFactory) return cachedFactory;
+  const logger = useNventLogger("event-store-factory");
   const rc = useRuntimeConfig();
   const adapter = rc?.queue?.eventStore?.adapter || "memory";
   let adapterInstance;

package/dist/runtime/server-utils/events/wiring/flowWiring.js

@@ -1,6 +1,5 @@
 import { getEventBus } from "../eventBus.js";
-import { useServerLogger, useEventStore, $useAnalyzedFlows, $useQueueRegistry, useQueue } from "#imports";
-const logger = useServerLogger("flow-wiring");
+import { useEventStore, $useAnalyzedFlows, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   if (!step.subscribes || step.subscribes.length === 0) {
     return true;
@@ -15,6 +14,7 @@ export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   });
 }
 async function checkAndTriggerPendingSteps(flowName, runId, store) {
+  const logger = useNventLogger("flow-wiring");
   try {
     const analyzedFlows = $useAnalyzedFlows();
     const registry = $useQueueRegistry();
@@ -177,6 +177,7 @@ export function createFlowWiring(deps) {
   const unsubs = [];
   let wired = false;
   const indexFlowRun = async (flowName, flowId, timestamp, metadata) => {
+    const logger = useNventLogger("flow-wiring");
     try {
       const store = useEventStore();
       const names = store.names();
@@ -190,6 +191,7 @@ export function createFlowWiring(deps) {
   function start() {
     if (wired) return;
     wired = true;
+    const logger = useNventLogger("flow-wiring");
     const store = useEventStore();
     const names = store.names();
     const handlePersistence = async (e) => {
@@ -393,6 +395,7 @@ export function createFlowWiring(deps) {
     }
   }
   function stop() {
+    const logger = useNventLogger("flow-wiring");
     for (const u of unsubs.splice(0)) {
       try {
         u();

package/dist/runtime/server-utils/queue/adapters/bullmq.d.ts

@@ -1,6 +1,7 @@
 import type { QueueProvider, JobInput, Job, JobsQuery, ScheduleOptions, QueueEvent, JobCounts } from '../types.js';
 export declare class BullMQProvider implements QueueProvider {
     private queues;
+    private logger;
     init(): Promise<void>;
     private ensureQueue;
     enqueue(queueName: string, job: JobInput): Promise<string>;

package/dist/runtime/server-utils/queue/adapters/bullmq.js

@@ -1,9 +1,9 @@
 import { Queue, QueueEvents } from "bullmq";
 import defu from "defu";
-import { useServerLogger, useRuntimeConfig, $useQueueRegistry, useEventManager } from "#imports";
-const logger = useServerLogger("bullmq-adapter");
+import { useRuntimeConfig, $useQueueRegistry, useEventManager, useNventLogger } from "#imports";
 export class BullMQProvider {
   queues = /* @__PURE__ */ new Map();
+  logger = useNventLogger("bullmq-adapter");
   async init() {
   }
   ensureQueue(name) {
@@ -132,14 +132,14 @@ export class BullMQProvider {
       closePromises.push(
         queue.close().catch((err) => {
           if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-            logger.warn("Error closing queue", { queueName, error: err });
+            this.logger.warn("Error closing queue", { queueName, error: err });
           }
         })
       );
       closePromises.push(
         events.close().catch((err) => {
           if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-            logger.warn("Error closing events for queue", { queueName, error: err });
+            this.logger.warn("Error closing events for queue", { queueName, error: err });
           }
         })
       );

package/dist/runtime/server-utils/utils/useEventManager.js

@@ -1,8 +1,8 @@
 import { getEventBus } from "../events/eventBus.js";
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("event-manager");
+import { useNventLogger } from "#imports";
 export function useEventManager() {
   if (globalThis.__nq_event_manager) return globalThis.__nq_event_manager;
+  const logger = useNventLogger("event-manager");
   const bus = getEventBus();
   const publishBus = async (evt) => {
     const rec = {

package/dist/runtime/server-utils/utils/useEventStore.js

@@ -1,7 +1,7 @@
 import { getEventStoreFactory } from "../events/eventStoreFactory.js";
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("event-store");
+import { useNventLogger } from "#imports";
 export function useEventStore() {
+  const logger = useNventLogger("event-store");
   const factory = getEventStoreFactory();
   async function read(stream, opts) {
     return await factory.adapter.read(stream, opts);

package/dist/runtime/server-utils/utils/useFlowEngine.js

@@ -1,10 +1,10 @@
-import { $useQueueRegistry, useQueue, useEventManager, useServerLogger } from "#imports";
+import { $useQueueRegistry, useQueue, useEventManager, useNventLogger } from "#imports";
 import { randomUUID } from "node:crypto";
-const logger = useServerLogger("flow-engine");
 export const useFlowEngine = () => {
   const registry = $useQueueRegistry();
   const queueAdapter = useQueue();
   const eventsManager = useEventManager();
+  const logger = useNventLogger("flow-engine");
   const startFlow = async (flowName, payload = {}) => {
     const flow = registry?.flows?.[flowName];
     if (!flow || !flow.entry) throw new Error("Flow not found");

package/dist/runtime/server-utils/utils/{useServerLogger.d.ts → useNventLogger.d.ts}

@@ -1,6 +1,6 @@
 import { type ConsolaInstance } from 'consola';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface ServerLogger {
+export interface NventLogger {
     debug: (message: string, context?: any) => void;
     info: (message: string, context?: any) => void;
     warn: (message: string, context?: any) => void;
@@ -20,11 +20,11 @@ export interface ServerLogger {
  * - NQ_DEBUG_<SCOPE>: environment variable for scope (e.g., NQ_DEBUG_FLOW_WIRING=1)
  *
  * @param scope - Logger scope/namespace (e.g., 'flow-wiring', 'event-manager')
- * @returns ServerLogger instance with scoped logging methods
+ * @returns NventLogger instance with scoped logging methods
  *
  * @example
  * ```ts
- * const logger = useServerLogger('flow-wiring')
+ * const logger = useNventLogger('flow-wiring')
  * logger.debug('Step triggered', { stepName: 'process', runId: '123' })
  * logger.info('Flow completed', { flowName: 'example' })
  * logger.warn('Retry attempt', { attempt: 3 })
@@ -35,7 +35,7 @@ export interface ServerLogger {
  * logger.consola.box('🚀 Flow Started')
  * ```
  */
-export declare function useServerLogger(scope: string): ServerLogger;
+export declare function useNventLogger(scope: string): NventLogger;
 /**
  * Type guard to check if debug logging is enabled for any scope
  */

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

@@ -7,7 +7,7 @@ const LOG_LEVELS = {
   error: 3
 };
 const loggerCache = /* @__PURE__ */ new Map();
-export function useServerLogger(scope) {
+export function useNventLogger(scope) {
   const rc = useRuntimeConfig();
   const debugConfig = rc?.queue?.debug;
   const configLevel = debugConfig?.level || process.env.NQ_DEBUG_LEVEL || "info";

package/dist/runtime/server-utils/worker/adapter.js

@@ -1,9 +1,9 @@
 import { Worker } from "bullmq";
 import { createBullMQProcessor } from "./runner/node.js";
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 const registeredWorkers = /* @__PURE__ */ new Map();
-const logger = useServerLogger("worker-adapter");
 export async function closeAllWorkers() {
+  const logger = useNventLogger("worker-adapter");
   const closePromises = [];
   for (const [queueName, info] of registeredWorkers.entries()) {
     closePromises.push(
@@ -20,6 +20,7 @@ export async function closeAllWorkers() {
 }
 export async function registerTsWorker(queueName, jobName, handler, opts) {
   let info = registeredWorkers.get(queueName);
+  const logger = useNventLogger("worker-adapter");
   if (info) {
     logger.info(`[registerTsWorker] Adding handler for job "${jobName}" to existing worker for queue "${queueName}"`);
     info.handlers.set(jobName, handler);

package/dist/runtime/server-utils/worker/runner/node.js

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { getStateProvider } from "../../state/stateFactory.js";
-import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useServerLogger } from "#imports";
-const logger = useServerLogger("node-runner");
+import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useNventLogger } from "#imports";
 const defaultState = {
   async get() {
     return null;
@@ -37,7 +36,7 @@ export function buildContext(partial) {
       return defaultState;
     }
   })();
-  const logger2 = partial?.logger || (() => {
+  const logger = partial?.logger || (() => {
     const logs = useLogs();
     return {
       log: (level, msg, meta) => {
@@ -66,12 +65,13 @@ export function buildContext(partial) {
     stepName: partial?.stepName,
     stepId: partial?.stepId,
     attempt: partial?.attempt,
-    logger: logger2,
+    logger,
     state,
     flow
   };
 }
 export function createBullMQProcessor(handler, queueName) {
+  const logger = useNventLogger("node-runner");
   return async function processor(job) {
     if (job.data?.__scheduledFlowStart) {
       const { __flowName, __flowInput } = job.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Nuxt queue service based on Bullmq",
   "repository": "DevJoghurt/nuxt-queue",
   "license": "MIT",