nvent 0.4.3 → 0.4.5

package/dist/runtime/app/pages/queues/jobs.vue

@@ -1,291 +0,0 @@
-<template>
-  <div class="h-full flex flex-col overflow-hidden">
-    <!-- Header -->
-    <div class="border-b border-gray-200 dark:border-gray-800 px-6 py-3 shrink-0">
-      <div class="flex items-center justify-between">
-        <div class="flex items-center gap-4">
-          <UButton
-            icon="i-lucide-arrow-left"
-            size="xs"
-            color="neutral"
-            variant="ghost"
-            @click="back"
-          />
-          <div>
-            <h1 class="text-lg font-semibold">
-              {{ queueName }}
-            </h1>
-            <p class="text-xs text-gray-500">
-              Queue Jobs
-            </p>
-          </div>
-        </div>
-        <div class="flex items-center gap-3">
-          <div
-            v-if="isConnected"
-            class="flex items-center gap-1.5 text-xs text-emerald-600 dark:text-emerald-400"
-          >
-            <div class="w-2 h-2 rounded-full bg-emerald-500 animate-pulse" />
-            <span>Live</span>
-            <span
-              v-if="isAutoRefreshing"
-              class="text-[10px] text-gray-400"
-            >
-              (updating...)
-            </span>
-          </div>
-          <div
-            v-else-if="isReconnecting"
-            class="flex items-center gap-1.5 text-xs text-amber-600 dark:text-amber-400"
-          >
-            <div class="w-2 h-2 rounded-full bg-amber-500 animate-pulse" />
-            <span>Reconnecting...</span>
-          </div>
-          <UBadge
-            :label="counts?.active.toString() || '0'"
-            color="warning"
-            variant="subtle"
-          >
-            <template #leading>
-              Active
-            </template>
-          </UBadge>
-          <UBadge
-            :label="counts?.waiting.toString() || '0'"
-            color="info"
-            variant="subtle"
-          >
-            <template #leading>
-              Waiting
-            </template>
-          </UBadge>
-          <UBadge
-            :label="counts?.completed.toString() || '0'"
-            color="success"
-            variant="subtle"
-          >
-            <template #leading>
-              Completed
-            </template>
-          </UBadge>
-          <UBadge
-            :label="counts?.failed.toString() || '0'"
-            color="error"
-            variant="subtle"
-          >
-            <template #leading>
-              Failed
-            </template>
-          </UBadge>
-          <USelectMenu
-            v-model="selectedStateOption"
-            :items="stateOptions"
-            placeholder="All States"
-            size="xs"
-            class="w-32"
-          />
-          <UButton
-            icon="i-lucide-refresh-cw"
-            size="xs"
-            color="neutral"
-            variant="ghost"
-            :loading="status === 'pending'"
-            @click.prevent="onRefresh"
-          >
-            Refresh
-          </UButton>
-        </div>
-      </div>
-    </div>
-
-    <!-- Main Content -->
-    <div class="flex-1 min-h-0 overflow-hidden flex flex-col">
-      <div
-        v-if="!data || !data.jobs || data.jobs.length === 0"
-        class="flex-1 flex items-center justify-center text-sm text-gray-400"
-      >
-        No jobs found
-      </div>
-      <template v-else>
-        <div class="flex-1 min-h-0 p-4 overflow-auto">
-          <UTable
-            ref="table"
-            v-model:pagination="pagination"
-            :data="data.jobs"
-            :columns="columns"
-            :loading="status === 'pending'"
-            :pagination-options="{
-  getPaginationRowModel: getPaginationRowModel()
-}"
-            :ui="{
-  base: 'table-fixed border-separate border-spacing-0',
-  thead: '[&>tr]:bg-elevated/50 [&>tr]:after:content-none',
-  tbody: '[&>tr]:last:[&>td]:border-b-0',
-  th: 'py-2 first:rounded-l-lg last:rounded-r-lg border-y border-default first:border-l last:border-r',
-  td: 'border-b border-default',
-  separator: 'h-0'
-}"
-          />
-        </div>
-
-        <div class="flex items-center justify-between gap-3 border-t border-default p-4 shrink-0">
-          <div class="text-sm text-muted">
-            Showing {{ Math.min(pagination.pageIndex * pagination.pageSize + pagination.pageSize, data.jobs.length) }} of {{ data.jobs.length }} job(s)
-            <span
-              v-if="selectedState"
-              class="text-gray-400"
-            >
-              (filtered by {{ selectedStateOption?.label }})
-            </span>
-          </div>
-          <div class="flex items-center gap-1.5">
-            <UPagination
-              :default-page="(table?.tableApi?.getState().pagination.pageIndex || 0) + 1"
-              :items-per-page="table?.tableApi?.getState().pagination.pageSize || 20"
-              :total="data.jobs.length"
-              @update:page="(p) => table?.tableApi?.setPageIndex(p - 1)"
-            />
-          </div>
-        </div>
-      </template>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, computed, watch } from "#imports";
-import { getPaginationRowModel } from "@tanstack/table-core";
-import { UTable, UButton, UBadge, UPagination, USelectMenu } from "#components";
-import { useQueueJobs } from "../../composables/useQueueJobs";
-import { useQueueUpdates } from "../../composables/useQueueUpdates";
-import { useComponentRouter } from "../../composables/useComponentRouter";
-const UBadgeComponent = resolveComponent("UBadge");
-const UButtonComponent = resolveComponent("UButton");
-const router = useComponentRouter();
-const queueName = computed(() => router.route.value?.params?.name || "");
-const stateOptions = [
-  { label: "All States", value: null },
-  { label: "Waiting", value: "waiting" },
-  { label: "Active", value: "active" },
-  { label: "Completed", value: "completed" },
-  { label: "Failed", value: "failed" },
-  { label: "Delayed", value: "delayed" },
-  { label: "Paused", value: "paused" }
-];
-const selectedStateOption = ref(stateOptions[0]);
-const selectedState = computed(() => selectedStateOption.value?.value ?? null);
-const { data, refresh, status } = useQueueJobs(queueName, selectedState);
-const { counts, isConnected, isReconnecting, shouldRefreshJobs, resetRefreshFlag } = useQueueUpdates(queueName);
-const isAutoRefreshing = ref(false);
-watch(selectedState, () => {
-  if (table.value?.tableApi) {
-    table.value.tableApi.setPageIndex(0);
-  }
-});
-watch(shouldRefreshJobs, async (shouldRefresh) => {
-  if (shouldRefresh) {
-    isAutoRefreshing.value = true;
-    await refresh();
-    resetRefreshFlag();
-    setTimeout(() => {
-      isAutoRefreshing.value = false;
-    }, 500);
-  }
-});
-const table = useTemplateRef("table");
-const pagination = ref({
-  pageIndex: 0,
-  pageSize: 20
-});
-const onRefresh = async () => {
-  await refresh();
-};
-const back = () => {
-  router.push("/queues");
-};
-const selectJob = (jobId) => {
-  router.push(`/queues/${queueName.value}/jobs/${jobId}`);
-};
-const columns = [
-  {
-    accessorKey: "id",
-    header: "Job ID",
-    cell: ({ row }) => {
-      const id = row.original.id;
-      return h("div", {
-        class: "font-mono text-xs cursor-pointer hover:underline",
-        onClick: () => selectJob(row.original.id)
-      }, id.length > 16 ? `${id.substring(0, 8)}...${id.substring(id.length - 8)}` : id);
-    }
-  },
-  {
-    accessorKey: "name",
-    header: "Name",
-    cell: ({ row }) => {
-      return h("div", {
-        class: "font-medium cursor-pointer hover:underline",
-        onClick: () => selectJob(row.original.id)
-      }, row.original.name);
-    }
-  },
-  {
-    accessorKey: "state",
-    header: "State",
-    cell: ({ row }) => {
-      const state = row.original.state;
-      const colorMap = {
-        waiting: "info",
-        active: "warning",
-        completed: "success",
-        failed: "error",
-        delayed: "secondary",
-        paused: "warning"
-      };
-      return h(UBadgeComponent, {
-        label: state || "unknown",
-        color: colorMap[state || ""] || "neutral",
-        variant: "subtle",
-        class: "capitalize"
-      });
-    }
-  },
-  {
-    accessorKey: "timestamp",
-    header: "Created",
-    cell: ({ row }) => {
-      const timestamp = row.original.timestamp;
-      if (!timestamp) return h("div", { class: "text-gray-400 text-xs" }, "-");
-      const date = new Date(timestamp);
-      return h(
-        "div",
-        { class: "text-xs" },
-        date.toLocaleString("de-DE", {
-          timeZone: "Europe/Berlin",
-          day: "2-digit",
-          month: "2-digit",
-          year: "numeric",
-          hour: "2-digit",
-          minute: "2-digit",
-          second: "2-digit"
-        })
-      );
-    }
-  },
-  {
-    id: "actions",
-    header: "",
-    cell: ({ row }) => {
-      return h(UButtonComponent, {
-        icon: "i-lucide-arrow-right",
-        size: "xs",
-        color: "neutral",
-        variant: "ghost",
-        square: true,
-        onClick: () => {
-          selectJob(row.original.id);
-        }
-      });
-    }
-  }
-];
-</script>

