nvent 0.4.4 → 0.5.0

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.d.ts

@@ -1,154 +0,0 @@
-export type FlowRole = 'entry' | 'step';
-export interface FlowConfig {
-    /**
-     * One or more flow names this step belongs to.
-     * A single worker step can participate in multiple flows.
-     */
-    name: string | string[];
-    /**
-     * Role of this step in the flow.
-     */
-    role: FlowRole;
-    /**
-     * Logical step name (used as job name and event kind on start).
-     */
-    step: string;
-    /**
-     * Event kinds this step emits (e.g., `${step}.completed`).
-     */
-    emits?: string[];
-    /**
-     * Event kinds this step subscribes to; can be a single string or an array.
-     * The compiler normalizes this to `string[]` under `subscribes`.
-     */
-    subscribes?: string | string[];
-}
-export interface QueueJobDefaults {
-    /**
-     * Number of retry attempts for failed jobs.
-     * BullMQ: attempts, PGBoss: retryLimit
-     */
-    attempts?: number;
-    /**
-     * Backoff strategy for retries.
-     * BullMQ: backoff, PGBoss: retryBackoff + exponentialBackoff
-     */
-    backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
-    /**
-     * Delay in milliseconds before the job is processed.
-     * BullMQ: delay, PGBoss: startAfter
-     */
-    delay?: number;
-    /**
-     * Job priority (higher number = higher priority).
-     * BullMQ: priority, PGBoss: priority
-     */
-    priority?: number;
-    /**
-     * Job timeout in milliseconds.
-     * BullMQ: timeout, PGBoss: expireInSeconds (converted)
-     */
-    timeout?: number;
-    /**
-     * Process jobs in LIFO (Last In First Out) order.
-     * BullMQ: lifo, PGBoss: not supported
-     */
-    lifo?: boolean;
-    /**
-     * Remove job from queue when completed.
-     * BullMQ: removeOnComplete, PGBoss: deleteAfterSeconds
-     */
-    removeOnComplete?: boolean | number;
-    /**
-     * Remove job from queue when failed.
-     * BullMQ: removeOnFail, PGBoss: deleteAfterSeconds
-     */
-    removeOnFail?: boolean | number;
-    /**
-     * Repeatable job configuration.
-     * BullMQ: repeat, PGBoss: schedule pattern
-     */
-    repeat?: {
-        cron?: string;
-        every?: number;
-        limit?: number;
-        tz?: string;
-    };
-}
-export interface QueueConfig {
-    /**
-     * Queue name. If not provided, the filename will be used.
-     */
-    name?: string;
-    /**
-     * Default options for jobs enqueued to this queue.
-     */
-    defaultJobOptions?: QueueJobDefaults;
-    /**
-     * Prefix for queue keys in Redis/storage.
-     * BullMQ: prefix, PGBoss: schema
-     */
-    prefix?: string;
-    /**
-     * Rate limiting configuration.
-     * BullMQ: limiter, PGBoss: teamSize + teamConcurrency (partial)
-     */
-    limiter?: {
-        /**
-         * Maximum number of jobs to process in the duration window.
-         */
-        max?: number;
-        /**
-         * Duration of the rate limit window in milliseconds.
-         */
-        duration?: number;
-        /**
-         * Group key for rate limiting (optional).
-         * BullMQ only: allows per-group rate limiting
-         */
-        groupKey?: string;
-    };
-}
-export interface WorkerConfig {
-    /**
-     * Number of jobs to process concurrently.
-     * BullMQ: concurrency, PGBoss: teamSize
-     */
-    concurrency?: number;
-    /**
-     * Lock duration in milliseconds.
-     * BullMQ: lockDuration, PGBoss: newJobCheckInterval (similar concept)
-     */
-    lockDurationMs?: number;
-    /**
-     * Maximum number of times a job can be stalled before being failed.
-     * BullMQ: maxStalledCount, PGBoss: not directly supported
-     */
-    maxStalledCount?: number;
-    /**
-     * Delay in milliseconds before processing jobs after queue is drained.
-     * BullMQ: drainDelay, PGBoss: not directly supported
-     */
-    drainDelayMs?: number;
-    /**
-     * Automatically run worker on startup.
-     * BullMQ: autorun, PGBoss: workers start automatically
-     */
-    autorun?: boolean;
-    /**
-     * Polling interval in milliseconds for checking new jobs.
-     * PGBoss: newJobCheckInterval, BullMQ: uses blocking wait
-     */
-    pollingIntervalMs?: number;
-}
-export interface QueueWorkerConfig {
-    queue?: QueueConfig;
-    flow?: FlowConfig;
-    worker?: WorkerConfig;
-}
-export type DefineQueueConfig = <T extends QueueWorkerConfig>(cfg: T) => T;
-export declare const defineQueueConfig: DefineQueueConfig;
-export default defineQueueConfig;

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/defineQueueWorker.js

@@ -1,17 +0,0 @@
-import { $useQueueRegistry, useFlowEngine, useQueue } from "#imports";
-export const defineQueueWorker = (handler) => {
-  const wrapped = async (input, ctx) => {
-    const provider = useQueue();
-    const flow = ctx.flow || useFlowEngine();
-    const registry = $useQueueRegistry();
-    const extended = {
-      ...ctx,
-      provider,
-      flow,
-      registry
-    };
-    return handler(input, extended);
-  };
-  return wrapped;
-};
-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[]>;
-};