nvent 0.4.0

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

@@ -0,0 +1,291 @@
+<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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,6 @@
+import '@vue-flow/core/dist/style.css';
+import '@vue-flow/core/dist/theme-default.css';
+import '@vue-flow/controls/dist/style.css';
+import '@vue-flow/minimap/dist/style.css';
+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

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin } from "#app";
+import { VueFlow } from "@vue-flow/core";
+import { Controls } from "@vue-flow/controls";
+import { MiniMap } from "@vue-flow/minimap";
+import { Background } from "@vue-flow/background";
+import "@vue-flow/core/dist/style.css";
+import "@vue-flow/core/dist/theme-default.css";
+import "@vue-flow/controls/dist/style.css";
+import "@vue-flow/minimap/dist/style.css";
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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/python/get_config.py

@@ -0,0 +1,64 @@
+import sys
+import json
+import importlib.util
+import os
+import platform
+
+
+def send_message(payload):
+    """Send a JSON line to the parent process.
+
+    On Unix-like systems, write to the file descriptor provided via env
+    NODE_CHANNEL_FD. On Windows, write to stdout.
+    """
+    bytes_message = (json.dumps(payload) + "\n").encode("utf-8")
+
+    if platform.system() == "Windows":
+        # On Windows, write to stdout
+        sys.stdout.buffer.write(bytes_message)
+        sys.stdout.buffer.flush()
+    else:
+        # On Unix systems, use the provided file descriptor
+        fd = int(os.environ["NODE_CHANNEL_FD"])  # expected to be set by parent
+        os.write(fd, bytes_message)
+
+
+async def run_python_module(file_path: str) -> None:
+    try:
+        module_dir = os.path.dirname(os.path.abspath(file_path))
+
+        if module_dir not in sys.path:
+            sys.path.insert(0, module_dir)
+
+        spec = importlib.util.spec_from_file_location(
+            os.path.splitext(os.path.basename(file_path))[0], file_path
+        )
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load module from {file_path}")
+
+        module = importlib.util.module_from_spec(spec)
+        # Set a basic package name to allow relative imports from same dir
+        module.__package__ = os.path.basename(module_dir)
+        spec.loader.exec_module(module)
+
+        if not hasattr(module, "config"):
+            raise AttributeError(f"No 'config' found in module {file_path}")
+
+        cfg = getattr(module, "config")
+        # Remove keys that are not serializable or not needed
+        if isinstance(cfg, dict) and "middleware" in cfg:
+            del cfg["middleware"]
+
+        send_message(cfg)
+    except Exception as error:
+        print("Error running Python module:", str(error), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit(1)
+    file_path = sys.argv[1]
+    import asyncio
+
+    asyncio.run(run_python_module(file_path))

package/dist/runtime/schema.d.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,20 @@
+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/api/_flows/[name]/clear-history.delete.d.ts

@@ -0,0 +1,10 @@
+/**
+ * DELETE /api/_flows/:flowName/clear-history
+ *
+ * Clears all event history for a specific flow.
+ * This deletes:
+ * - All flow run streams (nq:flow:run-*)
+ * - The flow runs index (nq:flows:<flowName>)
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/[name]/clear-history.delete.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, createError, useEventStore } from "#imports";
+export default defineEventHandler(async (event) => {
+  const flowName = event.context.params?.name;
+  if (!flowName) {
+    throw createError({ statusCode: 400, statusMessage: "Flow name required" });
+  }
+  try {
+    const store = useEventStore();
+    const names = store.names();
+    let deletedStreams = 0;
+    let deletedIndex = false;
+    const indexKey = names.flowIndex(flowName);
+    if (store.indexRead) {
+      const runs = await store.indexRead(indexKey, { limit: 1e4 });
+      if (store.deleteStream) {
+        for (const run of runs) {
+          const streamName = names.flow(run.id);
+          await store.deleteStream(streamName);
+          if (store.deleteIndex) {
+            const metaKey = `${indexKey}:meta:${run.id}`;
+            await store.deleteIndex(metaKey);
+          }
+          deletedStreams++;
+        }
+      }
+    }
+    if (store.deleteIndex) {
+      await store.deleteIndex(indexKey);
+      deletedIndex = true;
+    }
+    return {
+      success: true,
+      flowName,
+      deletedStreams,
+      deletedIndex
+    };
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to clear flow history",
+      data: error instanceof Error ? error.message : String(error)
+    });
+  }
+});

package/dist/runtime/server/api/_flows/[name]/runs.get.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GET /api/_flows/:name/runs?limit=50&offset=0
+ *
+ * List runs for a specific flow with pagination support
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/[name]/runs.get.js

@@ -0,0 +1,53 @@
+import { defineEventHandler, getRouterParam, getQuery, useEventStore, useServerLogger } from "#imports";
+const logger = useServerLogger("api-flows-runs");
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  const query = getQuery(event);
+  const limit = Math.min(Number.parseInt(query.limit) || 50, 100);
+  const offset = Math.max(Number.parseInt(query.offset) || 0, 0);
+  const status = query.status;
+  event.node.res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
+  event.node.res.setHeader("Pragma", "no-cache");
+  if (!flowName) {
+    return { error: "Missing flow name" };
+  }
+  const store = useEventStore();
+  const names = store.names();
+  try {
+    const runIndexKey = names.flowIndex(flowName);
+    let totalCount = 0;
+    try {
+      const allEntries = await store.indexRead(runIndexKey, { limit: 1e4 });
+      totalCount = allEntries.length;
+    } catch {
+      totalCount = 0;
+    }
+    const entries = await store.indexRead(runIndexKey, { offset, limit });
+    const filteredEntries = status ? entries.filter((e) => e.metadata?.status === status) : entries;
+    const items = filteredEntries.map((entry) => ({
+      id: entry.id,
+      flowName,
+      status: entry.metadata?.status || "unknown",
+      createdAt: new Date(entry.score).toISOString(),
+      startedAt: entry.metadata?.startedAt ? new Date(entry.metadata.startedAt).toISOString() : void 0,
+      completedAt: entry.metadata?.completedAt ? new Date(entry.metadata.completedAt).toISOString() : void 0,
+      stepCount: entry.metadata?.stepCount || 0,
+      completedSteps: entry.metadata?.completedSteps || 0
+    }));
+    return {
+      flowName,
+      count: items.length,
+      total: totalCount,
+      offset,
+      limit,
+      hasMore: offset + items.length < totalCount,
+      items
+    };
+  } catch (err) {
+    logger.error("[flows/runs] error:", { error: err });
+    return {
+      error: "Failed to list runs",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+});

package/dist/runtime/server/api/_flows/[name]/schedule.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/[name]/schedule.post.js

@@ -0,0 +1,57 @@
+import { defineEventHandler, readBody, getRouterParam, createError, useQueue, $useQueueRegistry } from "#imports";
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  if (!flowName) {
+    throw createError({ statusCode: 400, statusMessage: "Flow name is required" });
+  }
+  const body = await readBody(event);
+  const { input, cron, delay, jobId, metadata } = body;
+  if (cron && delay) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Cannot specify both cron and delay"
+    });
+  }
+  if (!cron && !delay) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Must specify either cron or delay"
+    });
+  }
+  const registry = $useQueueRegistry();
+  const flow = registry?.flows?.[flowName];
+  if (!flow || !flow.entry) {
+    throw createError({ statusCode: 404, statusMessage: `Flow '${flowName}' not found` });
+  }
+  const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
+  const queue = useQueue();
+  const scheduleOpts = {};
+  if (cron) scheduleOpts.cron = cron;
+  if (delay) scheduleOpts.delay = delay;
+  const jobData = {
+    __scheduledFlowStart: true,
+    __flowName: flowName,
+    __flowInput: input || {},
+    __schedule: {
+      metadata,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  const id = await queue.schedule(
+    queueName,
+    {
+      name: flow.entry.step,
+      data: jobData,
+      opts: jobId ? { jobId } : void 0
+    },
+    scheduleOpts
+  );
+  return {
+    id,
+    flowName,
+    queue: queueName,
+    step: flow.entry.step,
+    schedule: scheduleOpts,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+});

package/dist/runtime/server/api/_flows/[name]/schedules/[id].delete.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;