nvent 0.4.4 → 0.4.5

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

@@ -1,348 +0,0 @@
-import { useRuntimeConfig, useNventLogger } from "#imports";
-import IORedis from "ioredis";
-import { RedisPubSubGateway } from "./redisPubSubGateway.js";
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-export function createRedisAdapter() {
-  const rc = useRuntimeConfig();
-  const logger = useNventLogger("redis-adapter");
-  const conn = rc?.queue?.eventStore?.redis || {};
-  const rsOpts = rc?.queue?.eventStore?.options?.redisStreams || {};
-  const redis = new IORedis({
-    host: conn.host,
-    port: conn.port,
-    username: conn.username,
-    password: conn.password,
-    lazyConnect: true,
-    enableReadyCheck: false
-    // Disable ready check to avoid INFO command conflicts
-  });
-  const subscriber = new IORedis({
-    host: conn.host,
-    port: conn.port,
-    username: conn.username,
-    password: conn.password,
-    lazyConnect: true,
-    enableReadyCheck: false
-  });
-  const gateway = new RedisPubSubGateway(subscriber);
-  function buildFields(e) {
-    const dataStr = e.data !== void 0 ? JSON.stringify(e.data) : "";
-    const fields = [
-      "type",
-      String(e.type || ""),
-      "runId",
-      String(e.runId || ""),
-      "flowName",
-      String(e.flowName || ""),
-      "data",
-      dataStr,
-      "ts",
-      e.ts || nowIso()
-    ];
-    if (e.stepName) {
-      fields.push("stepName", String(e.stepName));
-    }
-    if (e.stepId) {
-      fields.push("stepId", String(e.stepId));
-    }
-    if (e.attempt !== void 0) {
-      fields.push("attempt", String(e.attempt));
-    }
-    return fields;
-  }
-  function parseFieldsToRecord(id, arr) {
-    const obj = {};
-    for (let i = 0; i < arr.length; i += 2) {
-      const k = String(arr[i]);
-      const v = String(arr[i + 1] ?? "");
-      obj[k] = v;
-    }
-    let data;
-    try {
-      data = obj.data ? JSON.parse(obj.data) : void 0;
-    } catch {
-      data = void 0;
-    }
-    const rec = {
-      id,
-      ts: obj.ts || nowIso(),
-      type: obj.type || "event",
-      runId: obj.runId || "",
-      flowName: obj.flowName || "",
-      data
-    };
-    if (obj.stepName) rec.stepName = obj.stepName;
-    if (obj.stepId) rec.stepId = obj.stepId;
-    if (obj.attempt) rec.attempt = Number.parseInt(obj.attempt, 10);
-    return rec;
-  }
-  return {
-    async append(subject, e) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const ts = nowIso();
-      const payloadFields = buildFields({ ...e, ts });
-      const stream = subject;
-      let id;
-      if (rsOpts?.trim?.maxLen && rsOpts.trim.maxLen > 0) {
-        const approx = rsOpts?.trim?.approx !== false;
-        const args = approx ? ["MAXLEN", "~", String(rsOpts.trim.maxLen)] : ["MAXLEN", String(rsOpts.trim.maxLen)];
-        id = await redis.xadd(stream, ...args, "*", ...payloadFields);
-      } else {
-        id = await redis.xadd(stream, "*", ...payloadFields);
-      }
-      const channel = `nq:events:${subject}`;
-      await redis.publish(channel, id);
-      if (process.env.NQ_DEBUG_EVENTS === "1") {
-        logger.info("[redis-streams] appended and published", { stream, id, channel, type: e.type });
-      }
-      const rec = { ...e, id, ts, subject };
-      return rec;
-    },
-    async read(subject, opts) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const from = opts?.fromId ? opts.fromId : "0-0";
-      const count = opts?.limit || 100;
-      const dir = opts?.direction || "forward";
-      const stream = subject;
-      let resp = [];
-      if (dir === "backward") {
-        resp = await redis.xrevrange(stream, from === "0-0" ? "+" : `(${from}`, "-", "COUNT", count);
-      } else {
-        resp = await redis.xrange(stream, from === "0-0" ? "-" : `(${from}`, "+", "COUNT", count);
-      }
-      const out = [];
-      for (const [id, arr] of resp) {
-        try {
-          const rec = parseFieldsToRecord(id, arr);
-          out.push(rec);
-        } catch {
-        }
-      }
-      return out;
-    },
-    async subscribe(subject, onEvent) {
-      const stream = subject;
-      const channel = `nq:events:${subject}`;
-      if (!redis.status || redis.status === "end") await redis.connect();
-      let running = true;
-      if (process.env.NQ_DEBUG_EVENTS === "1") {
-        logger.info("[redis-streams] subscribing", { stream, channel });
-      }
-      const messageHandler = async (messageId) => {
-        if (!running) return;
-        try {
-          const entries = await redis.xrange(stream, messageId, messageId, "COUNT", 1);
-          if (entries && entries.length > 0) {
-            const [id, arr] = entries[0];
-            const rec = parseFieldsToRecord(id, arr);
-            if (process.env.NQ_DEBUG_EVENTS === "1") {
-              logger.info("[redis-streams] received event", { stream, id, type: rec.type });
-            }
-            onEvent(rec);
-          }
-        } catch (err) {
-          if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.error("[redis-streams] message handling error:", err);
-          }
-        }
-      };
-      const unsubscribe = await gateway.subscribe(channel, messageHandler);
-      return {
-        unsubscribe() {
-          running = false;
-          unsubscribe();
-        }
-      };
-    },
-    async indexAdd(key, id, score, metadata) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      await redis.zadd(key, score, id);
-      if (metadata) {
-        const metaKey = `${key}:meta:${id}`;
-        const toStore = { version: "0" };
-        for (const [k, v] of Object.entries(metadata)) {
-          toStore[k] = Array.isArray(v) ? JSON.stringify(v) : String(v);
-        }
-        await redis.hset(metaKey, toStore);
-      }
-    },
-    async indexRead(key, opts) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const offset = opts?.offset || 0;
-      const limit = opts?.limit || 50;
-      const end = offset + limit - 1;
-      const results = await redis.zrevrange(key, offset, end, "WITHSCORES");
-      const entries = [];
-      for (let i = 0; i < results.length; i += 2) {
-        const id = results[i];
-        const score = Number.parseInt(results[i + 1]);
-        const metaKey = `${key}:meta:${id}`;
-        const metadata = await redis.hgetall(metaKey);
-        let parsedMetadata = void 0;
-        if (Object.keys(metadata).length > 0) {
-          parsedMetadata = { ...metadata };
-          if (parsedMetadata.emittedEvents) {
-            parsedMetadata.emittedEvents = JSON.parse(parsedMetadata.emittedEvents);
-          }
-          if (parsedMetadata.version !== void 0) {
-            parsedMetadata.version = Number.parseInt(parsedMetadata.version, 10);
-          }
-          if (parsedMetadata.startedAt !== void 0) {
-            parsedMetadata.startedAt = Number.parseInt(parsedMetadata.startedAt, 10);
-          }
-          if (parsedMetadata.completedAt !== void 0) {
-            parsedMetadata.completedAt = Number.parseInt(parsedMetadata.completedAt, 10);
-          }
-          if (parsedMetadata.stepCount !== void 0) {
-            parsedMetadata.stepCount = Number.parseInt(parsedMetadata.stepCount, 10);
-          }
-          if (parsedMetadata.completedSteps !== void 0) {
-            parsedMetadata.completedSteps = Number.parseInt(parsedMetadata.completedSteps, 10);
-          }
-        }
-        entries.push({
-          id,
-          score,
-          metadata: parsedMetadata
-        });
-      }
-      return entries;
-    },
-    async indexGet(key, id) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const score = await redis.zscore(key, id);
-      if (!score) return null;
-      const metaKey = `${key}:meta:${id}`;
-      const metadata = await redis.hgetall(metaKey);
-      if (Object.keys(metadata).length === 0) {
-        return { id, score: Number.parseFloat(score) };
-      }
-      const parsed = { ...metadata };
-      if (parsed.emittedEvents) {
-        parsed.emittedEvents = JSON.parse(parsed.emittedEvents);
-      }
-      if (parsed.version !== void 0) {
-        parsed.version = Number.parseInt(parsed.version, 10);
-      }
-      if (parsed.startedAt !== void 0) {
-        parsed.startedAt = Number.parseInt(parsed.startedAt, 10);
-      }
-      if (parsed.completedAt !== void 0) {
-        parsed.completedAt = Number.parseInt(parsed.completedAt, 10);
-      }
-      if (parsed.stepCount !== void 0) {
-        parsed.stepCount = Number.parseInt(parsed.stepCount, 10);
-      }
-      if (parsed.completedSteps !== void 0) {
-        parsed.completedSteps = Number.parseInt(parsed.completedSteps, 10);
-      }
-      return {
-        id,
-        score: Number.parseFloat(score),
-        metadata: parsed
-      };
-    },
-    async indexUpdate(key, id, metadata) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const metaKey = `${key}:meta:${id}`;
-      const current = await redis.hget(metaKey, "version");
-      const currentVersion = current ? Number.parseInt(current, 10) : 0;
-      const script = `
-        local current = redis.call('HGET', KEYS[1], 'version')
-        if current == ARGV[1] then
-          for i = 2, #ARGV, 2 do
-            redis.call('HSET', KEYS[1], ARGV[i], ARGV[i + 1])
-          end
-          redis.call('HSET', KEYS[1], 'version', tonumber(ARGV[1]) + 1)
-          return 1
-        else
-          return 0
-        end
-      `;
-      const args = [currentVersion.toString()];
-      for (const [k, v] of Object.entries(metadata)) {
-        if (v === void 0) continue;
-        args.push(k);
-        if (Array.isArray(v)) {
-          args.push(JSON.stringify(v.filter((item) => item != null)));
-        } else {
-          args.push(String(v));
-        }
-      }
-      const result = await redis.eval(script, 1, metaKey, ...args);
-      return result === 1;
-    },
-    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) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const metaKey = `${key}:meta:${id}`;
-      const newValue = await redis.hincrby(metaKey, field, increment);
-      await redis.hincrby(metaKey, "version", 1);
-      return newValue;
-    },
-    async setMetadataTTL(flowName, runId, ttlSeconds) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const metaKey = `nq:flow:idx:${flowName}:meta:${runId}`;
-      await redis.expire(metaKey, ttlSeconds);
-    },
-    async cleanupCompletedFlows(key, retentionSeconds) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      const now = Date.now();
-      const cutoffTime = now - retentionSeconds * 1e3;
-      const oldEntries = await redis.zrangebyscore(key, "-inf", cutoffTime);
-      let removedCount = 0;
-      for (const runId of oldEntries) {
-        const metaKey = `${key}:meta:${runId}`;
-        const metadata = await redis.hgetall(metaKey);
-        if (metadata && (metadata.status === "completed" || metadata.status === "failed")) {
-          await redis.zrem(key, runId);
-          await redis.del(metaKey);
-          removedCount++;
-        }
-      }
-      return removedCount;
-    },
-    async deleteStream(subject) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      await redis.del(subject);
-    },
-    async deleteByPattern(pattern) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      let cursor = "0";
-      const keysToDelete = [];
-      do {
-        const result = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
-        cursor = result[0];
-        const keys = result[1];
-        if (keys.length > 0) {
-          keysToDelete.push(...keys);
-        }
-      } while (cursor !== "0");
-      if (keysToDelete.length > 0) {
-        await redis.del(...keysToDelete);
-      }
-      return keysToDelete.length;
-    },
-    async deleteIndex(key) {
-      if (!redis.status || redis.status === "end") await redis.connect();
-      await redis.del(key);
-    },
-    async close() {
-      try {
-        await gateway.cleanup();
-        await redis.quit();
-        await subscriber.quit();
-      } catch {
-      }
-    }
-  };
-}

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

