nvent 0.4.4 → 0.5.0

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

@@ -1,65 +0,0 @@
-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();
-  const getFlowNameById = (id) => {
-    const cached = flowIdToName.get(id);
-    if (cached) return cached;
-    try {
-      const flows = registry?.flows || {};
-      for (const [name, def] of Object.entries(flows)) {
-        if (def?.id === id) {
-          flowIdToName.set(id, name);
-          return name;
-        }
-      }
-    } catch {
-    }
-    return void 0;
-  };
-  const unsubscribes = [];
-  unsubscribes.push(onType("emit", async (e) => {
-    if (e.runId) return;
-    const emitName = e.data?.name;
-    if (!emitName) return;
-    const triggers = Object.keys(registry?.eventIndex || {});
-    if (!triggers.includes(emitName)) return;
-    const { enqueue } = useQueue();
-    const targets = (registry?.eventIndex)[emitName] || [];
-    for (const t of targets) {
-      const payload = { ...e.data };
-      try {
-        const id = await enqueue(t.queue, { name: t.step, data: payload });
-        try {
-          const targetFlowName = getFlowNameById(String(t.flowId)) || String(t.flowId);
-          const newRunId = String(id);
-          await publishBus({
-            type: "flow.start",
-            runId: newRunId,
-            flowName: targetFlowName,
-            data: { input: payload }
-          });
-          if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.info("[flow-lifecycle] started new flow:", {
-              flowName: targetFlowName,
-              runId: newRunId,
-              entryStep: t.step
-            });
-          }
-        } catch {
-        }
-      } catch (err) {
-        logger.warn("[flow-lifecycle] failed to start flow:", {
-          step: t.step,
-          error: err?.message
-        });
-      }
-    }
-  }));
-  nitro.hooks.hook("close", () => {
-    unsubscribes.forEach((fn) => fn());
-    flowIdToName.clear();
-  });
-});

package/dist/runtime/server/plugins/queue-management.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

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

@@ -1,27 +0,0 @@
-import { defineNitroPlugin, useNventLogger } from "#imports";
-import { BullMQProvider } from "../../server-utils/queue/adapters/bullmq.js";
-import { setQueueProvider, getQueueProvider } from "../../server-utils/queue/queueFactory.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  const logger = useNventLogger("plugin-queue-management");
-  try {
-    const existingProvider = getQueueProvider();
-    if (existingProvider) {
-      logger.info("[queues plugin] Closing existing queue provider before creating new one...");
-      await existingProvider.close();
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  } catch {
-  }
-  const provider = new BullMQProvider();
-  await provider.init();
-  setQueueProvider(provider);
-  nitroApp.hooks.hook("close", async () => {
-    logger.info("[queues plugin] Closing queue provider...");
-    await provider.close();
-  });
-  return {
-    async close() {
-      await provider.close();
-    }
-  };
-});

package/dist/runtime/server/plugins/state-cleanup.d.ts

@@ -1,11 +0,0 @@
-/**
- * State Cleanup Plugin
- *
- * Handles automatic cleanup of flow state based on configuration strategy:
- * - 'never': State persists indefinitely
- * - 'immediate': Cleanup after each step (original behavior, not recommended)
- * - 'on-complete': Cleanup when flow completes (recommended, uses lifecycle tracking)
- * - 'ttl': State expires automatically via TTL (handled by storage provider)
- */
-declare const _default: any;
-export default _default;

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

@@ -1,93 +0,0 @@
-import { useNventLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
-import { getStateProvider } from "../../server-utils/state/stateFactory.js";
-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") {
-    return;
-  }
-  const { onType } = useEventManager();
-  const unsubs = [];
-  if (cleanup.strategy === "on-complete") {
-    unsubs.push(onType("flow.completed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after flow completion`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after flow completion", { flowId, error });
-      }
-    }));
-    unsubs.push(onType("flow.failed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after flow failure`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after flow failure", { flowId, error });
-      }
-    }));
-    logger.debug("Plugin initialized with strategy: on-complete");
-  } else if (cleanup.strategy === "immediate") {
-    unsubs.push(onType("step.completed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after step completion`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after step", { flowId, error });
-      }
-    }));
-    logger.debug("Plugin initialized with strategy: immediate");
-  }
-  return {
-    hooks: {
-      close: async () => {
-        for (const u of unsubs) {
-          try {
-            u();
-          } catch {
-          }
-        }
-        unsubs.length = 0;
-      }
-    }
-  };
-});

