nvent 0.4.0

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

@@ -0,0 +1,200 @@
+import {
+  defineWebSocketHandler,
+  useQueue,
+  registerWsPeer,
+  unregisterWsPeer,
+  useServerLogger
+} from "#imports";
+const peerContexts = /* @__PURE__ */ new WeakMap();
+const logger = useServerLogger("api-queues-ws");
+function safeSend(peer, data) {
+  try {
+    peer.send(JSON.stringify(data));
+    return true;
+  } catch {
+    return false;
+  }
+}
+export default defineWebSocketHandler({
+  open(peer) {
+    logger.info("[ws:queues] client connected:", peer.id);
+    registerWsPeer(peer);
+    peerContexts.set(peer, {
+      subscriptions: /* @__PURE__ */ new Map()
+    });
+    safeSend(peer, {
+      type: "connected",
+      timestamp: Date.now()
+    });
+  },
+  async message(peer, message) {
+    const context = peerContexts.get(peer);
+    if (!context) {
+      logger.error("[ws:queues] no context for peer:", peer.id);
+      return;
+    }
+    let data;
+    try {
+      data = JSON.parse(message.text());
+    } catch {
+      safeSend(peer, {
+        type: "error",
+        message: "Invalid JSON"
+      });
+      return;
+    }
+    const { type, queueName } = data;
+    if (type === "subscribe") {
+      if (!queueName) {
+        safeSend(peer, {
+          type: "error",
+          message: "Missing queueName"
+        });
+        return;
+      }
+      const queue = useQueue();
+      const existingUnsub = context.subscriptions.get(queueName);
+      if (existingUnsub) {
+        try {
+          existingUnsub();
+        } catch (err) {
+          logger.error("[ws:queues] error unsubscribing:", err);
+        }
+      }
+      const events = [
+        "waiting",
+        "active",
+        "completed",
+        "failed",
+        "progress"
+      ];
+      const unsubs = events.map(
+        (eventType) => queue.on(queueName, eventType, async (payload) => {
+          safeSend(peer, {
+            type: "event",
+            queueName,
+            event: {
+              eventType,
+              ...payload
+            }
+          });
+          if (["waiting", "active", "completed", "failed"].includes(eventType)) {
+            try {
+              const counts = await queue.getJobCounts(queueName);
+              safeSend(peer, {
+                type: "counts",
+                queueName,
+                counts
+              });
+            } catch (err) {
+              logger.error("[ws:queues] error fetching counts after event:", err);
+            }
+          }
+        })
+      );
+      const unsub = () => {
+        for (const u of unsubs) {
+          try {
+            u();
+          } catch (err) {
+            logger.error("[ws:queues] error unsubscribing:", err);
+          }
+        }
+      };
+      context.subscriptions.set(queueName, unsub);
+      try {
+        const counts = await queue.getJobCounts(queueName);
+        safeSend(peer, {
+          type: "counts",
+          queueName,
+          counts
+        });
+      } catch (err) {
+        logger.error("[ws:queues] error fetching counts:", err);
+      }
+      safeSend(peer, {
+        type: "subscribed",
+        queueName
+      });
+    } else if (type === "unsubscribe") {
+      if (!queueName) {
+        safeSend(peer, {
+          type: "error",
+          message: "Missing queueName"
+        });
+        return;
+      }
+      const unsub = context.subscriptions.get(queueName);
+      if (unsub) {
+        try {
+          unsub();
+          context.subscriptions.delete(queueName);
+          safeSend(peer, {
+            type: "unsubscribed",
+            queueName
+          });
+        } catch (err) {
+          logger.error("[ws:queues] error unsubscribing:", err);
+          safeSend(peer, {
+            type: "error",
+            message: "Failed to unsubscribe"
+          });
+        }
+      }
+    } else if (type === "ping") {
+      safeSend(peer, {
+        type: "pong",
+        timestamp: Date.now()
+      });
+    } else {
+      safeSend(peer, {
+        type: "error",
+        message: `Unknown message type: ${type}`
+      });
+    }
+  },
+  close(peer, event) {
+    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
+    if (!isNormalClosure) {
+      logger.info("[ws:queues] client disconnected:", {
+        peerId: peer.id,
+        code: event?.code,
+        reason: event?.reason
+      });
+    }
+    unregisterWsPeer(peer);
+    const context = peerContexts.get(peer);
+    if (context) {
+      for (const unsub of context.subscriptions.values()) {
+        try {
+          unsub();
+        } catch (err) {
+          if (!isNormalClosure) {
+            logger.error("[ws:queues] error unsubscribing on close:", err);
+          }
+        }
+      }
+      context.subscriptions.clear();
+      peerContexts.delete(peer);
+    }
+  },
+  error(peer, error) {
+    logger.error("[ws:queues] error for peer:", {
+      peerId: peer.id,
+      error
+    });
+    unregisterWsPeer(peer);
+    const context = peerContexts.get(peer);
+    if (context) {
+      for (const unsub of context.subscriptions.values()) {
+        try {
+          unsub();
+        } catch (err) {
+          logger.error("[ws:queues] error unsubscribing on error:", { error: err });
+        }
+      }
+      context.subscriptions.clear();
+      peerContexts.delete(peer);
+    }
+  }
+});

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

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

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

@@ -0,0 +1,382 @@
+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/events/adapters/memoryAdapter.d.ts

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