@@ -1,30 +0,0 @@
-import type IORedis from 'ioredis';
-/**
- * Gateway pattern for Redis Pub/Sub
- * Maintains a single 'message' listener and routes to channel-specific handlers
- */
-export declare class RedisPubSubGateway {
-    private subscriber;
-    private channelSubscribers;
-    private initialized;
-    private logger;
-    constructor(subscriber: IORedis);
-    private initialize;
-    /**
-     * Subscribe to a channel with a handler
-     * Returns unsubscribe function
-     */
-    subscribe(channel: string, handler: (messageId: string) => void): Promise<() => void>;
-    /**
-     * Get subscriber count for a channel (for debugging)
-     */
-    getSubscriberCount(channel: string): number;
-    /**
-     * Get total subscriber count across all channels
-     */
-    getTotalSubscriberCount(): number;
-    /**
-     * Cleanup all subscriptions
-     */
-    cleanup(): Promise<void>;
-}

package/dist/runtime/server-utils/events/adapters/redis/redisPubSubGateway.js

@@ -1,82 +0,0 @@
-import { useNventLogger } from "#imports";
-export class RedisPubSubGateway {
-  constructor(subscriber) {
-    this.subscriber = subscriber;
-  }
-  channelSubscribers = /* @__PURE__ */ new Map();
-  initialized = false;
-  logger = useNventLogger("redis-pubsub-gateway");
-  initialize() {
-    if (this.initialized) return;
-    this.initialized = true;
-    this.subscriber.on("message", (channel, messageId) => {
-      const handlers = this.channelSubscribers.get(channel);
-      if (!handlers || handlers.size === 0) return;
-      for (const handler of handlers) {
-        try {
-          handler(messageId);
-        } catch (err) {
-          if (process.env.NQ_DEBUG_EVENTS === "1") {
-            this.logger.error("[redis-pubsub-gateway] Handler error:", err);
-          }
-        }
-      }
-    });
-  }
-  /**
-   * Subscribe to a channel with a handler
-   * Returns unsubscribe function
-   */
-  async subscribe(channel, handler) {
-    this.initialize();
-    if (!this.channelSubscribers.has(channel)) {
-      this.channelSubscribers.set(channel, /* @__PURE__ */ new Set());
-      await this.subscriber.subscribe(channel);
-      if (process.env.NQ_DEBUG_EVENTS === "1") {
-        this.logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
-      }
-    }
-    this.channelSubscribers.get(channel).add(handler);
-    return () => {
-      const handlers = this.channelSubscribers.get(channel);
-      if (handlers) {
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-          this.channelSubscribers.delete(channel);
-          this.subscriber.unsubscribe(channel).catch(() => {
-          });
-          if (process.env.NQ_DEBUG_EVENTS === "1") {
-            this.logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
-          }
-        }
-      }
-    };
-  }
-  /**
-   * Get subscriber count for a channel (for debugging)
-   */
-  getSubscriberCount(channel) {
-    return this.channelSubscribers.get(channel)?.size ?? 0;
-  }
-  /**
-   * Get total subscriber count across all channels
-   */
-  getTotalSubscriberCount() {
-    let count = 0;
-    for (const handlers of this.channelSubscribers.values()) {
-      count += handlers.size;
-    }
-    return count;
-  }
-  /**
-   * Cleanup all subscriptions
-   */
-  async cleanup() {
-    const channels = Array.from(this.channelSubscribers.keys());
-    this.channelSubscribers.clear();
-    if (channels.length > 0) {
-      await this.subscriber.unsubscribe(...channels).catch(() => {
-      });
-    }
-  }
-}