package/dist/runtime/app/pages/queues/jobs.vue.d.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/app/plugins/vueflow.client.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
-export default _default;

package/dist/runtime/app/plugins/vueflow.client.js

@@ -1,11 +0,0 @@
-import { defineNuxtPlugin } from "#imports";
-import { VueFlow } from "@vue-flow/core";
-import { Controls } from "@vue-flow/controls";
-import { MiniMap } from "@vue-flow/minimap";
-import { Background } from "@vue-flow/background";
-export default defineNuxtPlugin((nuxtApp) => {
-  nuxtApp.vueApp.component("VueFlow", VueFlow);
-  nuxtApp.vueApp.component("Controls", Controls);
-  nuxtApp.vueApp.component("MiniMap", MiniMap);
-  nuxtApp.vueApp.component("Background", Background);
-});

package/dist/runtime/constants.d.ts

@@ -1,11 +0,0 @@
-export declare const QUEUE_STATUSES: {
-    readonly latest: "latest";
-    readonly active: "active";
-    readonly waiting: "waiting";
-    readonly waitingChildren: "waiting-children";
-    readonly prioritized: "prioritized";
-    readonly completed: "completed";
-    readonly failed: "failed";
-    readonly delayed: "delayed";
-    readonly paused: "paused";
-};

package/dist/runtime/constants.js