package/dist/runtime/server/plugins/worker-management.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

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

@@ -1,33 +0,0 @@
-import { defineNitroPlugin, $useWorkerHandlers, $useQueueRegistry } from "#imports";
-import { registerTsWorker, closeAllWorkers } from "../../server-utils/worker/adapter.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  nitroApp.hooks.hook("close", async () => {
-    await closeAllWorkers();
-  });
-  try {
-    const handlers = $useWorkerHandlers();
-    const registry = $useQueueRegistry() || { workers: [] };
-    for (const entry of handlers) {
-      const { queue, id, handler } = entry;
-      const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
-      let jobName;
-      if (w?.flow?.step) {
-        jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
-      } else {
-        jobName = id.includes("/") ? id.split("/").pop() : id;
-      }
-      if (typeof handler === "function") {
-        const cfg = w && w.worker || {};
-        const opts = {};
-        if (typeof cfg.concurrency === "number") opts.concurrency = cfg.concurrency;
-        if (typeof cfg.lockDurationMs === "number") opts.lockDuration = cfg.lockDurationMs;
-        if (typeof cfg.maxStalledCount === "number") opts.maxStalledCount = cfg.maxStalledCount;
-        if (typeof cfg.drainDelayMs === "number") opts.drainDelay = cfg.drainDelayMs;
-        if (typeof cfg.autorun === "boolean") opts.autorun = cfg.autorun;
-        if (w?.queue?.prefix) opts.prefix = w.queue.prefix;
-        await registerTsWorker(queue, jobName, handler, opts);
-      }
-    }
-  } catch {
-  }
-});

package/dist/runtime/server/tsconfig.json

@@ -1,3 +0,0 @@
-{
-    "extends": "../../../playground/.nuxt/tsconfig.server.json",
-}

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

@@ -1,2 +0,0 @@
-import type { EventStoreAdapter } from '../types.js';
-export declare function createFileAdapter(): EventStoreAdapter;

package/dist/runtime/server-utils/events/adapters/fileAdapter.js