package/dist/runtime/server-utils/events/eventStoreFactory.d.ts

@@ -1,19 +0,0 @@
-import { getStreamNames } from './streamNames.js';
-import type { EventStoreAdapter } from './types.js';
-export interface EventStoreInstance {
-    name: string;
-    append: EventStoreAdapter['append'];
-    read: EventStoreAdapter['read'];
-    subscribe: EventStoreAdapter['subscribe'];
-}
-export interface EventStoreFactory {
-    adapter: EventStoreAdapter;
-    names: ReturnType<typeof getStreamNames>;
-    stream(name: string): EventStoreInstance;
-    /** Idempotently start stream store wiring that persists ingress events and projections */
-    start(): void;
-    /** Stop wiring and release listeners */
-    stop(): void;
-}
-export declare function getEventStoreFactory(): EventStoreFactory;
-export declare function setEventStoreFactory(f: EventStoreFactory): void;

package/dist/runtime/server-utils/events/eventStoreFactory.js

@@ -1,44 +0,0 @@
-import { useRuntimeConfig, useNventLogger } from "#imports";
-import { getStreamNames } from "./streamNames.js";
-import { createRedisAdapter } from "./adapters/redis/redisAdapter.js";
-import { createMemoryAdapter } from "./adapters/memoryAdapter.js";
-import { createFileAdapter } from "./adapters/fileAdapter.js";
-import { createWiringRegistry } from "./wiring/registry.js";
-let cachedFactory = null;
-export function getEventStoreFactory() {
-  if (cachedFactory) return cachedFactory;
-  const logger = useNventLogger("event-store-factory");
-  const rc = useRuntimeConfig();
-  const adapter = rc?.queue?.eventStore?.adapter || "memory";
-  let adapterInstance;
-  if (adapter === "memory") adapterInstance = createMemoryAdapter();
-  else if (adapter === "file") adapterInstance = createFileAdapter();
-  else if (adapter === "redis") adapterInstance = createRedisAdapter();
-  else adapterInstance = createMemoryAdapter();
-  logger.debug("Event store initialized", { adapter, adapterType: adapter });
-  const names = getStreamNames();
-  const wiring = createWiringRegistry({ adapter: adapterInstance, names });
-  const factory = {
-    adapter: adapterInstance,
-    names,
-    stream(name) {
-      return {
-        name,
-        append: (s, e) => adapterInstance.append(s, e),
-        read: (s, o) => adapterInstance.read(s, o),
-        subscribe: (s, cb) => adapterInstance.subscribe(s, cb)
-      };
-    },
-    start() {
-      wiring.start();
-    },
-    stop() {
-      wiring.stop();
-    }
-  };
-  cachedFactory = factory;
-  return factory;
-}
-export function setEventStoreFactory(f) {
-  cachedFactory = f;
-}

