@ventually/ui 0.0.0

package/dist/runtime.js

@@ -0,0 +1,303 @@
+import { FlowProducer, Queue, Scheduler, UnrecoverableError, Worker, } from "@ventually/core";
+import { MemoryAdapter } from "@ventually/memory";
+const QUEUE_CONFIG = {
+    email: {
+        description: "Transactional email delivery with retries and recurring heartbeats.",
+        concurrency: 3,
+        pollIntervalMs: 20,
+        attempts: 3,
+        removeOnCompleteCount: 30,
+        removeOnFailCount: 30,
+        recurringEnabled: true,
+    },
+    fetcher: {
+        description: "Fetches raw document content before downstream processing.",
+        concurrency: 1,
+        pollIntervalMs: 20,
+        attempts: 1,
+        removeOnCompleteCount: 0,
+        removeOnFailCount: 0,
+        recurringEnabled: false,
+    },
+    chunker: {
+        description: "Splits fetched content into smaller processing chunks.",
+        concurrency: 1,
+        pollIntervalMs: 20,
+        attempts: 1,
+        removeOnCompleteCount: 0,
+        removeOnFailCount: 0,
+        recurringEnabled: false,
+    },
+    embeddings: {
+        description: "Generates embeddings for prepared chunks.",
+        concurrency: 1,
+        pollIntervalMs: 20,
+        attempts: 1,
+        removeOnCompleteCount: 0,
+        removeOnFailCount: 0,
+        recurringEnabled: false,
+    },
+    vectorstore: {
+        description: "Persists vectors into the final storage layer.",
+        concurrency: 1,
+        pollIntervalMs: 20,
+        attempts: 1,
+        removeOnCompleteCount: 0,
+        removeOnFailCount: 0,
+        recurringEnabled: false,
+    },
+};
+export class EventuallyUIRuntime {
+    offsetMs = 0;
+    adapter = new MemoryAdapter();
+    events = [];
+    workers = new Map();
+    scheduleHandles = new Map();
+    emailQueue = new Queue("email", {
+        adapter: this.adapter,
+        now: () => this.now(),
+        defaultJobOptions: {
+            attempts: 3,
+            removeOnComplete: { count: 30 },
+            removeOnFail: { count: 30 },
+        },
+    });
+    scheduler = new Scheduler("email", {
+        adapter: this.adapter,
+        now: () => this.now(),
+        defaultJobOptions: {
+            removeOnComplete: { count: 30 },
+            removeOnFail: { count: 30 },
+        },
+    });
+    flowProducer = new FlowProducer({
+        adapter: this.adapter,
+        now: () => this.now(),
+    });
+    constructor() {
+        this.registerWorker("email", new Worker("email", async (job) => {
+            await job.updateProgress(25);
+            await this.sleep(50);
+            if (job.data.subject.toLowerCase().includes("fail")) {
+                throw new UnrecoverableError("Simulated delivery failure");
+            }
+            await job.updateProgress(100);
+            return {
+                messageId: `msg_${job.id.slice(0, 8)}`,
+            };
+        }, { adapter: this.adapter, concurrency: 3, pollInterval: 20, now: () => this.now() }));
+        this.registerWorker("fetcher", new Worker("fetcher", async (job) => {
+            await this.sleep(30);
+            return { body: `Fetched: ${job.data.value}` };
+        }, { adapter: this.adapter, pollInterval: 20, now: () => this.now() }));
+        this.registerWorker("chunker", new Worker("chunker", async (job) => {
+            await this.sleep(30);
+            return { chunks: job.data.body.split(/\s+/).filter(Boolean) };
+        }, { adapter: this.adapter, pollInterval: 20, now: () => this.now() }));
+        this.registerWorker("embeddings", new Worker("embeddings", async (job) => {
+            await this.sleep(40);
+            return { vectors: job.data.chunks.length || 4 };
+        }, { adapter: this.adapter, pollInterval: 20, now: () => this.now() }));
+        this.registerWorker("vectorstore", new Worker("vectorstore", async (job) => {
+            await this.sleep(40);
+            return { upserted: job.data.vectors || 4 };
+        }, { adapter: this.adapter, pollInterval: 20, now: () => this.now() }));
+    }
+    start() {
+        for (const worker of this.workers.values()) {
+            void worker.run();
+        }
+    }
+    snapshot() {
+        const queues = this.adapter.getAllQueuesSnapshot().map((queue) => this.toQueueSnapshot(queue));
+        return {
+            now: this.now(),
+            queues,
+            events: this.events.slice(-80).reverse(),
+            workers: [...this.workers.entries()].map(([queue, worker]) => ({
+                queue,
+                paused: worker.__paused ?? false,
+            })),
+        };
+    }
+    async enqueueEmail(kind) {
+        const subjectMap = {
+            welcome: "Welcome aboard",
+            digest: "Daily digest",
+            failure: "Fail this message",
+        };
+        await this.emailQueue.add(kind, {
+            to: "alice@example.com",
+            subject: subjectMap[kind],
+            html: `<p>${subjectMap[kind]}</p>`,
+        }, {
+            priority: kind === "welcome" ? 10 : 3,
+            delay: kind === "digest" ? "5s" : 0,
+        });
+    }
+    async enqueueFlow() {
+        await this.flowProducer.add({
+            name: "upsert-vectors",
+            queueName: "vectorstore",
+            data: { vectors: 0 },
+            children: [
+                {
+                    name: "embed-chunks",
+                    queueName: "embeddings",
+                    data: { chunks: [] },
+                    children: [
+                        {
+                            name: "chunk-document",
+                            queueName: "chunker",
+                            data: { body: "" },
+                            children: [
+                                {
+                                    name: "fetch-document",
+                                    queueName: "fetcher",
+                                    data: { value: "https://example.com/doc.pdf" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    createRecurringEmail() {
+        const handle = this.scheduler.every("heartbeat", {
+            to: "ops@example.com",
+            subject: "Heartbeat",
+            html: "<p>System pulse</p>",
+        }, "15s", { jitter: "2s" });
+        this.scheduleHandles.set(handle.id, handle);
+        this.pushEvent({
+            queue: "email",
+            type: "scheduled",
+            jobId: handle.id,
+            name: "heartbeat",
+            detail: "Recurring email schedule started",
+        });
+        return handle.id;
+    }
+    cancelSchedule(id) {
+        this.scheduleHandles.get(id)?.cancel();
+        this.scheduleHandles.delete(id);
+    }
+    pauseWorker(queue) {
+        const worker = this.workers.get(queue);
+        if (!worker) {
+            return;
+        }
+        worker.pause();
+        worker.__paused = true;
+    }
+    resumeWorker(queue) {
+        const worker = this.workers.get(queue);
+        if (!worker) {
+            return;
+        }
+        worker.resume();
+        worker.__paused = false;
+    }
+    advanceTime(ms) {
+        this.offsetMs += ms;
+        this.adapter.advanceTime(ms);
+    }
+    toQueueSnapshot(queue) {
+        const config = QUEUE_CONFIG[queue.name] ?? {
+            description: "Queue configuration is not available.",
+            concurrency: 1,
+            pollIntervalMs: 20,
+            attempts: 1,
+            removeOnCompleteCount: 0,
+            removeOnFailCount: 0,
+            recurringEnabled: false,
+        };
+        return {
+            name: queue.name,
+            config,
+            counts: queue.counts,
+            jobs: queue.jobs.map((job) => ({
+                id: job.id,
+                name: job.name,
+                state: job.state,
+                attempt: job.attempt,
+                attempts: job.attempts,
+                createdAt: job.createdAt,
+                processedAt: job.processedAt,
+                finishedAt: job.finishedAt,
+                availableAt: job.availableAt,
+                failedReason: job.failedReason,
+            })),
+        };
+    }
+    registerWorker(queue, worker) {
+        worker.on("active", (job) => {
+            this.pushEvent({
+                queue,
+                type: "active",
+                jobId: job.id,
+                name: job.name,
+                detail: `attempt ${job.attempt}/${job.attempts}`,
+            });
+        });
+        worker.on("progress", (job, progress) => {
+            this.pushEvent({
+                queue,
+                type: "progress",
+                jobId: job.id,
+                name: job.name,
+                detail: JSON.stringify(progress),
+            });
+        });
+        worker.on("completed", (job, result) => {
+            this.pushEvent({
+                queue,
+                type: "completed",
+                jobId: job.id,
+                name: job.name,
+                detail: JSON.stringify(result),
+            });
+        });
+        worker.on("failed", (job, error) => {
+            this.pushEvent({
+                queue,
+                type: "failed",
+                jobId: job.id,
+                name: job.name,
+                detail: error.message,
+            });
+        });
+        worker.on("retrying", (job, error, nextRetryAt) => {
+            this.pushEvent({
+                queue,
+                type: "retrying",
+                jobId: job.id,
+                name: job.name,
+                detail: `${error.message} -> ${new Date(nextRetryAt).toLocaleTimeString()}`,
+            });
+        });
+        this.workers.set(queue, worker);
+    }
+    pushEvent(entry) {
+        this.events.push({
+            ...entry,
+            id: `${entry.queue}:${entry.jobId}:${this.now()}:${this.events.length}`,
+            at: this.now(),
+        });
+        if (this.events.length > 200) {
+            this.events.splice(0, this.events.length - 200);
+        }
+    }
+    now() {
+        return Date.now() + this.offsetMs;
+    }
+    async sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export function getEventuallyUIRuntime() {
+    globalThis.__eventuallyUIRuntime ??= new EventuallyUIRuntime();
+    globalThis.__eventuallyUIRuntime.start();
+    return globalThis.__eventuallyUIRuntime;
+}

package/dist/shared-types.d.ts

@@ -0,0 +1,71 @@
+export type EventuallyUIJobState = "waiting" | "blocked" | "active" | "delayed" | "completed" | "failed";
+export interface EventuallyUIJob {
+    id: string;
+    name: string;
+    state: EventuallyUIJobState;
+    attempt: number;
+    attempts: number;
+    createdAt: number;
+    processedAt: number | null;
+    finishedAt: number | null;
+    availableAt: number;
+    failedReason: string | null;
+}
+export interface EventuallyUIQueueSnapshot {
+    name: string;
+    config: {
+        description: string;
+        concurrency: number;
+        pollIntervalMs: number;
+        attempts: number;
+        removeOnCompleteCount: number;
+        removeOnFailCount: number;
+        recurringEnabled: boolean;
+    };
+    counts: Record<EventuallyUIJobState, number>;
+    jobs: EventuallyUIJob[];
+}
+export interface EventuallyUIEvent {
+    id: string;
+    queue: string;
+    type: string;
+    jobId: string;
+    name: string;
+    at: number;
+    detail: string;
+}
+export interface EventuallyUIWorker {
+    queue: string;
+    paused: boolean;
+}
+export interface EventuallyUISnapshot {
+    now: number;
+    queues: EventuallyUIQueueSnapshot[];
+    events: EventuallyUIEvent[];
+    workers: EventuallyUIWorker[];
+}
+export type EventuallyUIAction = {
+    action: "enqueue-job";
+    queue: string;
+    payload: unknown;
+} | {
+    action: "enqueue-email";
+    kind: "welcome" | "digest" | "failure";
+} | {
+    action: "enqueue-flow";
+} | {
+    action: "schedule-heartbeat";
+} | {
+    action: "cancel-schedule";
+    id: string;
+} | {
+    action: "pause-worker";
+    queue: string;
+} | {
+    action: "resume-worker";
+    queue: string;
+} | {
+    action: "advance-time";
+    ms: number;
+};
+//# sourceMappingURL=shared-types.d.ts.map

package/dist/shared-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-types.d.ts","sourceRoot":"","sources":["../src/shared-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,SAAS,GACT,QAAQ,GACR,SAAS,GACT,WAAW,GACX,QAAQ,CAAC;AAEb,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,oBAAoB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,gBAAgB,EAAE,OAAO,CAAC;KAC3B,CAAC;IACF,MAAM,EAAE,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IAC7C,IAAI,EAAE,eAAe,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,yBAAyB,EAAE,CAAC;IACpC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;CAAE,GACnE;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,GAC1B;IAAE,MAAM,EAAE,oBAAoB,CAAA;CAAE,GAChC;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/shared-types.js

@@ -0,0 +1 @@
+export {};