nvent 0.4.4 → 0.5.0

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
-  };
-}

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/server-utils/worker/runner/node.d.ts

@@ -1,27 +0,0 @@
-import type { Job as BullJob } from 'bullmq';
-import { useFlowEngine } from '#imports';
-export interface RunLogger {
-    log: (level: 'debug' | 'info' | 'warn' | 'error', msg: string, meta?: any) => void;
-}
-export interface RunState {
-    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>;
-}
-export interface RunContext {
-    jobId?: string;
-    queue?: string;
-    flowId?: string;
-    flowName?: string;
-    stepName?: string;
-    stepId?: string;
-    attempt?: number;
-    logger: RunLogger;
-    state: RunState;
-    flow: ReturnType<typeof useFlowEngine>;
-}
-export declare function buildContext(partial?: Partial<RunContext>): RunContext;
-export type NodeHandler = (input: any, ctx: RunContext) => Promise<any>;
-export declare function createBullMQProcessor(handler: NodeHandler, queueName: string): (job: BullJob) => Promise<any>;

package/dist/runtime/server-utils/worker/runner/node.js

@@ -1,196 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { getStateProvider } from "../../state/stateFactory.js";
-import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useNventLogger } from "#imports";
-const defaultState = {
-  async get() {
-    return null;
-  },
-  async set() {
-  },
-  async delete() {
-  }
-};
-function scopeKey(baseKey, flowId) {
-  if (!flowId) return baseKey;
-  return `flow:${flowId}:${baseKey}`;
-}
-export function buildContext(partial) {
-  const state = partial?.state || (() => {
-    try {
-      const state2 = getStateProvider();
-      const rc = useRuntimeConfig();
-      const cleanupCfg = rc?.queue?.state?.cleanup || { strategy: "never" };
-      return {
-        async get(key) {
-          return state2.get(scopeKey(key, partial?.flowId));
-        },
-        async set(key, value, opts) {
-          const ttl = opts?.ttl ?? (cleanupCfg?.strategy === "ttl" ? cleanupCfg?.ttlMs : void 0);
-          return state2.set(scopeKey(key, partial?.flowId), value, ttl ? { ttl } : void 0);
-        },
-        async delete(key) {
-          return state2.delete(scopeKey(key, partial?.flowId));
-        }
-      };
-    } catch {
-      return defaultState;
-    }
-  })();
-  const logger = partial?.logger || (() => {
-    const logs = useLogs();
-    return {
-      log: (level, msg, meta) => {
-        const mergedMeta = { ...meta || {} };
-        void logs.publishLog(level, msg, mergedMeta, { queue: partial?.queue, jobId: partial?.jobId, flowId: partial?.flowId });
-      }
-    };
-  })();
-  const baseFlowEngine = useFlowEngine();
-  const flow = {
-    ...baseFlowEngine,
-    emit: async (trigger, payload = {}) => {
-      const enrichedPayload = {
-        ...payload,
-        flowId: payload.flowId || partial?.flowId,
-        flowName: payload.flowName || partial?.flowName
-      };
-      return baseFlowEngine.emit(trigger, enrichedPayload);
-    }
-  };
-  return {
-    jobId: partial?.jobId,
-    queue: partial?.queue,
-    flowId: partial?.flowId,
-    flowName: partial?.flowName,
-    stepName: partial?.stepName,
-    stepId: partial?.stepId,
-    attempt: partial?.attempt,
-    logger,
-    state,
-    flow
-  };
-}
-export function createBullMQProcessor(handler, queueName) {
-  const logger = useNventLogger("node-runner");
-  return async function processor(job) {
-    if (job.data?.__scheduledFlowStart) {
-      const { __flowName, __flowInput } = job.data;
-      try {
-        const { startFlow } = useFlowEngine();
-        const result2 = await startFlow(__flowName, __flowInput || {});
-        return {
-          scheduled: true,
-          flowId: result2.flowId,
-          flowName: __flowName
-        };
-      } catch (err) {
-        logger.error("[scheduled-flow] Failed to start flow:", err);
-        throw err;
-      }
-    }
-    const eventMgr = useEventManager();
-    const rc = useRuntimeConfig();
-    const autoScope = rc?.queue?.state?.autoScope || "always";
-    const providedFlow = job.data?.flowId;
-    const flowId = providedFlow || (autoScope === "always" ? randomUUID() : void 0);
-    const attempt = (job.attemptsMade || 0) + 1;
-    const maxAttempts = job.opts?.attempts || 1;
-    const isFinalAttempt = attempt >= maxAttempts;
-    const stepRunId = `${String(flowId || job.id)}__${job.name}__attempt-${attempt}`;
-    const flowName = job.data?.flowName || "unknown";
-    const ctx = buildContext({
-      jobId: job.id,
-      queue: queueName,
-      flowId,
-      flowName,
-      stepName: job.name,
-      stepId: stepRunId,
-      attempt
-    });
-    const attemptLogger = {
-      log: (level, msg, meta) => {
-        const enriched = { ...meta || {}, stepName: job.name, attempt, stepRunId, flowName };
-        ctx.logger.log(level, msg, enriched);
-      }
-    };
-    try {
-      await eventMgr.publishBus({
-        type: "step.started",
-        runId: flowId || "unknown",
-        flowName,
-        stepName: job.name,
-        stepId: stepRunId,
-        attempt,
-        data: { jobId: job.id, name: job.name, queue: queueName }
-      });
-    } catch {
-    }
-    let result;
-    try {
-      const workerInput = job.data?.input !== void 0 ? job.data.input : job.data;
-      result = await handler(workerInput, { ...ctx, logger: attemptLogger });
-    } catch (err) {
-      logger.error(`[worker] Job failed: ${job.name} (${job.id})`, {
-        queue: queueName,
-        flowId,
-        flowName,
-        stepName: job.name,
-        error: err?.message || String(err),
-        stack: err?.stack
-      });
-      const willRetry = !isFinalAttempt;
-      try {
-        await eventMgr.publishBus({
-          type: "step.failed",
-          runId: flowId || "unknown",
-          flowName,
-          stepName: job.name,
-          stepId: stepRunId,
-          attempt,
-          data: {
-            error: String(err?.message || err),
-            stack: err?.stack
-          }
-        });
-      } catch {
-      }
-      if (willRetry) {
-        try {
-          await eventMgr.publishBus({
-            type: "step.retry",
-            runId: flowId || "unknown",
-            flowName,
-            stepName: job.name,
-            stepId: stepRunId,
-            attempt,
-            data: {
-              stepName: job.name,
-              queue: queueName,
-              error: String(err?.message || err),
-              stack: err?.stack,
-              attempt,
-              maxAttempts,
-              nextAttempt: attempt + 1
-            }
-          });
-        } catch {
-        }
-      }
-      throw err;
-    }
-    try {
-      const eventMgr2 = useEventManager();
-      await eventMgr2.publishBus({
-        type: "step.completed",
-        runId: flowId || "unknown",
-        flowName,
-        stepName: job.name,
-        stepId: stepRunId,
-        attempt,
-        data: { result }
-      });
-    } catch {
-    }
-    return result;
-  };
-}

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