package/dist/runtime/server-utils/events/streamNames.d.ts

@@ -1,17 +0,0 @@
-/**
- * Stream naming utilities
- *
- * Core streams:
- * - nq:flow:{runId}        - Flow run event stream
- * - nq:flows:{flowName}    - Sorted set index of flow runs by flow name
- */
-export interface StreamNamesConfig {
-    flow?: string | ((runId: string) => string);
-    flowIndex?: string | ((flowName: string) => string);
-}
-export interface StreamNames {
-    flow: (runId: string) => string;
-    flowIndex: (flowName: string) => string;
-}
-export declare function getStreamNames(): StreamNames;
-export default getStreamNames;

package/dist/runtime/server-utils/events/streamNames.js

@@ -1,17 +0,0 @@
-import { useRuntimeConfig } from "#imports";
-function defaults() {
-  return {
-    flow: (runId) => `nq:flow:${runId}`,
-    flowIndex: (flowName) => `nq:flows:${flowName}`
-  };
-}
-export function getStreamNames() {
-  const rc = useRuntimeConfig();
-  const cfg = rc?.queue?.eventStore?.streams || {};
-  const d = defaults();
-  return {
-    flow: typeof cfg.flow === "string" ? (runId) => `${cfg.flow}${runId}` : cfg.flow || d.flow,
-    flowIndex: typeof cfg.flowIndex === "string" ? (flowName) => `${cfg.flowIndex}${flowName}` : cfg.flowIndex || d.flowIndex
-  };
-}
-export default getStreamNames;

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