@@ -1,11 +0,0 @@
-export const QUEUE_STATUSES = {
-  latest: "latest",
-  active: "active",
-  waiting: "waiting",
-  waitingChildren: "waiting-children",
-  prioritized: "prioritized",
-  completed: "completed",
-  failed: "failed",
-  delayed: "delayed",
-  paused: "paused"
-};

package/dist/runtime/schema.d.ts

@@ -1,37 +0,0 @@
-import z from 'zod';
-export declare const JobSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    data: z.ZodAny;
-    progress: z.ZodNumber;
-    opts: z.ZodObject<{
-        attempts: z.ZodNumber;
-        delay: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    state: z.ZodAny;
-    returnvalue: z.ZodAny;
-    attemptsStarted: z.ZodNumber;
-    attemptsMade: z.ZodNumber;
-    delay: z.ZodNumber;
-    timestamp: z.ZodNumber;
-    finishedOn: z.ZodOptional<z.ZodNumber>;
-    processedOn: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const JobSchemaArray: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    data: z.ZodAny;
-    progress: z.ZodNumber;
-    opts: z.ZodObject<{
-        attempts: z.ZodNumber;
-        delay: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    state: z.ZodAny;
-    returnvalue: z.ZodAny;
-    attemptsStarted: z.ZodNumber;
-    attemptsMade: z.ZodNumber;
-    delay: z.ZodNumber;
-    timestamp: z.ZodNumber;
-    finishedOn: z.ZodOptional<z.ZodNumber>;
-    processedOn: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;

package/dist/runtime/schema.js

@@ -1,20 +0,0 @@
-import z from "zod";
-export const JobSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  data: z.any(),
-  progress: z.number(),
-  opts: z.object({
-    attempts: z.number(),
-    delay: z.number().optional()
-  }),
-  state: z.any(),
-  returnvalue: z.any(),
-  attemptsStarted: z.number(),
-  attemptsMade: z.number(),
-  delay: z.number(),
-  timestamp: z.number(),
-  finishedOn: z.number().optional(),
-  processedOn: z.number().optional()
-});
-export const JobSchemaArray = z.array(JobSchema);

package/dist/runtime/server/plugins/00.event-store.d.ts

