nvent 0.4.4 → 0.4.5

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

@@ -1,164 +0,0 @@
-import { Queue, QueueEvents } from "bullmq";
-import defu from "defu";
-import { useRuntimeConfig, $useQueueRegistry, useEventManager, useNventLogger } from "#imports";
-export class BullMQProvider {
-  queues = /* @__PURE__ */ new Map();
-  logger = useNventLogger("bullmq-adapter");
-  async init() {
-  }
-  ensureQueue(name) {
-    let cached = this.queues.get(name);
-    if (cached) return cached;
-    const { publishBus } = useEventManager();
-    const rc = useRuntimeConfig();
-    const connection = rc.queue?.queue?.redis;
-    let queueDefaults = void 0;
-    let prefix;
-    let limiter = void 0;
-    try {
-      const registry = $useQueueRegistry();
-      if (registry && Array.isArray(registry.workers)) {
-        const w = registry.workers.find((w2) => w2?.queue?.name === name);
-        if (w?.queue) {
-          queueDefaults = w.queue.defaultJobOptions;
-          prefix = w.queue.prefix;
-          limiter = w.queue.limiter;
-        }
-      }
-    } catch {
-    }
-    const queueOpts = { connection, prefix, defaultJobOptions: queueDefaults };
-    if (limiter) {
-      queueOpts.limiter = {
-        max: limiter.max,
-        duration: limiter.duration,
-        groupKey: limiter.groupKey
-      };
-    }
-    const queue = new Queue(name, queueOpts);
-    const events = new QueueEvents(name, { connection, prefix });
-    events.setMaxListeners(50);
-    cached = { queue, events, wired: false, defaults: queueDefaults };
-    this.queues.set(name, cached);
-    const forward = async (kind, payload) => {
-      const jobId = payload?.jobId || "unknown";
-      let runId = "";
-      try {
-        if (jobId && jobId !== "unknown") {
-          const job = await queue.getJob(jobId);
-          if (job?.data?.flowId) {
-            runId = job.data.flowId;
-          }
-        }
-      } catch {
-      }
-      const rec = {
-        type: `job.${kind}`,
-        runId,
-        data: { ...payload, queue: name, jobId }
-      };
-      await publishBus(rec);
-    };
-    for (const ev of ["waiting", "active", "progress", "completed", "failed", "delayed"]) {
-      events.on(ev, (p) => {
-        void forward(ev, p);
-      });
-    }
-    cached.wired = true;
-    return cached;
-  }
-  async enqueue(queueName, job) {
-    const { queue, defaults } = this.ensureQueue(queueName);
-    const opts = defu(job.opts || {}, defaults || {});
-    const bullJob = await queue.add(job.name, job.data, opts);
-    return bullJob.id;
-  }
-  async schedule(queueName, job, opts) {
-    const { queue, defaults } = this.ensureQueue(queueName);
-    const jobsOpts = defu({ ...job.opts }, defaults || {});
-    if (opts?.delay) jobsOpts.delay = opts.delay;
-    if (opts?.cron) jobsOpts.repeat = { pattern: opts.cron };
-    const bullJob = await queue.add(job.name, job.data, jobsOpts);
-    return bullJob.id;
-  }
-  async getJob(queueName, id) {
-    const { queue } = this.ensureQueue(queueName);
-    const j = await queue.getJob(id);
-    if (!j) return null;
-    return await this.toJob(j);
-  }
-  async getJobs(queueName, _q) {
-    const { queue } = this.ensureQueue(queueName);
-    const states = _q?.state && _q.state.length > 0 ? _q.state : ["waiting", "active", "completed", "failed", "delayed", "paused"];
-    const limit = _q?.limit || 1e3;
-    const jobs = await queue.getJobs(states, 0, limit - 1);
-    return await Promise.all(jobs.map((j) => this.toJob(j)));
-  }
-  on(queueName, event, cb) {
-    const { events } = this.ensureQueue(queueName);
-    const handler = (payload) => cb(payload);
-    events.on(event, handler);
-    return () => {
-      events.off(event, handler);
-    };
-  }
-  async isPaused(queueName) {
-    const { queue } = this.ensureQueue(queueName);
-    return await queue.isPaused();
-  }
-  async getJobCounts(queueName) {
-    const { queue } = this.ensureQueue(queueName);
-    const counts = await queue.getJobCounts("waiting", "active", "completed", "failed", "delayed", "paused");
-    return {
-      active: counts.active || 0,
-      completed: counts.completed || 0,
-      failed: counts.failed || 0,
-      delayed: counts.delayed || 0,
-      waiting: counts.waiting || 0,
-      paused: counts.paused || 0
-    };
-  }
-  async pause(queueName) {
-    const { queue } = this.ensureQueue(queueName);
-    await queue.pause();
-  }
-  async resume(queueName) {
-    const { queue } = this.ensureQueue(queueName);
-    await queue.resume();
-  }
-  async close() {
-    const closePromises = [];
-    for (const [queueName, { queue, events }] of this.queues.entries()) {
-      closePromises.push(
-        queue.close().catch((err) => {
-          if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-            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")) {
-            this.logger.warn("Error closing events for queue", { queueName, error: err });
-          }
-        })
-      );
-    }
-    await Promise.allSettled(closePromises);
-    this.queues.clear();
-  }
-  async toJob(j) {
-    const state = await j.getState();
-    return {
-      id: j.id,
-      name: j.name,
-      data: j.data,
-      returnvalue: j.returnvalue,
-      failedReason: j.failedReason,
-      state,
-      timestamp: j.timestamp,
-      processedOn: j.processedOn,
-      finishedOn: j.finishedOn
-    };
-  }
-}