@@ -1,63 +0,0 @@
-import type { EventRecord } from '../types.js';
-export interface PublishContext {
-    queue?: string;
-    jobId?: string;
-    /** Flow run ID for flow events */
-    flowId?: string;
-    /** Trigger ID for trigger events */
-    triggerId?: string;
-}
-export interface PublishPayload<T = any> {
-    type: string;
-    runId: string;
-    flowName: string;
-    stepName?: string;
-    stepId?: string;
-    attempt?: number;
-    data?: T;
-}
-export interface EventReadOptions {
-    fromId?: string;
-    limit?: number;
-    direction?: 'forward' | 'backward';
-}
-export interface EventSubscription {
-    unsubscribe(): void;
-}
-export interface IndexEntry {
-    id: string;
-    score: number;
-    metadata?: {
-        status?: 'running' | 'completed' | 'failed';
-        startedAt?: number;
-        completedAt?: number;
-        stepCount?: number;
-        completedSteps?: number;
-        emittedEvents?: string[];
-        version?: number;
-    };
-}
-export interface IndexReadOptions {
-    offset?: number;
-    limit?: number;
-}
-export interface EventStoreAdapter {
-    append(subject: string, e: Omit<EventRecord, 'id' | 'ts'>): Promise<EventRecord>;
-    read(subject: string, opts?: EventReadOptions): Promise<EventRecord[]>;
-    subscribe(subject: string, onEvent: (e: EventRecord) => void): Promise<EventSubscription>;
-    indexAdd?(key: string, id: string, score: number, metadata?: Record<string, any>): Promise<void>;
-    indexGet?(key: string, id: string): Promise<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?: IndexReadOptions): Promise<IndexEntry[]>;
-    setMetadataTTL?(flowName: string, runId: string, ttlSeconds: number): Promise<void>;
-    cleanupCompletedFlows?(key: string, retentionSeconds: number): Promise<number>;
-    /** Delete a specific stream/subject */
-    deleteStream?(subject: string): Promise<void>;
-    /** Delete all streams matching a pattern (e.g., 'flow:*' or 'trigger:webhook-*') */
-    deleteByPattern?(pattern: string): Promise<number>;
-    /** Delete an index key */
-    deleteIndex?(key: string): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/runtime/server-utils/events/wiring/registry.d.ts