@@ -1,13 +0,0 @@
-/**
- * Flow Run Snapshots (stream-based)
- *
- * Writes append-only snapshot events to nq:proj:flow:<flowName>:<runId>
- * for key lifecycle kinds:
- *  - flow.start -> status=running
- *  - flow.complete -> status=completed
- *  - runner.log (with correlationId) -> logsCount++ (as a patch)
- *
- * Consumers reduce the small snapshot stream to a final object.
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/plugins/00.event-store.js

@@ -1,16 +0,0 @@
-import { defineNitroPlugin } from "#imports";
-import { getEventStoreFactory } from "../../server-utils/events/eventStoreFactory.js";
-export default defineNitroPlugin(() => {
-  const factory = getEventStoreFactory();
-  factory.start();
-  return {
-    hooks: {
-      close: async () => {
-        try {
-          factory.stop();
-        } catch {
-        }
-      }
-    }
-  };
-});

package/dist/runtime/server/plugins/flow-management.d.ts

@@ -1,13 +0,0 @@
-/**
- * Flow Management Plugin
- *
- * Handles NEW flow starts from external triggers:
- * - Processes external triggers to start new flows
- * - Emits flow.start events for new flow runs
- * - Maps flowIds to flowNames
- *
- * Note: Step orchestration (checking dependencies, triggering next steps)
- * is handled by flowWiring.ts which subscribes to emit/step.completed events
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/plugins/flow-management.js

@@ -1,65 +0,0 @@
-import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
-export default defineNitroPlugin((nitro) => {
-  const logger = useNventLogger("plugin-flow-management");
-  const { onType, publishBus } = useEventManager();
-  const registry = $useQueueRegistry();
-  const flowIdToName = /* @__PURE__ */ new Map();
-  const getFlowNameById = (id) => {
-    const cached = flowIdToName.get(id);
-    if (cached) return cached;
-    try {
-      const flows = registry?.flows || {};
-      for (const [name, def] of Object.entries(flows)) {
-        if (def?.id === id) {
-          flowIdToName.set(id, name);
-          return name;
-        }
-      }
-    } catch {
-    }
-    return void 0;
-  };
-  const unsubscribes = [];
-  unsubscribes.push(onType("emit", async (e) => {
-    if (e.runId) return;
-    const emitName = e.data?.name;
-    if (!emitName) return;
-    const triggers = Object.keys(registry?.eventIndex || {});
-    if (!triggers.includes(emitName)) return;
-    const { enqueue } = useQueue();
-    const targets = (registry?.eventIndex)[emitName] || [];
-    for (const t of targets) {
-      const payload = { ...e.data };
-      try {
-        const id = await enqueue(t.queue, { name: t.step, data: payload });
-        try {
-          const targetFlowName = getFlowNameById(String(t.flowId)) || String(t.flowId);
-          const newRunId = String(id);
-          await publishBus({
-            type: "flow.start",
-            runId: newRunId,
-            flowName: targetFlowName,
-            data: { input: payload }
-          });
-          if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.info("[flow-lifecycle] started new flow:", {
-              flowName: targetFlowName,
-              runId: newRunId,
-              entryStep: t.step
-            });
-          }
-        } catch {
-        }
-      } catch (err) {
-        logger.warn("[flow-lifecycle] failed to start flow:", {
-          step: t.step,
-          error: err?.message
-        });
-      }
-    }
-  }));
-  nitro.hooks.hook("close", () => {
-    unsubscribes.forEach((fn) => fn());
-    flowIdToName.clear();
-  });
-});

package/dist/runtime/server/plugins/queue-management.js

@@ -1,27 +0,0 @@
-import { defineNitroPlugin, useNventLogger } from "#imports";
-import { BullMQProvider } from "../../server-utils/queue/adapters/bullmq.js";
-import { setQueueProvider, getQueueProvider } from "../../server-utils/queue/queueFactory.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  const logger = useNventLogger("plugin-queue-management");
-  try {
-    const existingProvider = getQueueProvider();
-    if (existingProvider) {
-      logger.info("[queues plugin] Closing existing queue provider before creating new one...");
-      await existingProvider.close();
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  } catch {
-  }
-  const provider = new BullMQProvider();
-  await provider.init();
-  setQueueProvider(provider);
-  nitroApp.hooks.hook("close", async () => {
-    logger.info("[queues plugin] Closing queue provider...");
-    await provider.close();
-  });
-  return {
-    async close() {
-      await provider.close();
-    }
-  };
-});