package/dist/runtime/server-utils/queue/queueFactory.d.ts

@@ -1,3 +0,0 @@
-import type { QueueProvider } from './types.js';
-export declare function setQueueProvider(p: QueueProvider): void;
-export declare function getQueueProvider(): QueueProvider;

package/dist/runtime/server-utils/queue/queueFactory.js

@@ -1,10 +0,0 @@
-let currentProvider = null;
-export function setQueueProvider(p) {
-  currentProvider = p;
-}
-export function getQueueProvider() {
-  if (!currentProvider) {
-    throw new Error("[nuxt-queue] QueueProvider not initialized");
-  }
-  return currentProvider;
-}

package/dist/runtime/server-utils/queue/types.d.ts

@@ -1,47 +0,0 @@
-export type JobCounts = {
-    active: number;
-    completed: number;
-    failed: number;
-    delayed: number;
-    waiting: number;
-    paused: number;
-};
-export type QueueEvent = 'added' | 'waiting' | 'active' | 'progress' | 'completed' | 'failed' | 'paused' | 'resumed';
-export interface JobInput {
-    name: string;
-    data: any;
-    opts?: Record<string, any>;
-}
-export interface Job {
-    id: string;
-    name: string;
-    data: any;
-    state?: 'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | 'paused';
-    returnvalue?: any;
-    failedReason?: string;
-    timestamp?: number;
-    processedOn?: number;
-    finishedOn?: number;
-}
-export interface JobsQuery {
-    state?: Array<Job['state']>;
-    limit?: number;
-    cursor?: string;
-}
-export interface ScheduleOptions {
-    delay?: number;
-    cron?: string;
-}
-export interface QueueProvider {
-    init(): Promise<void>;
-    enqueue(queue: string, job: JobInput): Promise<string>;
-    schedule(queue: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
-    getJob(queue: string, id: string): Promise<Job | null>;
-    getJobs(queue: string, q?: JobsQuery): Promise<Job[]>;
-    on(queue: string, event: QueueEvent, cb: (p: any) => void): () => void;
-    getJobCounts?(queue: string): Promise<Record<string, number>>;
-    isPaused?(queue: string): Promise<boolean>;
-    pause(queue: string): Promise<void>;
-    resume(queue: string): Promise<void>;
-    close(): Promise<void>;
-}

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

@@ -1,2 +0,0 @@
-import type { StateProvider } from '../types.js';
-export declare function createRedisStateProvider(namespace?: string): StateProvider;

package/dist/runtime/server-utils/state/adapters/redis.js

@@ -1,42 +0,0 @@
-import { useStorage, useRuntimeConfig } from "#imports";
-function nsKey(ns, key) {
-  if (!key) return ns;
-  return key.startsWith(ns + ":") ? key : `${ns}:${key}`;
-}
-export function createRedisStateProvider(namespace) {
-  const storage = useStorage("redis");
-  const ns = namespace || useRuntimeConfig()?.queue?.state?.namespace || "nq";
-  return {
-    async get(key) {
-      return storage.getItem(nsKey(ns, key));
-    },
-    async set(key, value, opts) {
-      await storage.setItem(nsKey(ns, key), value, { ttl: opts?.ttl });
-    },
-    async delete(key) {
-      await storage.removeItem(nsKey(ns, key));
-    },
-    async list(prefix, opts) {
-      const base = nsKey(ns, prefix);
-      const keys = await storage.getKeys(base);
-      const filtered = keys.filter((k) => k.startsWith(base)).slice(0, opts?.limit || keys.length);
-      return { keys: filtered };
-    },
-    async patch(key, updater, opts) {
-      const retries = Math.max(0, opts?.retries ?? 3);
-      const k = nsKey(ns, key);
-      let lastErr;
-      for (let i = 0; i <= retries; i++) {
-        try {
-          const prev = await storage.getItem(k);
-          const next = updater(prev);
-          await storage.setItem(k, next);
-          return next;
-        } catch (err) {
-          lastErr = err;
-        }
-      }
-      throw lastErr || new Error("patch failed");
-    }
-  };
-}

package/dist/runtime/server-utils/state/stateFactory.d.ts

@@ -1,3 +0,0 @@
-import type { StateProvider } from './types.js';
-export declare function getStateProvider(): StateProvider;
-export declare function setStateProvider(p: StateProvider): void;

package/dist/runtime/server-utils/state/stateFactory.js

@@ -1,17 +0,0 @@
-import { useRuntimeConfig } from "#imports";
-import { createRedisStateProvider } from "./adapters/redis.js";
-let currentStateProvider = null;
-export function getStateProvider() {
-  if (currentStateProvider) return currentStateProvider;
-  const rc = useRuntimeConfig();
-  const adapter = rc?.queue?.state?.adapter || "redis";
-  const ns = rc?.queue?.state?.namespace || "nq";
-  if (adapter === "redis") {
-    currentStateProvider = createRedisStateProvider(ns);
-    return currentStateProvider;
-  }
-  throw new Error(`[nuxt-queue] Unsupported StateProvider: ${adapter}`);
-}
-export function setStateProvider(p) {
-  currentStateProvider = p;
-}

package/dist/runtime/server-utils/state/types.d.ts

@@ -1,23 +0,0 @@
-export interface StateProvider {
-    get<T = any>(key: string): Promise<T | null>;
-    set<T = any>(key: string, value: T, opts?: {
-        ttl?: number;
-    }): Promise<void>;
-    delete(key: string): Promise<void>;
-    list(prefix: string, opts?: {
-        limit?: number;
-    }): Promise<{
-        keys: string[];
-    }>;
-    patch<T = any>(key: string, updater: (prev: T | null) => T, opts?: {
-        retries?: number;
-    }): Promise<T>;
-}
-export interface StorageLike {
-    getItem<T = any>(key: string): Promise<T | null>;
-    setItem<T = any>(key: string, value: T, opts?: {
-        ttl?: number;
-    }): Promise<void>;
-    removeItem(key: string): Promise<void>;
-    getKeys(base?: string): Promise<string[]>;
-}

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

@@ -1,2 +0,0 @@
-export const defineQueueConfig = (cfg) => cfg;
-export default defineQueueConfig;

package/dist/runtime/server-utils/utils/defineQueueWorker.d.ts

@@ -1,10 +0,0 @@
-import { useFlowEngine, useQueue } from '#imports';
-import type { RunContext, NodeHandler } from '../worker/runner/node.js';
-export type ExtendedRunContext = RunContext & {
-    provider: ReturnType<typeof useQueue>;
-    flow: ReturnType<typeof useFlowEngine>;
-    registry: any;
-};
-export type DefineQueueWorker = (handler: (input: any, ctx: ExtendedRunContext) => Promise<any>) => NodeHandler;
-export declare const defineQueueWorker: DefineQueueWorker;
-export default defineQueueWorker;

package/dist/runtime/server-utils/utils/useEventStore.d.ts

@@ -1,20 +0,0 @@
-import type { EventReadOptions } from '../events/types.js';
-import type { EventRecord } from '../types.js';
-export declare function useEventStore(): {
-    names: () => import("../events/streamNames.js").StreamNames;
-    read: (stream: string, opts?: EventReadOptions) => Promise<EventRecord[]>;
-    indexAdd: (key: string, id: string, score: number, metadata?: Record<string, any>) => Promise<void>;
-    indexGet: (key: string, id: string) => Promise<import("../events/types.js").IndexEntry | null>;
-    indexUpdate: (key: string, id: string, metadata: Record<string, any>) => Promise<boolean>;
-    indexUpdateWithRetry: (key: string, id: string, metadata: Record<string, any>, maxRetries?: number) => Promise<void>;
-    indexIncrement: (key: string, id: string, field: string, increment?: number) => Promise<number>;
-    indexRead: (key: string, opts?: {
-        offset?: number;
-        limit?: number;
-    }) => Promise<import("../events/types.js").IndexEntry[]>;
-    deleteStream: (subject: string) => Promise<void>;
-    deleteByPattern: (pattern: string) => Promise<number>;
-    deleteIndex: (key: string) => Promise<void>;
-    subscribe: (stream: string, handler: (e: EventRecord) => void) => () => void;
-    adapter: import("../events/types.js").EventStoreAdapter;
-};

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

@@ -1,119 +0,0 @@
-import { getEventStoreFactory } from "../events/eventStoreFactory.js";
-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);
-  }
-  async function indexAdd(key, id, score, metadata) {
-    if (!factory.adapter.indexAdd) {
-      throw new Error("Current adapter does not support indexAdd");
-    }
-    return await factory.adapter.indexAdd(key, id, score, metadata);
-  }
-  async function indexGet(key, id) {
-    if (!factory.adapter.indexGet) {
-      throw new Error("Current adapter does not support indexGet");
-    }
-    return await factory.adapter.indexGet(key, id);
-  }
-  async function indexUpdate(key, id, metadata) {
-    if (!factory.adapter.indexUpdate) {
-      throw new Error("Current adapter does not support indexUpdate");
-    }
-    return await factory.adapter.indexUpdate(key, id, metadata);
-  }
-  async function indexUpdateWithRetry(key, id, metadata, maxRetries) {
-    if (!factory.adapter.indexUpdateWithRetry) {
-      throw new Error("Current adapter does not support indexUpdateWithRetry");
-    }
-    return await factory.adapter.indexUpdateWithRetry(key, id, metadata, maxRetries);
-  }
-  async function indexIncrement(key, id, field, increment) {
-    if (!factory.adapter.indexIncrement) {
-      throw new Error("Current adapter does not support indexIncrement");
-    }
-    return await factory.adapter.indexIncrement(key, id, field, increment);
-  }
-  async function indexRead(key, opts) {
-    if (!factory.adapter.indexRead) {
-      throw new Error("Current adapter does not support indexRead");
-    }
-    return await factory.adapter.indexRead(key, opts);
-  }
-  async function deleteStream(subject) {
-    if (!factory.adapter.deleteStream) {
-      throw new Error("Current adapter does not support deleteStream");
-    }
-    return await factory.adapter.deleteStream(subject);
-  }
-  async function deleteByPattern(pattern) {
-    if (!factory.adapter.deleteByPattern) {
-      throw new Error("Current adapter does not support deleteByPattern");
-    }
-    return await factory.adapter.deleteByPattern(pattern);
-  }
-  async function deleteIndex(key) {
-    if (!factory.adapter.deleteIndex) {
-      throw new Error("Current adapter does not support deleteIndex");
-    }
-    return await factory.adapter.deleteIndex(key);
-  }
-  function names() {
-    return factory.names;
-  }
-  function subscribe(stream, handler) {
-    logger.debug("Subscribing to stream", { stream });
-    let sub = null;
-    let active = true;
-    (async () => {
-      try {
-        sub = await factory.adapter.subscribe(stream, (e) => {
-          logger.debug("Event received", { stream, id: e?.id, type: e?.type });
-          handler(e);
-        });
-        logger.debug("Subscription active", { stream });
-      } catch (err) {
-        logger.error("Subscription error", { stream, error: err });
-      }
-      if (!active && sub) {
-        try {
-          sub.unsubscribe();
-        } catch {
-        }
-      }
-    })();
-    return () => {
-      active = false;
-      if (sub) {
-        try {
-          sub.unsubscribe();
-        } catch {
-        }
-        sub = null;
-      }
-    };
-  }
-  return {
-    // names
-    names,
-    // read from canonical streams
-    read,
-    // sorted set index operations
-    indexAdd,
-    indexGet,
-    indexUpdate,
-    indexUpdateWithRetry,
-    indexIncrement,
-    indexRead,
-    // deletion operations
-    deleteStream,
-    deleteByPattern,
-    deleteIndex,
-    // subscribe to canonical stream events via the adapter (Store Bus)
-    subscribe,
-    // expose adapter if advanced usage is needed
-    adapter: factory.adapter
-  };
-}

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

