nvent 0.4.4 → 0.4.5

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

@@ -1,31 +0,0 @@
-import type { QueueEvent, JobsQuery, ScheduleOptions, JobInput, JobCounts } from '../queue/types.js';
-export declare const useQueue: () => {
-    enqueue: (queue: string, job: JobInput) => Promise<string>;
-    schedule: (queue: string, job: JobInput, opts?: ScheduleOptions) => Promise<string>;
-    getJob: (queue: string, id: string) => Promise<import("../queue/types.js").Job | null>;
-    getJobs: (queue: string, q?: JobsQuery) => Promise<import("../queue/types.js").Job[]>;
-    on: (queue: string, event: QueueEvent, cb: (p: any) => void) => () => void;
-    pause: (queue: string) => Promise<void>;
-    resume: (queue: string) => Promise<void>;
-    getJobCounts: (queue: string) => Promise<Record<string, number>> | {
-        new (executor: (resolve: (value: JobCounts | PromiseLike<JobCounts>) => void, reject: (reason?: any) => void) => void): Promise<JobCounts>;
-        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
-        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
-        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
-        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
-        readonly prototype: Promise<any>;
-        reject<T = never>(reason?: any): Promise<T>;
-        resolve(): Promise<void>;
-        resolve<T>(value: T): Promise<Awaited<T>>;
-        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
-        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
-        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
-        any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
-        any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
-        withResolvers<T>(): PromiseWithResolvers<T>;
-        try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>;
-        readonly [Symbol.species]: PromiseConstructor;
-    };
-    isPaused: (queue: string) => Promise<any>;
-    close: () => Promise<void>;
-};

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

@@ -1,24 +0,0 @@
-import { getQueueProvider } from "../queue/queueFactory.js";
-export const useQueue = () => {
-  const provider = getQueueProvider();
-  return {
-    // Enqueue immediately
-    enqueue: (queue, job) => provider.enqueue(queue, job),
-    // Schedule with optional delay or cron
-    schedule: (queue, job, opts) => provider.schedule(queue, job, opts),
-    // Fetch single job
-    getJob: (queue, id) => provider.getJob(queue, id),
-    // List jobs (provider decides states/pagination)
-    getJobs: (queue, q) => provider.getJobs(queue, q),
-    // Subscribe to provider-agnostic events
-    on: (queue, event, cb) => provider.on(queue, event, cb),
-    // Operational controls
-    pause: (queue) => provider.pause(queue),
-    resume: (queue) => provider.resume(queue),
-    // Optional helpers if provider exposes them
-    getJobCounts: (queue) => provider.getJobCounts ? provider.getJobCounts(queue) : Promise,
-    isPaused: (queue) => provider.isPaused ? provider.isPaused(queue) : Promise.resolve(void 0),
-    // Provider lifecycle (normally handled by plugin/provider)
-    close: () => provider.close()
-  };
-};

package/dist/runtime/server-utils/worker/adapter.d.ts

@@ -1,4 +0,0 @@
-import { Worker } from 'bullmq';
-import { type NodeHandler } from './runner/node.js';
-export declare function closeAllWorkers(): Promise<void>;
-export declare function registerTsWorker(queueName: string, jobName: string, handler: NodeHandler, opts?: any): Promise<Worker<any, any, string>>;

package/dist/runtime/server-utils/worker/adapter.js

@@ -1,66 +0,0 @@
-import { Worker } from "bullmq";
-import { createBullMQProcessor } from "./runner/node.js";
-import { useRuntimeConfig, useNventLogger } from "#imports";
-const registeredWorkers = /* @__PURE__ */ new Map();
-export async function closeAllWorkers() {
-  const logger = useNventLogger("worker-adapter");
-  const closePromises = [];
-  for (const [queueName, info] of registeredWorkers.entries()) {
-    closePromises.push(
-      info.worker.close().catch((err) => {
-        if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-          logger.warn("Error closing worker for queue", { queueName, error: err });
-        }
-      })
-    );
-  }
-  await Promise.allSettled(closePromises);
-  registeredWorkers.clear();
-  logger.info("[closeAllWorkers] All workers closed");
-}
-export async function registerTsWorker(queueName, jobName, handler, opts) {
-  let info = registeredWorkers.get(queueName);
-  const logger = useNventLogger("worker-adapter");
-  if (info) {
-    logger.info(`[registerTsWorker] Adding handler for job "${jobName}" to existing worker for queue "${queueName}"`);
-    info.handlers.set(jobName, handler);
-    return info.worker;
-  }
-  logger.info(`[registerTsWorker] Creating new worker for queue: ${queueName}`);
-  const handlers = /* @__PURE__ */ new Map();
-  handlers.set(jobName, handler);
-  const dispatcher = async (job) => {
-    const handler2 = handlers.get(job.name);
-    if (!handler2) {
-      const error = `[Worker] No handler registered for job "${job.name}" on queue "${queueName}". Available handlers: ${Array.from(handlers.keys()).join(", ")}`;
-      logger.error(error);
-      throw new Error(error);
-    }
-    const processor = createBullMQProcessor(handler2, queueName);
-    return processor(job);
-  };
-  const rc = useRuntimeConfig();
-  const connection = rc?.queue?.queue?.redis;
-  const shouldPause = opts?.autorun === false;
-  const worker = new Worker(queueName, dispatcher, { connection, ...opts || {} });
-  if (shouldPause) {
-    await worker.pause();
-    logger.info(`[registerTsWorker] Worker for queue "${queueName}" created but paused (autorun: false)`);
-  } else {
-    logger.info(`[registerTsWorker] Worker for queue "${queueName}" created and running`);
-  }
-  worker.on("error", (err) => {
-    logger.error(`[Worker] Error in worker for queue "${queueName}":`, err);
-  });
-  worker.on("failed", (job, err) => {
-    logger.error(`[Worker] Job failed in worker for queue "${queueName}":`, {
-      jobId: job?.id,
-      jobName: job?.name,
-      error: err.message,
-      stack: err.stack
-    });
-  });
-  info = { worker, handlers };
-  registeredWorkers.set(queueName, info);
-  return worker;
-}