package/dist/runtime/server/plugins/state-cleanup.d.ts

@@ -1,11 +0,0 @@
-/**
- * State Cleanup Plugin
- *
- * Handles automatic cleanup of flow state based on configuration strategy:
- * - 'never': State persists indefinitely
- * - 'immediate': Cleanup after each step (original behavior, not recommended)
- * - 'on-complete': Cleanup when flow completes (recommended, uses lifecycle tracking)
- * - 'ttl': State expires automatically via TTL (handled by storage provider)
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/plugins/state-cleanup.js

@@ -1,93 +0,0 @@
-import { useNventLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
-import { getStateProvider } from "../../server-utils/state/stateFactory.js";
-export default defineNitroPlugin(() => {
-  const logger = useNventLogger("plugin-state-cleanup");
-  const rc = useRuntimeConfig();
-  const cleanup = rc?.queue?.state?.cleanup || { strategy: "never" };
-  if (cleanup.strategy === "never" || cleanup.strategy === "ttl") {
-    return;
-  }
-  const { onType } = useEventManager();
-  const unsubs = [];
-  if (cleanup.strategy === "on-complete") {
-    unsubs.push(onType("flow.completed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after flow completion`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after flow completion", { flowId, error });
-      }
-    }));
-    unsubs.push(onType("flow.failed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after flow failure`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after flow failure", { flowId, error });
-      }
-    }));
-    logger.debug("Plugin initialized with strategy: on-complete");
-  } else if (cleanup.strategy === "immediate") {
-    unsubs.push(onType("step.completed", async (event) => {
-      const flowId = event.runId;
-      if (!flowId) return;
-      try {
-        const sp = getStateProvider();
-        const prefix = `flow:${flowId}:`;
-        const { keys } = await sp.list(prefix);
-        if (keys.length > 0) {
-          const rc2 = useRuntimeConfig();
-          const ns = rc2?.queue?.state?.namespace || "nq";
-          const nsPrefix = `${ns}:`;
-          await Promise.all(keys.map((k) => {
-            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
-            return sp.delete(keyWithoutNs);
-          }));
-          logger.info(`Cleaned up ${keys.length} state keys after step completion`, { flowId, keys });
-        }
-      } catch (error) {
-        logger.error("Error cleaning up state after step", { flowId, error });
-      }
-    }));
-    logger.debug("Plugin initialized with strategy: immediate");
-  }
-  return {
-    hooks: {
-      close: async () => {
-        for (const u of unsubs) {
-          try {
-            u();
-          } catch {
-          }
-        }
-        unsubs.length = 0;
-      }
-    }
-  };
-});

package/dist/runtime/server/plugins/worker-management.js

@@ -1,33 +0,0 @@
-import { defineNitroPlugin, $useWorkerHandlers, $useQueueRegistry } from "#imports";
-import { registerTsWorker, closeAllWorkers } from "../../server-utils/worker/adapter.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  nitroApp.hooks.hook("close", async () => {
-    await closeAllWorkers();
-  });
-  try {
-    const handlers = $useWorkerHandlers();
-    const registry = $useQueueRegistry() || { workers: [] };
-    for (const entry of handlers) {
-      const { queue, id, handler } = entry;
-      const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
-      let jobName;
-      if (w?.flow?.step) {
-        jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
-      } else {
-        jobName = id.includes("/") ? id.split("/").pop() : id;
-      }
-      if (typeof handler === "function") {
-        const cfg = w && w.worker || {};
-        const opts = {};
-        if (typeof cfg.concurrency === "number") opts.concurrency = cfg.concurrency;
-        if (typeof cfg.lockDurationMs === "number") opts.lockDuration = cfg.lockDurationMs;
-        if (typeof cfg.maxStalledCount === "number") opts.maxStalledCount = cfg.maxStalledCount;
-        if (typeof cfg.drainDelayMs === "number") opts.drainDelay = cfg.drainDelayMs;
-        if (typeof cfg.autorun === "boolean") opts.autorun = cfg.autorun;
-        if (w?.queue?.prefix) opts.prefix = w.queue.prefix;
-        await registerTsWorker(queue, jobName, handler, opts);
-      }
-    }
-  } catch {
-  }
-});

package/dist/runtime/server/tsconfig.json

@@ -1,3 +0,0 @@
-{
-    "extends": "../../../playground/.nuxt/tsconfig.server.json",
-}