lightflow-engine 0.1.3 → 0.1.4

package/dist/src/index.js

@@ -104,7 +104,7 @@ export async function step(fn) {
     }
     ctx.seq += 1;
     ctx.freshResults.set(key, value);
-    await ctx.store.appendEvent({
+    ctx.append({
         runId: ctx.runId, seq: ctx.seq, type: "step_completed",
         payload: { key, value }, createdAt: ctx.now(),
     });
@@ -120,6 +120,7 @@ const SNAPSHOT_MIN_EVENTS = 100;
  * costing replay time and can be pruned later without breaking resumes.
  */
 async function maybeSnapshot(ctx) {
+    await Promise.all(ctx.inflight);
     ctx.completedNow += 1;
     const done = ctx.completedNow +
         [...ctx.memo.values()].filter((e) => e.type === "step_completed").length;
@@ -307,8 +308,13 @@ export class Engine {
         // by the winner, and any newer events it would have seen are picked up
         // by the next resume.
         const claimer = this.store;
-        if (claimer.claimRun && !(await claimer.claimRun(runId)))
+        const claim = await claimer.claimRun?.(runId);
+        if (claim && !claim.ok)
+            return;
+        if (claim?.cancelled) {
+            await this.store.setStatus(runId, "failed", { error: "cancelled" });
             return;
+        }
         const log = await this.store.getEvents(runId);
         // Memo index: one pass over the log, O(1) lookups during replay.
         // A leading 'snapshot' event pre-fills completed step/sleep/chunk state.
@@ -340,26 +346,36 @@ export class Engine {
             runId, seq: log.length ? log.reduce((m, e) => Math.max(m, e.seq), 0) + 1 : 1,
             stepCalls: 0, sleepCalls: 0, hookCalls: 0,
             writes: 0,
-            store: this.store, log, memo, completedNow: 0, freshResults: new Map(), cursor: 0, chunks: [], now: () => Date.now(),
+            store: this.store, log, memo, completedNow: 0, freshResults: new Map(),
+            inflight: [], cursor: 0, chunks: [], now: () => Date.now(),
+            append: (e) => {
+                // Pipelined append: capture the promise; callers only await at
+                // suspension/end, so several step completions share one flush.
+                const p = ctx.store.appendEvent(e).then(() => { ctx.inflight = ctx.inflight.filter(x => x !== p); });
+                ctx.inflight.push(p);
+                return p;
+            },
         };
         const prev = current;
         current = ctx;
         try {
-            if (await this.store.isCancelled?.(runId)) {
-                await this.store.setStatus(runId, "failed", { error: "cancelled" });
-                return;
-            }
             const output = await fn(...args);
-            await this.store.setStatus(runId, "completed", output);
+            await Promise.all(ctx.inflight);
+            await (this.store.finishRun?.(runId, "completed", output)
+                ?? this.store.setStatus(runId, "completed", output));
             this.local.get(runId)?.resolve(output);
         }
         catch (err) {
-            if (err instanceof SuspendSignal)
+            if (err instanceof SuspendSignal) {
+                await Promise.all(ctx.inflight);
                 return; // waiting on a timer
+            }
             const fail = async (error) => {
-                await this.store.setStatus(runId, "failed", {
+                await (this.store.finishRun?.(runId, "failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                }) ?? this.store.setStatus(runId, "failed", {
                     error: error instanceof Error ? error.message : String(error),
-                });
+                }));
                 this.local.get(runId)?.reject(err instanceof Error ? err : new Error(String(err)));
             };
             if (err instanceof CancelledError)

package/dist/src/pg-store.js

@@ -5,10 +5,19 @@
  * columns, so no timezone ambiguity (the bug that cost hours in world-postgres).
  */
 import pg from "pg";
-export async function createPostgresStore(url) {
+export async function createPostgresStore(url, opts = {}) {
     // Pipelining (pg >= 8.23): batch queries on one connection instead of one
     // round trip per query — 1.5-2.4x on multi-query workloads.
     const pool = new pg.Pool({ connectionString: url, max: 20, pipeline: true });
+    if (opts.sessionOptions) {
+        const sets = Object.entries(opts.sessionOptions)
+            .map(([k, v]) => `SET ${k} = ${v === "off" || v === "on" ? v : `'${v}'`}`)
+            .join("; ");
+        // Apply per connection as it opens (pg fires 'connect' per client).
+        pool.on("connect", (client) => {
+            void client.query(sets).catch(() => { });
+        });
+    }
     await pool.query(`
     CREATE TABLE IF NOT EXISTS lightflow_runs (
       run_id     TEXT PRIMARY KEY,
@@ -208,14 +217,21 @@ export async function createPostgresStore(url) {
         async claimDue() { return false; },
         async claimRun(runId, leaseMs = 30_000) {
             const now = Date.now();
+            // One round trip: claim the lease AND read the cancelled flag.
             const r = await pool.query(`UPDATE lightflow_runs SET claimed_until=$2, updated_at=$3
          WHERE run_id=$1 AND claimed_until < $3
-         RETURNING run_id`, [runId, now + leaseMs, now]);
-            return (r.rowCount ?? 0) > 0;
+         RETURNING cancelled`, [runId, now + leaseMs, now]);
+            return { ok: (r.rowCount ?? 0) > 0, cancelled: r.rows[0]?.cancelled === true };
         },
         async releaseRun(runId) {
             await pool.query(`UPDATE lightflow_runs SET claimed_until=0 WHERE run_id=$1 AND claimed_until > 0`, [runId]);
         },
+        /** Terminal status + lease release in one round trip. */
+        async finishRun(runId, status, output) {
+            await pool.query(`UPDATE lightflow_runs
+         SET status=$2, output=$3, claimed_until=0, updated_at=$4
+         WHERE run_id=$1`, [runId, status, output === undefined ? null : JSON.stringify(output), Date.now()]);
+        },
         /** LISTEN/NOTIFY wakeup support: re-poll immediately on notify. */
         async notifyWake() {
             await pool.query(`NOTIFY lightflow_wake`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightflow-engine",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A tiny durable workflow engine for Node.js and Postgres: steps that run at most once, timers that survive crashes, streams that replay exactly once.",
   "license": "MIT",
   "type": "module",