package/dist/runtime/types.d.ts

@@ -1,132 +0,0 @@
-import type { WorkerOptions as BullmqWorkerOptions } from 'bullmq'
-import type z from 'zod'
-import type colors from 'tailwindcss/colors'
-import type { JobSchemaArray, JobSchema } from './schema'
-
-type NeutralColor = 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone'
-export type Color = Exclude<keyof typeof colors, 'inherit' | 'current' | 'transparent' | 'black' | 'white' | NeutralColor> | NeutralColor
-
-export type Jobs = z.infer<typeof JobSchemaArray>
-export type Job = z.infer<typeof JobSchema>
-
-export type WorkerOptions = Omit<BullmqWorkerOptions, 'connection' | 'useWorkerThreads'>
-
-export type WorkerConfig = Record<string, WorkerOptions>
-
-export type QueueData = {
-  name: string
-  origin: 'remote' | 'local'
-  active: boolean
-  jobs: JobCounts
-  worker: number
-}
-
-// Declarations for worker authoring helpers available via auto-imports at runtime
-// These declarations make TS happy in worker files and tests.
-export declare function defineQueueWorker(processor: (...args: any[]) => any): any
-export declare function defineQueueConfig(cfg: any): any
-
-// v0.4 Event Schema
-export type EventType = 'flow.start' | 'flow.completed' | 'flow.failed' | 'step.started' | 'step.completed' | 'step.failed' | 'step.retry' | 'log' | 'emit' | 'state'
-
-export interface BaseEvent {
-  id?: string // Redis stream ID (auto-generated, not present for ingress events)
-  ts?: string // ISO timestamp (auto-generated, not present for ingress events)
-  type: EventType
-  runId: string // Flow run UUID
-  flowName: string // Flow definition name
-}
-
-export interface StepEvent extends BaseEvent {
-  stepName: string
-  stepId: string
-  attempt: number
-}
-
-export interface FlowStartEvent extends BaseEvent {
-  type: 'flow.start'
-  data?: {
-    input?: any
-  }
-}
-
-export interface FlowCompletedEvent extends BaseEvent {
-  type: 'flow.completed'
-  data?: {
-    result?: any
-  }
-}
-
-export interface FlowFailedEvent extends BaseEvent {
-  type: 'flow.failed'
-  data?: {
-    error?: string
-    stack?: string
-  }
-}
-
-export interface StepStartedEvent extends StepEvent {
-  type: 'step.started'
-  data?: {
-    input?: any
-  }
-}
-
-export interface StepCompletedEvent extends StepEvent {
-  type: 'step.completed'
-  data?: {
-    result?: any
-  }
-}
-
-export interface StepFailedEvent extends StepEvent {
-  type: 'step.failed'
-  data?: {
-    error?: string
-    stack?: string
-  }
-}
-
-export interface StepRetryEvent extends StepEvent {
-  type: 'step.retry'
-  data?: {
-    stepName: string
-    queue: string
-    error?: string
-    stack?: string
-    attempt: number
-    maxAttempts: number
-    nextAttempt: number
-  }
-}
-
-export interface LogEvent extends StepEvent {
-  type: 'log'
-  data: {
-    level: 'debug' | 'info' | 'warn' | 'error'
-    message: string
-    [key: string]: any
-  }
-}
-
-export interface EmitEvent extends StepEvent {
-  type: 'emit'
-  data: {
-    topic: string
-    payload: any
-  }
-}
-
-export interface StateEvent extends StepEvent {
-  type: 'state'
-  data: {
-    operation: 'get' | 'set' | 'delete'
-    scope?: string
-    key: string
-    value?: any
-  }
-}
-
-export type FlowEvent = FlowStartEvent | FlowCompletedEvent | FlowFailedEvent | StepStartedEvent | StepCompletedEvent | StepFailedEvent | StepRetryEvent | LogEvent | EmitEvent | StateEvent
-
-export type EventRecord = FlowEvent