@@ -1,10 +0,0 @@
-import type { StreamAdapter } from '../types.js';
-export interface WiringDeps {
-    adapter: StreamAdapter;
-    names?: any;
-}
-export interface Wiring {
-    start(): void;
-    stop(): void;
-}
-export declare function createWiringRegistry(deps: WiringDeps): Wiring;

package/dist/runtime/server-utils/events/wiring/registry.js

@@ -1,24 +0,0 @@
-import { createFlowWiring } from "./flowWiring.js";
-export function createWiringRegistry(deps) {
-  const wirings = [
-    createFlowWiring({ adapter: deps.adapter })
-    // add future wirings here (triggers, webhooks, etc.)
-  ];
-  let started = false;
-  return {
-    start() {
-      if (started) return;
-      started = true;
-      for (const w of wirings) w.start();
-    },
-    stop() {
-      for (const w of wirings) {
-        try {
-          w.stop();
-        } catch {
-        }
-      }
-      started = false;
-    }
-  };
-}

package/dist/runtime/server-utils/queue/adapters/bullmq.d.ts

@@ -1,18 +0,0 @@
-import type { QueueProvider, JobInput, Job, JobsQuery, ScheduleOptions, QueueEvent, JobCounts } from '../types.js';
-export declare class BullMQProvider implements QueueProvider {
-    private queues;
-    private logger;
-    init(): Promise<void>;
-    private ensureQueue;
-    enqueue(queueName: string, job: JobInput): Promise<string>;
-    schedule(queueName: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
-    getJob(queueName: string, id: string): Promise<Job | null>;
-    getJobs(queueName: string, _q?: JobsQuery): Promise<Job[]>;
-    on(queueName: string, event: QueueEvent, cb: (p: any) => void): () => void;
-    isPaused(queueName: string): Promise<boolean>;
-    getJobCounts(queueName: string): Promise<JobCounts>;
-    pause(queueName: string): Promise<void>;
-    resume(queueName: string): Promise<void>;
-    close(): Promise<void>;
-    private toJob;
-}