@@ -1,9 +0,0 @@
-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[]>;
-};

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

@@ -1,44 +0,0 @@
-import { $useQueueRegistry, useQueue, useEventManager, useNventLogger } from "#imports";
-import { randomUUID } from "node:crypto";
-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");
-    const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
-    const flowId = randomUUID();
-    const id = await queueAdapter.enqueue(queueName, { name: flow.entry.step, data: { ...payload, flowId, flowName } });
-    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 [];
-  };
-  return { startFlow, emit };
-};

package/dist/runtime/server-utils/utils/useLogs.d.ts

@@ -1,41 +0,0 @@
-export interface LogReadOptions {
-    fromId?: string;
-    limit?: number;
-}
-export declare function useLogs(): {
-    getJobLogs: (_jobId: string, _opts?: {
-        limit?: number;
-        fromId?: string;
-        direction?: "forward" | "backward";
-        paged?: boolean;
-    }) => Promise<any>;
-    getFlowRunLogs: (flowId: string, opts?: {
-        limit?: number;
-        fromId?: string;
-        direction?: "forward" | "backward";
-        paged?: boolean;
-    }) => Promise<any>;
-    publishLog: (level: "debug" | "info" | "warn" | "error", msg: string, meta?: any, ctx?: {
-        queue?: string;
-        jobId?: string;
-        flowId?: string;
-    }) => Promise<void>;
-    onLog: (handler: (e: {
-        level: "debug" | "info" | "warn" | "error";
-        msg: string;
-        meta?: any;
-        raw: any;
-    }) => void) => any;
-    onJobLog: (_jobId: string, _handler: (e: {
-        level: "debug" | "info" | "warn" | "error";
-        msg: string;
-        meta?: any;
-        raw: any;
-    }) => void) => () => void;
-    onFlowLog: (flowId: string, handler: (e: {
-        level: "debug" | "info" | "warn" | "error";
-        msg: string;
-        meta?: any;
-        raw: any;
-    }) => void) => any;
-};

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

