nvent 0.4.3 → 0.4.5

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;

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

@@ -1,171 +0,0 @@
-const GLOBAL_KEY = "__nuxt_queue_memory_adapter__";
-function getStore() {
-  if (!globalThis[GLOBAL_KEY]) {
-    globalThis[GLOBAL_KEY] = {
-      events: /* @__PURE__ */ new Map(),
-      listeners: /* @__PURE__ */ new Map(),
-      indices: /* @__PURE__ */ new Map()
-    };
-  }
-  return globalThis[GLOBAL_KEY];
-}
-export function createMemoryAdapter() {
-  const { events, listeners, indices } = getStore();
-  return {
-    async append(stream, e) {
-      const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      const rec = { ...e, id, ts: (/* @__PURE__ */ new Date()).toISOString() };
-      const list = events.get(stream) || [];
-      list.push(rec);
-      events.set(stream, list);
-      const set = listeners.get(stream);
-      if (set) set.forEach((cb) => cb(rec));
-      return rec;
-    },
-    async read(stream, opts) {
-      const list = events.get(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 out = idx >= 0 ? list.slice(idx + 1) : list;
-      if (opts?.limit && opts.limit > 0) return out.slice(0, opts.limit);
-      return out;
-    },
-    async subscribe(stream, onEvent) {
-      let set = listeners.get(stream);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        listeners.set(stream, set);
-      }
-      set.add(onEvent);
-      return {
-        unsubscribe() {
-          set.delete(onEvent);
-        }
-      };
-    },
-    async indexAdd(key, id, score, metadata) {
-      const data = indices.get(key) || [];
-      const existing = data.findIndex((entry) => entry.id === id);
-      if (existing >= 0) {
-        data[existing].score = score;
-        if (metadata) {
-          data[existing].metadata = metadata;
-        }
-      } else {
-        data.push({ id, score, metadata });
-      }
-      indices.set(key, data);
-    },
-    async indexRead(key, opts) {
-      const data = indices.get(key) || [];
-      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);
-    },
-    async indexGet(key, id) {
-      const data = indices.get(key) || [];
-      const entry = data.find((item) => item.id === id);
-      if (!entry) return null;
-      return {
-        id: entry.id,
-        score: entry.score,
-        metadata: entry.metadata
-      };
-    },
-    async indexUpdate(key, id, metadata) {
-      const data = indices.get(key) || [];
-      const entryIndex = data.findIndex((item) => item.id === id);
-      if (entryIndex === -1) {
-        data.push({ id, score: Date.now(), metadata: { ...metadata, version: 1 } });
-        indices.set(key, data);
-        return true;
-      }
-      const entry = data[entryIndex];
-      const currentVersion = entry.metadata?.version || 0;
-      const expectedVersion = metadata.version !== void 0 ? metadata.version - 1 : currentVersion;
-      if (currentVersion !== expectedVersion) {
-        return false;
-      }
-      entry.metadata = {
-        ...entry.metadata,
-        ...metadata,
-        version: currentVersion + 1
-      };
-      indices.set(key, data);
-      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) {
-      const data = indices.get(key) || [];
-      const entryIndex = data.findIndex((item) => item.id === id);
-      if (entryIndex === -1) {
-        const newEntry = {
-          id,
-          score: Date.now(),
-          metadata: { [field]: increment, version: 1 }
-        };
-        data.push(newEntry);
-        indices.set(key, data);
-        return increment;
-      }
-      const entry = data[entryIndex];
-      if (!entry.metadata) {
-        entry.metadata = { version: 0 };
-      }
-      const currentValue = entry.metadata[field] || 0;
-      const newValue = currentValue + increment;
-      entry.metadata[field] = newValue;
-      entry.metadata.version = (entry.metadata.version || 0) + 1;
-      indices.set(key, data);
-      return newValue;
-    },
-    async deleteStream(subject) {
-      events.delete(subject);
-      listeners.delete(subject);
-    },
-    async deleteByPattern(pattern) {
-      const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${regexPattern}$`);
-      let count = 0;
-      for (const key of events.keys()) {
-        if (regex.test(key)) {
-          events.delete(key);
-          listeners.delete(key);
-          count++;
-        }
-      }
-      return count;
-    },
-    async deleteIndex(key) {
-      indices.delete(key);
-    },
-    async close() {
-      listeners.clear();
-      events.clear();
-      indices.clear();
-    }
-  };
-}

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

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