@ontemper/platform 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @ontemper/platform — Temper Platform SDK (Restate-powered)
+ *
+ * Thin wrapper around Restate's TypeScript SDK providing:
+ * - ctx.step(name, fn) — journaled step execution (replayed on retry)
+ * - ctx.sleep(durationMs) — durable timer (survives process restarts)
+ * - ctx.get/set(key, value) — durable K/V state
+ * - Dual-write to Postgres for API/dashboard queryability
+ *
+ * The Restate journal is the source of truth for execution replay.
+ * Postgres writes are best-effort for dashboard visibility.
+ */
+import * as restate from "@restatedev/restate-sdk";
+interface CreateWorkflowOptions {
+    name?: string;
+    handler: (ctx: TemperContext, input: unknown) => Promise<unknown>;
+}
+/**
+ * Wrapper context that exposes safe operations only.
+ * Does NOT expose raw Restate context methods like genericCall() or objectClient()
+ * to enforce the sandbox trust model.
+ */
+declare class TemperContext {
+    private ctx;
+    private executionId;
+    constructor(ctx: restate.WorkflowContext, executionId: string);
+    /** Run a named step with journaling. On replay, returns the cached result. */
+    step<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    /** Durable sleep — survives process restarts. Restate manages the timer. */
+    sleep(durationMs: number): Promise<void>;
+    /** Get a durable state value. */
+    get<T>(key: string): Promise<T | null>;
+    /** Set a durable state value. */
+    set<T>(key: string, value: T): Promise<void>;
+}
+export declare function createWorkflow({ name, handler }: CreateWorkflowOptions): void;
+export declare const temper: {
+    createWorkflow: typeof createWorkflow;
+};
+export {};

package/dist/index.js

@@ -0,0 +1,137 @@
+/**
+ * @ontemper/platform — Temper Platform SDK (Restate-powered)
+ *
+ * Thin wrapper around Restate's TypeScript SDK providing:
+ * - ctx.step(name, fn) — journaled step execution (replayed on retry)
+ * - ctx.sleep(durationMs) — durable timer (survives process restarts)
+ * - ctx.get/set(key, value) — durable K/V state
+ * - Dual-write to Postgres for API/dashboard queryability
+ *
+ * The Restate journal is the source of truth for execution replay.
+ * Postgres writes are best-effort for dashboard visibility.
+ */
+import * as restate from "@restatedev/restate-sdk";
+import { endpoint } from "@restatedev/restate-sdk/fetch";
+const POSTGRES_WRITE_URL = process.env.ORCHESTRATOR_URL;
+/**
+ * Wrapper context that exposes safe operations only.
+ * Does NOT expose raw Restate context methods like genericCall() or objectClient()
+ * to enforce the sandbox trust model.
+ */
+class TemperContext {
+    ctx;
+    executionId;
+    constructor(ctx, executionId) {
+        this.ctx = ctx;
+        this.executionId = executionId;
+    }
+    /** Run a named step with journaling. On replay, returns the cached result. */
+    async step(name, fn) {
+        return this.ctx.run(name, async () => {
+            const result = await fn();
+            // Dual-write step result to Postgres for dashboard
+            if (POSTGRES_WRITE_URL) {
+                await fetch(`${POSTGRES_WRITE_URL}/internal/step-result`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        execution_id: this.executionId,
+                        step_name: name,
+                        output: result,
+                        status: "completed",
+                    }),
+                }).catch(() => { }); // best-effort, Restate journal is source of truth
+            }
+            return result;
+        });
+    }
+    /** Durable sleep — survives process restarts. Restate manages the timer. */
+    async sleep(durationMs) {
+        await this.ctx.sleep(durationMs);
+    }
+    /** Get a durable state value. */
+    async get(key) {
+        return this.ctx.get(key);
+    }
+    /** Set a durable state value. */
+    async set(key, value) {
+        this.ctx.set(key, value);
+    }
+}
+function writeDualStatus(executionId, status, extra) {
+    if (!POSTGRES_WRITE_URL)
+        return;
+    return fetch(`${POSTGRES_WRITE_URL}/internal/execution-status`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ execution_id: executionId, status, ...extra }),
+    }).catch(() => { }); // best-effort
+}
+export function createWorkflow({ name, handler }) {
+    // Restate service names must match ^([a-zA-Z]|_[a-zA-Z0-9])[a-zA-Z0-9._-]*$
+    // UUIDs start with digits, so prefix with "wf_" to make them valid.
+    const rawName = name || process.env.WORKFLOW_ID || "WorkflowRunner";
+    const workflowName = rawName.match(/^[a-zA-Z_]/) ? rawName : `wf_${rawName}`;
+    const workflow = restate.workflow({
+        name: workflowName,
+        handlers: {
+            run: async (ctx, input) => {
+                const executionId = ctx.key; // Restate workflow key = execution ID
+                const temperCtx = new TemperContext(ctx, executionId);
+                // Extract metadata from the Restate invocation envelope.
+                // Ingest sends: { workflow_id, input, trigger_type, org_id }
+                const envelope = input;
+                const workflowId = envelope?.workflow_id;
+                const orgId = envelope?.org_id;
+                const triggerType = envelope?.trigger_type;
+                // Unwrap the actual user payload from the ingest envelope
+                const userInput = envelope?.input ?? input;
+                // Dual-write: mark running (UPSERT — creates execution_runs row if ingest didn't)
+                await ctx.run("_mark_running", async () => {
+                    await writeDualStatus(executionId, "running", {
+                        workflow_id: workflowId,
+                        org_id: orgId,
+                        trigger_type: triggerType,
+                    });
+                });
+                try {
+                    const output = await handler(temperCtx, userInput);
+                    // Dual-write: mark completed
+                    await ctx.run("_mark_completed", async () => {
+                        await writeDualStatus(executionId, "completed", { output });
+                    });
+                    return output;
+                }
+                catch (err) {
+                    // Dual-write: mark failed
+                    await ctx.run("_mark_failed", async () => {
+                        await writeDualStatus(executionId, "failed", {
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    });
+                    throw err;
+                }
+            },
+        },
+    });
+    // Start Bun HTTP server with Restate endpoint + health check
+    const port = Number(process.env.PORT);
+    if (!port)
+        throw new Error("PORT env var required");
+    const restateHandler = endpoint().bind(workflow).handler();
+    Bun.serve({
+        port,
+        hostname: "0.0.0.0", // Bind IPv4 — Restate connects via IPv4
+        async fetch(req) {
+            const url = new URL(req.url);
+            if (url.pathname === "/health" || url.pathname === "/healthcheck") {
+                return new Response(JSON.stringify({ status: "ok" }), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            return restateHandler.fetch(req);
+        },
+    });
+}
+// Customer-facing API (backward-compatible module shape)
+export const temper = { createWorkflow };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ontemper/platform",
+  "version": "0.1.0",
+  "description": "Temper platform SDK for durable workflow execution",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsc"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@restatedev/restate-sdk": "^1.4.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0"
+  }
+}