@@ -1,382 +0,0 @@
-import { promises as fsp } from "node:fs";
-import { dirname, join } from "node:path";
-import { useRuntimeConfig } from "#imports";
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function sanitize(name) {
-  return name.replace(/[^\w.-]/g, "_");
-}
-async function ensureDir(path) {
-  try {
-    await fsp.mkdir(path, { recursive: true });
-  } catch {
-  }
-}
-async function fileExists(path) {
-  try {
-    await fsp.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export function createFileAdapter() {
-  const rc = useRuntimeConfig();
-  const rootDir = rc?.queue?.rootDir || process.cwd();
-  const dirRoot = rc?.queue?.eventStore?.options?.file?.dir ? join(rootDir, rc.queue.eventStore.options.file.dir) : join(rootDir, ".data/nq-events");
-  const ext = rc?.queue?.eventStore?.options?.file?.ext || ".ndjson";
-  const pollMs = rc?.queue?.eventStore?.options?.file?.pollMs ?? 1e3;
-  const subscribers = /* @__PURE__ */ new Map();
-  const timers = /* @__PURE__ */ new Map();
-  const lastIds = /* @__PURE__ */ new Map();
-  const indices = /* @__PURE__ */ new Map();
-  const streamPath = (stream) => join(dirRoot, sanitize(stream) + ext);
-  const indexPath = (key) => join(dirRoot, "indices", sanitize(key) + ".json");
-  const readAll = async (stream) => {
-    const p = streamPath(stream);
-    if (!await fileExists(p)) return [];
-    const content = await fsp.readFile(p, "utf8");
-    const lines = content.split("\n").filter(Boolean);
-    const out = [];
-    for (const line of lines) {
-      try {
-        const rec = JSON.parse(line);
-        out.push(rec);
-      } catch {
-      }
-    }
-    return out;
-  };
-  const adapter = {
-    async append(stream, e) {
-      const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      const rec = { ...e, id, ts: nowIso() };
-      const p = streamPath(stream);
-      await ensureDir(dirname(p));
-      await fsp.appendFile(p, JSON.stringify(rec) + "\n", { encoding: "utf8" });
-      const set = subscribers.get(stream);
-      if (set) {
-        for (const cb of set) {
-          try {
-            cb(rec);
-          } catch {
-          }
-        }
-      }
-      return rec;
-    },
-    async read(stream, opts) {
-      const list = await readAll(stream);
-      const dir = opts?.direction || "forward";
-      if (dir === "backward") {
-        let end = list.length;
-        if (opts?.fromId) {
-          const idx2 = list.findIndex((e) => e.id === opts.fromId);
-          end = idx2 >= 0 ? idx2 : list.length;
-        }
-        const count = opts?.limit && opts.limit > 0 ? opts.limit : end;
-        const start = Math.max(0, end - count);
-        const slice = list.slice(start, end);
-        return slice.reverse();
-      }
-      if (!opts?.fromId) {
-        if (opts?.limit && opts.limit > 0) return list.slice(0, opts.limit);
-        return list;
-      }
-      const idx = list.findIndex((e) => e.id === opts.fromId);
-      const sliced = idx >= 0 ? list.slice(idx + 1) : list;
-      if (opts?.limit && opts.limit > 0) return sliced.slice(0, opts.limit);
-      return sliced;
-    },
-    async subscribe(stream, onEvent) {
-      let set = subscribers.get(stream);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        subscribers.set(stream, set);
-      }
-      set.add(onEvent);
-      if (!timers.has(stream)) {
-        const t = setInterval(async () => {
-          try {
-            const fromId = lastIds.get(stream);
-            const fresh = await adapter.read(stream, fromId ? { fromId } : void 0);
-            if (fresh.length) {
-              for (const rec of fresh) {
-                set.forEach((cb) => {
-                  try {
-                    cb(rec);
-                  } catch {
-                  }
-                });
-                lastIds.set(stream, rec.id);
-              }
-            }
-          } catch {
-          }
-        }, pollMs);
-        timers.set(stream, t);
-      }
-      return {
-        unsubscribe() {
-          const s = subscribers.get(stream);
-          if (s) s.delete(onEvent);
-          if (s && s.size === 0) {
-            subscribers.delete(stream);
-            const t = timers.get(stream);
-            if (t) {
-              try {
-                clearInterval(t);
-              } catch {
-              }
-              timers.delete(stream);
-            }
-          }
-        }
-      };
-    },
-    async deleteStream(subject) {
-      const p = streamPath(subject);
-      try {
-        await fsp.unlink(p);
-      } catch {
-      }
-      subscribers.delete(subject);
-      const t = timers.get(subject);
-      if (t) {
-        clearInterval(t);
-        timers.delete(subject);
-      }
-      lastIds.delete(subject);
-    },
-    async deleteByPattern(pattern) {
-      const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${regexPattern}$`);
-      let count = 0;
-      try {
-        await ensureDir(dirRoot);
-        const files = await fsp.readdir(dirRoot);
-        for (const file of files) {
-          if (!file.endsWith(ext)) continue;
-          const subject = file.slice(0, -ext.length);
-          if (regex.test(subject)) {
-            const p = join(dirRoot, file);
-            await fsp.unlink(p);
-            subscribers.delete(subject);
-            const t = timers.get(subject);
-            if (t) {
-              clearInterval(t);
-              timers.delete(subject);
-            }
-            lastIds.delete(subject);
-            count++;
-          }
-        }
-      } catch {
-      }
-      return count;
-    },
-    async deleteIndex(key) {
-      indices.delete(key);
-      const p = indexPath(key);
-      try {
-        await fsp.unlink(p);
-      } catch {
-      }
-    },
-    async indexAdd(key, id, score, metadata) {
-      let data = indices.get(key);
-      if (!data) {
-        const p2 = indexPath(key);
-        if (await fileExists(p2)) {
-          try {
-            const content = await fsp.readFile(p2, "utf8");
-            data = JSON.parse(content);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-        indices.set(key, data);
-      }
-      const existing = data.findIndex((entry) => entry.id === id);
-      if (existing >= 0) {
-        data[existing] = { ...data[existing], score, ...metadata };
-      } else {
-        data.push({ id, score, ...metadata });
-      }
-      const p = indexPath(key);
-      await ensureDir(dirname(p));
-      await fsp.writeFile(p, JSON.stringify(data, null, 2), "utf8");
-    },
-    async indexRead(key, opts) {
-      let data = indices.get(key);
-      if (!data) {
-        const p = indexPath(key);
-        if (await fileExists(p)) {
-          try {
-            const content = await fsp.readFile(p, "utf8");
-            data = JSON.parse(content);
-            indices.set(key, data);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-      }
-      const sorted = [...data].sort((a, b) => b.score - a.score);
-      const offset = opts?.offset || 0;
-      const limit = opts?.limit || 50;
-      return sorted.slice(offset, offset + limit).map((entry) => ({
-        id: entry.id,
-        score: entry.score,
-        metadata: {
-          status: entry.status,
-          startedAt: entry.startedAt,
-          completedAt: entry.completedAt,
-          stepCount: entry.stepCount,
-          completedSteps: entry.completedSteps,
-          emittedEvents: entry.emittedEvents
-        }
-      }));
-    },
-    async indexGet(key, id) {
-      let data = indices.get(key);
-      if (!data) {
-        const p = indexPath(key);
-        if (await fileExists(p)) {
-          try {
-            const content = await fsp.readFile(p, "utf8");
-            data = JSON.parse(content);
-            indices.set(key, data);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-      }
-      const entry = data.find((e) => e.id === id);
-      if (!entry) return null;
-      return {
-        id: entry.id,
-        score: entry.score,
-        metadata: {
-          status: entry.status,
-          startedAt: entry.startedAt,
-          completedAt: entry.completedAt,
-          stepCount: entry.stepCount,
-          completedSteps: entry.completedSteps,
-          emittedEvents: entry.emittedEvents
-        }
-      };
-    },
-    async indexUpdate(key, id, metadata) {
-      let data = indices.get(key);
-      if (!data) {
-        const p2 = indexPath(key);
-        if (await fileExists(p2)) {
-          try {
-            const content = await fsp.readFile(p2, "utf8");
-            data = JSON.parse(content);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-        indices.set(key, data);
-      }
-      const entry = data.find((e) => e.id === id);
-      if (!entry) return false;
-      Object.assign(entry, metadata);
-      const p = indexPath(key);
-      await ensureDir(dirname(p));
-      await fsp.writeFile(p, JSON.stringify(data, null, 2), "utf8");
-      return true;
-    },
-    async indexUpdateWithRetry(key, id, metadata, maxRetries = 3) {
-      for (let attempt = 0; attempt < maxRetries; attempt++) {
-        const success = await this.indexUpdate(key, id, metadata);
-        if (success) return;
-        await new Promise((resolve) => setTimeout(resolve, 10 * Math.pow(2, attempt)));
-      }
-      throw new Error(`Failed to update index after ${maxRetries} retries`);
-    },
-    async indexIncrement(key, id, field, increment = 1) {
-      let data = indices.get(key);
-      if (!data) {
-        const p2 = indexPath(key);
-        if (await fileExists(p2)) {
-          try {
-            const content = await fsp.readFile(p2, "utf8");
-            data = JSON.parse(content);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-        indices.set(key, data);
-      }
-      const entry = data.find((e) => e.id === id);
-      if (!entry) return 0;
-      const currentValue = entry[field] || 0;
-      const newValue = currentValue + increment;
-      entry[field] = newValue;
-      const p = indexPath(key);
-      await ensureDir(dirname(p));
-      await fsp.writeFile(p, JSON.stringify(data, null, 2), "utf8");
-      return newValue;
-    },
-    async cleanupCompletedFlows(key, retentionSeconds) {
-      let data = indices.get(key);
-      if (!data) {
-        const p = indexPath(key);
-        if (await fileExists(p)) {
-          try {
-            const content = await fsp.readFile(p, "utf8");
-            data = JSON.parse(content);
-          } catch {
-            data = [];
-          }
-        } else {
-          data = [];
-        }
-        indices.set(key, data);
-      }
-      const now = Date.now();
-      const cutoffTime = now - retentionSeconds * 1e3;
-      const originalLength = data.length;
-      const filtered = data.filter((entry) => {
-        const isTerminal = entry.status === "completed" || entry.status === "failed";
-        const isOld = entry.completedAt ? entry.completedAt < cutoffTime : false;
-        return !(isTerminal && isOld);
-      });
-      const removedCount = originalLength - filtered.length;
-      if (removedCount > 0) {
-        indices.set(key, filtered);
-        const p = indexPath(key);
-        await ensureDir(dirname(p));
-        await fsp.writeFile(p, JSON.stringify(filtered, null, 2), "utf8");
-      }
-      return removedCount;
-    },
-    async setMetadataTTL(_key, _id, _ttlSeconds) {
-    },
-    async close() {
-      for (const t of timers.values()) {
-        try {
-          clearInterval(t);
-        } catch {
-        }
-      }
-      timers.clear();
-      subscribers.clear();
-      lastIds.clear();
-    }
-  };
-  return adapter;
-}

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

@@ -1,2 +0,0 @@
-import type { EventStoreAdapter } from '../types.js';
-export declare function createMemoryAdapter(): EventStoreAdapter;