@@ -1,74 +0,0 @@
-import { useEventManager, useEventStore } from "#imports";
-export function useLogs() {
-  const eventManager = useEventManager();
-  const store = useEventStore();
-  const names = store.names();
-  async function getJobLogs(_jobId, _opts) {
-    return { items: [], nextFromId: void 0 };
-  }
-  async function getFlowRunLogs(flowId, opts) {
-    const s = names.flow(flowId);
-    const limit = opts?.limit ?? 200;
-    const direction = opts?.direction || "backward";
-    if (opts?.paged) {
-      const page2 = await store.read(s, { limit: limit * 5, fromId: opts?.fromId, direction });
-      const filtered = page2.filter((r) => r?.kind === "runner.log");
-      const items = filtered.slice(0, limit);
-      const nextFromId = page2.length >= limit * 5 ? page2[page2.length - 1]?.id : void 0;
-      return { items, nextFromId };
-    }
-    const page = await store.read(s, { limit, fromId: opts?.fromId, direction });
-    return page.filter((r) => r?.kind === "runner.log").slice(0, limit);
-  }
-  async function publishLog(level, msg, meta, ctx) {
-    const reserved = /* @__PURE__ */ new Set(["flowId", "flowName", "stepName", "stepRunId", "stepId", "attempt", "jobId", "queue", "tags"]);
-    const envMeta = {};
-    const dataMeta = {};
-    const src = meta || {};
-    for (const k of Object.keys(src)) {
-      if (reserved.has(k)) envMeta[k] = src[k];
-      else dataMeta[k] = src[k];
-    }
-    if (ctx?.flowId && envMeta.flowId == null) envMeta.flowId = ctx.flowId;
-    const runId = ctx?.flowId || "unknown";
-    const flowName = envMeta.flowName || "unknown";
-    const stepName = envMeta.stepName;
-    const stepId = envMeta.stepId || envMeta.stepRunId;
-    const attempt = envMeta.attempt;
-    await eventManager.publishBus({
-      type: "log",
-      runId,
-      flowName,
-      stepName,
-      stepId,
-      attempt,
-      data: { level, message: msg, ...dataMeta }
-    });
-  }
-  function onLog(handler) {
-    return eventManager.onType("log", (evt) => {
-      const d = evt?.data || {};
-      handler({ level: d.level, msg: d.message || d.msg, meta: d.meta, raw: evt });
-    });
-  }
-  function onJobLog(_jobId, _handler) {
-    return () => {
-    };
-  }
-  function onFlowLog(flowId, handler) {
-    const s = names.flow(flowId);
-    return store.subscribe(s, (evt) => {
-      if (evt?.kind !== "runner.log") return;
-      const d = evt?.data || {};
-      handler({ level: d.level, msg: d.msg, meta: d.meta, raw: evt });
-    });
-  }
-  return {
-    getJobLogs,
-    getFlowRunLogs,
-    publishLog,
-    onLog,
-    onJobLog,
-    onFlowLog
-  };
-}