effect-mq 0.4.2 → 0.6.0

package/dist/redis/scripts.d.ts

@@ -28,18 +28,36 @@
  * - `p:schedules` / `p:schedule:<key>`  ZSET by nextRunAt + HASH per record
  * - `p:dedupe:<name>\0<key>`   HASH {jobId, expiresAt} + `p:dedupes` index
  *                               ZSET (score = window expiry, +inf = pending)
+ * - `p:flowchild:<flowId>\0<childKey>`  HASH of one flow dependency row
+ * - `p:flowchildren:<flowId>`  ZSET (score 0, member = childKey; ZRANGEBYLEX
+ *                               gives child-key order + cursor pagination)
+ * - `p:flowpending`             ZSET, member `<flowId>\0<childKey>`, score =
+ *                               sweep-eligibility timestamp (pendingSince at
+ *                               staging, re-armed on sweep return)
+ * - `p:flowcascade`             ZSET, score 0, member `<flowId>\0<childKey>`
+ *                               (cancels still owed to child stores)
+ * - `p:flowoutbox`              ZSET, score = seq from `p:flowoutbox:seq`,
+ *                               member `<seq>\0<report json>` — undelivered
+ *                               child-result reports (see OutboxEntry). The
+ *                               seq prefix makes every member id a peek
+ *                               cursor that survives deletions (see
+ *                               peekOutbox in RedisJobStore)
+ *
+ * `waiting-children` parents live only in the job hash, `p:all`, and
+ * `p:counts` — never in a pending zset, so `claim` can never return them.
  *
  * @since 0.2.0
  */
 import { Redis } from "effect/unstable/persistence";
 /**
  * enqueue(prefix, idMode, id, name, queue, payloadJson, metadataJson,
- *         priority, attemptsMax, backoffJson, keepJson, timeoutMs, delayMs, now)
+ *         priority, attemptsMax, backoffJson, keepJson, timeoutMs, delayMs,
+ *         now, dedupe..., traceJson, parentJson)
  * idMode: "user" (dedup no-op), "generated" (collision -> retry sentinel),
  * "auto" (j-<seq>, in-script collision loop).
  */
 export declare const enqueue: Redis.Script<{
-    params: [prefix: string, idMode: string, id: string, name: string, queue: string, payloadJson: string, metadataJson: string, priority: number, attemptsMax: number, backoffJson: string, keepJson: string, timeoutMs: string, delayMs: number, now: number, dedupeKey: string, dedupeTtlMs: string, dedupeExtend: string, dedupeReplace: string, traceJson: string];
+    params: [prefix: string, idMode: string, id: string, name: string, queue: string, payloadJson: string, metadataJson: string, priority: number, attemptsMax: number, backoffJson: string, keepJson: string, timeoutMs: string, delayMs: number, now: number, dedupeKey: string, dedupeTtlMs: string, dedupeExtend: string, dedupeReplace: string, traceJson: string, parentJson: string];
     result: string;
 }>;
 /**
@@ -103,7 +121,7 @@ export declare const counts: Redis.Script<{
     params: [prefix: string];
     result: string;
 }>;
-/** remove(prefix, id) -> removed boolean (active jobs are refused). */
+/** remove(prefix, id) -> removed boolean (active/waiting-children refused). */
 export declare const remove: Redis.Script<{
     params: [prefix: string, id: string];
     result: string;
@@ -114,8 +132,10 @@ export declare const retry: Redis.Script<{
     result: string;
 }>;
 /**
- * cancel(prefix, id, now) — waiting/delayed become terminal; active gets the
- * cancel-request flag; terminal states are refused.
+ * cancel(prefix, id, now) — waiting/delayed/waiting-children become terminal
+ * (a parked flow parent also flips its remaining pending rows to cancelled,
+ * handing them to the cascade sweep); active gets the cancel-request flag;
+ * terminal states are refused.
  */
 export declare const cancel: Redis.Script<{
     params: [prefix: string, id: string, now: number];
@@ -136,7 +156,7 @@ export declare const promote: Redis.Script<{
  * preserves the stored nextRunAt.
  */
 export declare const upsertSchedule: Redis.Script<{
-    params: [prefix: string, key: string, jobName: string, queue: string, cron: string, tz: string, everyMs: string, payloadJson: string, metadataJson: string, priority: string, attemptsMax: string, backoffJson: string, keepJson: string, timeoutMs: string, nextRunAt: number];
+    params: [prefix: string, key: string, jobName: string, queue: string, cron: string, tz: string, everyMs: string, payloadJson: string, metadataJson: string, priority: string, attemptsMax: string, backoffJson: string, keepJson: string, timeoutMs: string, group: string, nextRunAt: number];
     result: string;
 }>;
 /** removeSchedule(prefix, key) -> existed boolean. */
@@ -162,21 +182,21 @@ export declare const advanceSchedule: Redis.Script<{
 /**
  * tickSchedule(prefix, key, expectedRunAt, nextRunAt, id, name, queue,
  *   payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson,
- *   timeoutMs, traceJson, delayMs, now) -> "1" fired | "0"
+ *   timeoutMs, traceJson, parentJson, delayMs, now) -> "1" fired | "0"
  * Atomic occurrence claim: the nextRunAt CAS and the tick job's insert run
  * in one script, so a stale sweeper can never re-fire a slot — even after
  * retention pruned the previous slot's job row.
  */
 export declare const tickSchedule: Redis.Script<{
-    params: [prefix: string, key: string, expectedRunAt: number, nextRunAt: number, id: string, name: string, queue: string, payloadJson: string, metadataJson: string, priority: number, attemptsMax: number, backoffJson: string, keepJson: string, timeoutMs: string, traceJson: string, delayMs: number, now: number];
+    params: [prefix: string, key: string, expectedRunAt: number, nextRunAt: number, id: string, name: string, queue: string, payloadJson: string, metadataJson: string, priority: number, attemptsMax: number, backoffJson: string, keepJson: string, timeoutMs: string, traceJson: string, parentJson: string, delayMs: number, now: number];
     result: string;
 }>;
 /**
  * enqueueMany(prefix, now, count, ...items) -> JSON array of per-item results
- * ({id, duplicate} | {collision} | {error}). Items are 13-ARGV strides:
+ * ({id, duplicate} | {collision} | {error}). Items are 14-ARGV strides:
  * idMode, id, name, queue, payloadJson, metadataJson, priority, attemptsMax,
- * backoffJson, keepJson, timeoutMs, traceJson, delayMs. Plain (non-dedup)
- * items only — the caller routes dedup items through \`enqueue\`.
+ * backoffJson, keepJson, timeoutMs, traceJson, parentJson, delayMs. Plain
+ * (non-dedup) items only — the caller routes dedup items through \`enqueue\`.
  */
 export declare const enqueueMany: Redis.Script<{
     params: [prefix: string, now: number, count: number, items: readonly string[]];
@@ -201,4 +221,91 @@ export declare const sweepDedupes: Redis.Script<{
     params: [prefix: string, limit: number, now: number];
     result: string;
 }>;
+/**
+ * fanOut(prefix, id, token, final, clearStaged, failFast, total, now, count,
+ *   ...items) — the FanOut ack, chunked like enqueueMany. Items are 5-ARGV
+ *   strides: childKey, storeKey, childJobId, name, specJson.
+ *
+ * Every chunk is lock-token-guarded. Non-final chunks ONLY stage dependency
+ * rows; the final chunk stages its rows, appends the "fanned-out" ledger
+ * entry (no attempt consumed), persists the manifest (flowFailFast,
+ * flowPending = total, zeroed outcome counters), and transitions the parent:
+ * pending > 0 parks it in
+ * waiting-children (no pending zset — never claimable), pending == 0 settles
+ * it straight to runnable collect. A parent whose manifest already landed
+ * keeps it untouched (rows are not re-created; the transition follows the
+ * persisted pending count), so a double fan-out cannot duplicate children.
+ * When staging starts with no manifest, the FIRST chunk clears previously
+ * staged rows — a crashed earlier attempt may have staged different keys. A
+ * raced cancelRequested wins: the parent settles cancelled and its pending
+ * rows flip to cancelled (cascade work for the flow sweeper).
+ */
+export declare const fanOut: Redis.Script<{
+    params: [prefix: string, id: string, token: string, final: string, clearStaged: string, failFast: string, total: number, now: number, count: number, items: readonly string[]];
+    result: string;
+}>;
+/**
+ * recordChildResults(prefix, now, count, ...items) -> {results, wakes}.
+ * Items are 5-ARGV strides: flowId, childKey, outcome, exitJson,
+ * failedReason; results are positional {applied, parentSettled}; wakes names
+ * the queues of parents that resumed runnable. One atomic batch; reports may
+ * span flows.
+ *
+ * Phase 1 applies EVERY row update — idempotent, only while the row is
+ * still pending; an applied report moves the child from the parent's `pending`
+ * counter to its outcome counter and marks the row cascaded (the outcome
+ * came FROM the child's store). Phase 2 settles each touched flow at most
+ * once: the FIRST applied failed report in batch order under fail-fast
+ * (terminal store-side failure; remaining rows flip to cancelled; wins the
+ * tie over pending==0 — and this settle IS a nested parent's terminal
+ * transition, so its own report goes to the outbox here), else pending==0
+ * resumes the parent runnable at the flow's LAST applied report's index.
+ */
+export declare const recordChildResults: Redis.Script<{
+    params: [prefix: string, now: number, count: number, items: readonly string[]];
+    result: string;
+}>;
+/**
+ * listChildResults(prefix, flowId, cursor, limit) — child-key order via
+ * ZRANGEBYLEX over the per-flow index; cursor = last childKey (exclusive).
+ * Items are positional HMGET tuples (the field list must stay in lockstep
+ * with the driver's `toChildRecord`) — the full spec JSON stays server-side.
+ */
+export declare const listChildResults: Redis.Script<{
+    params: [prefix: string, flowId: string, cursor: string, limit: number];
+    result: string;
+}>;
+/**
+ * flowSweepWork(prefix, pendingAgeMs, limit, now) -> {reconcile, cascade}
+ * grouped by flowId. Reconcile scans the flowpending zset (score = the row's
+ * sweep-eligibility timestamp) and yields rows whose parent is still parked
+ * in waiting-children. Every scanned member is re-armed or purged so no
+ * member can pin the head of the page:
+ *
+ * - parent missing, or terminal with NO manifest: a crashed fan-out's
+ *   staged orphan — purge the row, its index member, and the flowpending
+ *   member (left alone their old scores would head-pin every page forever);
+ * - parent alive but not waiting-children (mid-staging): re-arm to now so
+ *   it rotates behind fresher work;
+ * - returned rows: re-arm to now (defer-on-return, per the contract) so a
+ *   full page rotates across sweeps;
+ * - a non-pending row's membership is stale (rows never return to pending):
+ *   self-heal by removing the member.
+ *
+ * Cascade lists flowcascade members (cancels still owed to child stores).
+ * Spec JSON strings pass through untouched — the script never cjson-decodes
+ * stored payloads (precision, lone surrogates).
+ */
+export declare const flowSweepWork: Redis.Script<{
+    params: [prefix: string, pendingAgeMs: number, limit: number, now: number];
+    result: string;
+}>;
+/**
+ * markChildrenCascaded(prefix, flowId, childKeysJson) — idempotent; unknown
+ * keys are ignored (their index members are still cleared).
+ */
+export declare const markChildrenCascaded: Redis.Script<{
+    params: [prefix: string, flowId: string, childKeysJson: string];
+    result: string;
+}>;
 //# sourceMappingURL=scripts.d.ts.map

package/dist/redis/scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/redis/scripts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AA0JnD;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;EAgIM,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;EAsEQ,CAAA;AAE1B;;;;GAIG;AACH,eAAO,MAAM,GAAG;;;EAyEU,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,OAAO;;;EA4BM,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,WAAW;;;EAuBE,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,cAAc;;;EAgDD,CAAA;AAE1B,sEAAsE;AACtE,eAAO,MAAM,MAAM;;;EAUO,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,IAAI;;;EAsES,CAAA;AAE1B,mDAAmD;AACnD,eAAO,MAAM,MAAM;;;EAUO,CAAA;AAE1B,uEAAuE;AACvE,eAAO,MAAM,MAAM;;;EAcO,CAAA;AAE1B,sEAAsE;AACtE,eAAO,MAAM,KAAK;;;EA2BQ,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,MAAM;;;EAiCO,CAAA;AAE1B,yDAAyD;AACzD,eAAO,MAAM,OAAO;;;EAqBM,CAAA;AAE1B;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;EA4DD,CAAA;AAE1B,sDAAsD;AACtD,eAAO,MAAM,cAAc;;;EAUD,CAAA;AAE1B,yEAAyE;AACzE,eAAO,MAAM,aAAa;;;EAqBA,CAAA;AAE1B,gEAAgE;AAChE,eAAO,MAAM,YAAY;;;EAcC,CAAA;AAE1B,gFAAgF;AAChF,eAAO,MAAM,eAAe;;;EAcF,CAAA;AAE1B;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;EAwDC,CAAA;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;EA+CE,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;EA0DG,CAAA;AAE1B;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;EAyCC,CAAA"}
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/redis/scripts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AAkPnD;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;EAkIM,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;EAsEQ,CAAA;AAE1B;;;;GAIG;AACH,eAAO,MAAM,GAAG;;;EA0EU,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,OAAO;;;EA4BM,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,WAAW;;;EAuBE,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,cAAc;;;EAiDD,CAAA;AAE1B,sEAAsE;AACtE,eAAO,MAAM,MAAM;;;EAUO,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,IAAI;;;EAsES,CAAA;AAE1B,mDAAmD;AACnD,eAAO,MAAM,MAAM;;;EAUO,CAAA;AAE1B,+EAA+E;AAC/E,eAAO,MAAM,MAAM;;;EAeO,CAAA;AAE1B,sEAAsE;AACtE,eAAO,MAAM,KAAK;;;EA2BQ,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;EAqCO,CAAA;AAE1B,yDAAyD;AACzD,eAAO,MAAM,OAAO;;;EAqBM,CAAA;AAE1B;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;EA8DD,CAAA;AAE1B,sDAAsD;AACtD,eAAO,MAAM,cAAc;;;EAUD,CAAA;AAE1B,yEAAyE;AACzE,eAAO,MAAM,aAAa;;;EAsBA,CAAA;AAE1B,gEAAgE;AAChE,eAAO,MAAM,YAAY;;;EAcC,CAAA;AAE1B,gFAAgF;AAChF,eAAO,MAAM,eAAe;;;EAcF,CAAA;AAE1B;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;EA0DC,CAAA;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;EA+CE,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;EA4DG,CAAA;AAE1B;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;EAyCC,CAAA;AAE1B;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM;;;EA+FO,CAAA;AAE1B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB;;;EAmGL,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;EAkBH,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa;;;EA0EA,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;EAgBP,CAAA"}