@corvohq/worker 0.2.0

package/dist/rpc.js

@@ -0,0 +1,193 @@
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-node";
+import { create } from "@bufbuild/protobuf";
+import { WorkerService, HeartbeatJobUpdateSchema, } from "./gen/corvo/v1/worker_pb.js";
+// ---------------------------------------------------------------------------
+// Auth interceptor
+// ---------------------------------------------------------------------------
+function authInterceptor(auth) {
+    return (next) => async (req) => {
+        if (auth.headers) {
+            for (const [k, v] of Object.entries(auth.headers)) {
+                req.header.set(k, v);
+            }
+        }
+        if (auth.apiKey) {
+            req.header.set(auth.apiKeyHeader || "X-API-Key", auth.apiKey);
+        }
+        let token = auth.bearerToken || "";
+        if (auth.tokenProvider) {
+            token = await auth.tokenProvider();
+        }
+        if (token) {
+            req.header.set("authorization", `Bearer ${token}`);
+        }
+        return next(req);
+    };
+}
+function makeClient(baseUrl, auth) {
+    const transport = createConnectTransport({
+        baseUrl,
+        httpVersion: "1.1",
+        useBinaryFormat: false, // use JSON for compatibility
+        interceptors: [authInterceptor(auth)],
+    });
+    return createClient(WorkerService, transport);
+}
+// ---------------------------------------------------------------------------
+// RpcClient
+// ---------------------------------------------------------------------------
+export class RpcClient {
+    constructor(baseUrl, auth = {}) {
+        this.client = makeClient(baseUrl.replace(/\/$/, ""), auth);
+    }
+    async enqueue(queue, payloadJson) {
+        const resp = await this.client.enqueue({ queue, payloadJson });
+        return {
+            jobId: resp.jobId,
+            status: resp.status,
+            uniqueExisting: resp.uniqueExisting,
+        };
+    }
+    async fail(jobId, error, backtrace = "") {
+        const resp = await this.client.fail({ jobId, error, backtrace });
+        return { status: resp.status };
+    }
+    async heartbeat(jobs) {
+        const protoJobs = {};
+        for (const [id, update] of Object.entries(jobs)) {
+            protoJobs[id] = create(HeartbeatJobUpdateSchema, {
+                progressJson: update.progressJson ?? "",
+                checkpointJson: update.checkpointJson ?? "",
+                streamDelta: update.streamDelta ?? "",
+            });
+        }
+        const resp = await this.client.heartbeat({ jobs: protoJobs });
+        const out = {};
+        for (const [id, jr] of Object.entries(resp.jobs)) {
+            out[id] = { status: jr.status };
+        }
+        return out;
+    }
+    /** Unary call to StreamLifecycle endpoint (Connect JSON protocol). */
+    async lifecycleExchange(body) {
+        // StreamLifecycle is bidi streaming in proto, but we call it as unary
+        // using the raw Connect JSON-over-HTTP protocol for compatibility.
+        // The server supports single-request/single-response over HTTP/1.1.
+        throw new Error("lifecycleExchange is not supported via createClient; use LifecycleStream instead");
+    }
+}
+// ---------------------------------------------------------------------------
+// ErrNotLeader
+// ---------------------------------------------------------------------------
+export class ErrNotLeader extends Error {
+    constructor(leaderAddr) {
+        super(leaderAddr
+            ? `NOT_LEADER: leader is at ${leaderAddr}`
+            : "NOT_LEADER: leader unknown");
+        this.name = "ErrNotLeader";
+        this.leaderAddr = leaderAddr;
+    }
+}
+// ---------------------------------------------------------------------------
+// LifecycleStream — bidi streaming over Connect RPC
+// ---------------------------------------------------------------------------
+export class LifecycleStream {
+    constructor(baseUrl, auth = {}) {
+        this.closed = false;
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.auth = auth;
+    }
+    async exchange(req) {
+        if (this.closed) {
+            throw new Error("stream closed");
+        }
+        // StreamLifecycle is bidi streaming in the proto, but the server
+        // supports Connect protocol unary-style JSON calls. We use raw HTTP
+        // because createClient's bidi streaming requires HTTP/2 and a long-lived
+        // stream, which doesn't match our request-per-exchange pattern.
+        const h = { "content-type": "application/json" };
+        if (this.auth.headers) {
+            for (const [k, v] of Object.entries(this.auth.headers)) {
+                h[k] = v;
+            }
+        }
+        if (this.auth.apiKey) {
+            h[this.auth.apiKeyHeader || "X-API-Key"] = this.auth.apiKey;
+        }
+        let token = this.auth.bearerToken || "";
+        if (this.auth.tokenProvider) {
+            token = await this.auth.tokenProvider();
+        }
+        if (token) {
+            h["authorization"] = `Bearer ${token}`;
+        }
+        const url = `${this.baseUrl}/corvo.v1.WorkerService/StreamLifecycle`;
+        const body = JSON.stringify({
+            requestId: req.requestId,
+            queues: req.queues,
+            workerId: req.workerId,
+            hostname: req.hostname,
+            leaseDuration: req.leaseDuration,
+            fetchCount: req.fetchCount,
+            acks: req.acks.map((a) => ({
+                jobId: a.jobId,
+                resultJson: a.resultJson,
+            })),
+            enqueues: req.enqueues.map((e) => ({
+                queue: e.queue,
+                payloadJson: e.payloadJson,
+            })),
+        });
+        const resp = await globalThis.fetch(url, {
+            method: "POST",
+            headers: h,
+            body,
+        });
+        if (!resp.ok) {
+            throw new Error(`RPC StreamLifecycle failed: HTTP ${resp.status}`);
+        }
+        const msg = (await resp.json());
+        if (msg.error === "NOT_LEADER") {
+            throw new ErrNotLeader(msg.leaderAddr ?? "");
+        }
+        return {
+            requestId: msg.requestId ?? 0,
+            jobs: msg.jobs ?? [],
+            acked: msg.acked ?? 0,
+            enqueuedJobIds: msg.enqueuedJobIds ?? [],
+            error: msg.error ?? "",
+            leaderAddr: msg.leaderAddr ?? "",
+        };
+    }
+    close() {
+        this.closed = true;
+    }
+}
+// ---------------------------------------------------------------------------
+// ResilientLifecycleStream — reconnects on NOT_LEADER
+// ---------------------------------------------------------------------------
+export class ResilientLifecycleStream {
+    constructor(baseUrl, auth = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.auth = auth;
+        this.stream = new LifecycleStream(this.baseUrl, auth);
+    }
+    async exchange(req) {
+        try {
+            return await this.stream.exchange(req);
+        }
+        catch (err) {
+            if (err instanceof ErrNotLeader && err.leaderAddr) {
+                this.stream.close();
+                this.baseUrl = err.leaderAddr;
+                this.stream = new LifecycleStream(this.baseUrl, this.auth);
+                return this.stream.exchange(req);
+            }
+            throw err;
+        }
+    }
+    close() {
+        this.stream.close();
+    }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@corvohq/worker",
+  "version": "0.2.0",
+  "description": "TypeScript worker runtime for Corvo",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@corvohq/client": "0.2.0",
+    "@connectrpc/connect": "^2.1.1",
+    "@connectrpc/connect-node": "^2.1.1",
+    "@bufbuild/protobuf": "^2.11.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "@bufbuild/buf": "^1.65.0",
+    "@bufbuild/protoc-gen-es": "^2.11.0"
+  }
+}