effect-mq 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-mq",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Effect-native background jobs: schema-first definitions, storage-agnostic queue core, worker runtime, and a Postgres store through drizzle.",
   "license": "MIT",
   "author": "Adam Rankin",

package/src/JobStore.ts

@@ -594,9 +594,18 @@ export type AckOutcome =
   }
 
 /**
- * Filters and pagination for `list`. Results are ordered newest-first
- * (`enqueuedAt` desc, then id desc); pass the returned `cursor` back to get
- * the next page.
+ * Filters, ordering, and pagination for `list`. The default order is
+ * newest-first (`enqueuedAt` desc, then id desc); pass the returned
+ * `cursor` back — with the SAME options that produced it — to get the next
+ * page.
+ *
+ * Ordering is not free on every storage layout, so the contract defines a
+ * REQUIRED (filter, orderBy) surface every driver serves
+ * (conformance-pinned): `enqueuedAt` with any filters; `runAt` for
+ * `states: ["delayed"]` within a `queue`; `finishedAt` for terminal
+ * `states`, with or without `name`/`queue`. Beyond that surface a driver
+ * either serves the query or dies with `ListOrderUnsupportedError` — never
+ * a silent full scan. Memory and Postgres serve every combination.
  *
  * @since 0.1.0
  */
@@ -606,11 +615,37 @@ export interface ListOptions {
   readonly states?: ReadonlyArray<JobState> | undefined
   /** Every entry must match the record's metadata exactly (AND semantics). */
   readonly metadata?: Readonly<Record<string, string>> | undefined
+  /**
+   * The field to order by (default `enqueuedAt`). Jobs missing the field
+   * (`finishedAt` on non-terminal rows) sort as 0.
+   *
+   * @since 0.7.0
+   */
+  readonly orderBy?: "enqueuedAt" | "runAt" | "finishedAt" | undefined
+  /**
+   * Direction (default `desc`). The id tiebreak follows the direction.
+   *
+   * @since 0.7.0
+   */
+  readonly order?: "asc" | "desc" | undefined
   readonly cursor?: string | undefined
   /** Page size; default 50. */
   readonly limit?: number | undefined
 }
 
+/**
+ * A driver received a (filter, `orderBy`) combination outside the surface
+ * it can serve without a full scan (see `ListOptions`). Delivered as a
+ * defect: the query contradicts the driver's documented matrix, which is a
+ * programming mistake, not a runtime condition to recover from.
+ *
+ * @since 0.7.0
+ */
+export class ListOrderUnsupportedError extends Data.TaggedError("ListOrderUnsupportedError")<{
+  readonly orderBy: string
+  readonly message: string
+}> {}
+
 /**
  * @since 0.1.0
  */

package/src/MemoryJobStore.ts

@@ -795,7 +795,14 @@ const makeStoreUnsafe = (options?: MemoryJobStoreOptions | undefined): MemorySto
       Effect.sync(() => {
         const limit = Math.max(1, options.limit ?? 50)
         const states = options.states === undefined ? undefined : new Set(options.states)
-        // Newest first, stable across retries: (enqueuedAt desc, id desc).
+        const orderBy = options.orderBy ?? "enqueuedAt"
+        const descending = (options.order ?? "desc") === "desc"
+        // Jobs missing the field (finishedAt on non-terminal rows) sort as 0.
+        const orderValue = (job: MemJob): number =>
+          orderBy === "enqueuedAt" ? job.enqueuedAt : orderBy === "runAt" ? job.runAt : job.finishedAt ?? 0
+        const compareIds = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0)
+        // Stable across retries: the id tiebreak follows the direction, and
+        // the cursor excludes everything at or before its (value, id).
         let cursor: { readonly at: number; readonly id: string } | undefined
         if (options.cursor !== undefined) {
           const split = options.cursor.indexOf(":")
@@ -811,26 +818,27 @@ const makeStoreUnsafe = (options?: MemoryJobStoreOptions | undefined): MemorySto
             (states === undefined || states.has(job.state)) &&
             (options.metadata === undefined || metadataMatches(job.metadata, options.metadata))
           )
-          .toSorted((a, b) =>
-            b.enqueuedAt !== a.enqueuedAt
-              ? b.enqueuedAt - a.enqueuedAt
-              : b.id < a.id
-              ? -1
-              : b.id > a.id
-              ? 1
-              : 0
-          )
-          .filter((job) =>
-            cursor === undefined ||
-            job.enqueuedAt < cursor.at ||
-            (job.enqueuedAt === cursor.at && job.id < cursor.id)
-          )
+          .toSorted((a, b) => {
+            const byValue = descending
+              ? orderValue(b) - orderValue(a)
+              : orderValue(a) - orderValue(b)
+            if (byValue !== 0) return byValue
+            return descending ? compareIds(b.id, a.id) : compareIds(a.id, b.id)
+          })
+          .filter((job) => {
+            if (cursor === undefined) return true
+            const value = orderValue(job)
+            if (descending) {
+              return value < cursor.at || (value === cursor.at && job.id < cursor.id)
+            }
+            return value > cursor.at || (value === cursor.at && job.id > cursor.id)
+          })
         const items = matches.slice(0, limit).map(snapshot)
-        const last = items[items.length - 1]
+        const lastJob = matches[Math.min(limit, matches.length) - 1]
         const result: ListResult = {
           items,
-          cursor: matches.length > limit && last !== undefined
-            ? `${last.enqueuedAt}:${last.id}`
+          cursor: matches.length > limit && lastJob !== undefined
+            ? `${orderValue(lastJob)}:${lastJob.id}`
             : undefined
         }
         return result

package/src/drizzle-postgres/DrizzleJobStore.ts

@@ -1585,12 +1585,30 @@ export const make = (
           if (listOptions.metadata !== undefined && Object.keys(listOptions.metadata).length > 0) {
             conditions.push(sql`${jobs.metadata} @> ${JSON.stringify(listOptions.metadata)}::jsonb`)
           }
+          const orderBy = listOptions.orderBy ?? "enqueuedAt"
+          const descending = (listOptions.order ?? "desc") === "desc"
+          // Order on the exact value the record reports: enqueued_at/run_at
+          // are NOT NULL columns; finished_at is absent on non-terminal rows
+          // and sorts as 0 — COALESCE to the epoch, which is what the
+          // `<orderValueMillis>:<id>` cursor round-trips through `new
+          // Date(0)`. All stored timestamps were bound from the Clock at
+          // millisecond precision, so cursor equality comparisons are exact.
+          const orderExpr = orderBy === "enqueuedAt"
+            ? sql`${jobs.enqueuedAt}`
+            : orderBy === "runAt"
+            ? sql`${jobs.runAt}`
+            : sql`COALESCE(${jobs.finishedAt}, 'epoch'::timestamptz)`
+          const direction = descending ? sql`DESC` : sql`ASC`
           if (listOptions.cursor !== undefined) {
+            // Exclusive keyset: `<orderValueMillis>:<id>`, strictly past the
+            // cursor row in the requested direction (id tiebreak included).
             const split = listOptions.cursor.indexOf(":")
             const cursorAt = new Date(Number(listOptions.cursor.slice(0, split)))
             const cursorId = listOptions.cursor.slice(split + 1)
             conditions.push(
-              sql`(${jobs.enqueuedAt}, ${jobs.id}) < (${cursorAt}, ${cursorId})`
+              descending
+                ? sql`(${orderExpr}, ${jobs.id}) < (${cursorAt}, ${cursorId})`
+                : sql`(${orderExpr}, ${jobs.id}) > (${cursorAt}, ${cursorId})`
             )
           }
           const rows = rowsOf(yield* db.execute<JobRow>(sql`
@@ -1610,7 +1628,7 @@ export const make = (
               ${jobs.exit} AS "exit", ${jobs.failedReason} AS "failedReason"
             FROM ${jobs}
             WHERE ${sql.join(conditions, sql` AND `)}
-            ORDER BY ${jobs.enqueuedAt} DESC, ${jobs.id} DESC
+            ORDER BY ${orderExpr} ${direction}, ${jobs.id} ${direction}
             LIMIT ${limit + 1}
           `).pipe(Effect.mapError(storeError("list failed"))))
           const items = rows.slice(0, limit).map(toRecord)
@@ -1618,7 +1636,13 @@ export const make = (
           return {
             items,
             cursor: rows.length > limit && last !== undefined
-              ? `${last.enqueuedAt}:${last.id}`
+              ? `${
+                orderBy === "enqueuedAt"
+                  ? last.enqueuedAt
+                  : orderBy === "runAt"
+                  ? last.runAt
+                  : last.finishedAt ?? 0
+              }:${last.id}`
               : undefined
           }
         }),

package/src/redis/RedisJobStore.ts

@@ -12,7 +12,20 @@
  *
  * @since 0.2.0
  */
-import { Clock, type Context, Deferred, Duration, Effect, Exit, Layer, Option, Queue, Schedule, type Scope } from "effect"
+import {
+  Clock,
+  type Context,
+  Data,
+  Deferred,
+  Duration,
+  Effect,
+  Exit,
+  Layer,
+  Option,
+  Queue,
+  Schedule,
+  type Scope
+} from "effect"
 import { Redis } from "effect/unstable/persistence"
 import * as JobStore from "../JobStore.ts"
 import * as scripts from "./scripts.ts"
@@ -37,6 +50,65 @@ export interface RedisJobStoreOptions {
    * Default: `j-<n>` from the store's counter. See `JobStore.IdGenerator`.
    */
   readonly idGenerator?: JobStore.IdGenerator | undefined
+  /**
+   * The optional list indexes: `p:byname:<name>` and `p:byqueue:<queue>`,
+   * both scored by `enqueuedAt`, serving `list({ name })` / `list({ queue })`
+   * without a full scan. Default: all on. `false` disables both; a partial
+   * object disables one (`{ name: false }`). Disable an index only when you
+   * never list that way — a `list` that ROUTES to a disabled index dies with
+   * `ListIndexDisabledError` (a query servable from another structure, e.g.
+   * `name` + terminal `states` ordered by `finishedAt`, never touches it).
+   *
+   * This setting is a PER-PREFIX invariant: every store instance sharing a
+   * key prefix must agree on it. Index writes happen at insert time in the
+   * writing process, so a store with an index off inserts rows that index
+   * never sees — enabled readers on the same prefix silently miss those rows
+   * (the `p:index:<kind>:ready` marker churn between mixed stores is a
+   * symptom of the misconfiguration, not a safety net against it).
+   *
+   * Init reconciles each index one-shot. Enabled with no `ready` marker: a
+   * full driver-paged ZSCAN of `p:all` rebuilds it, then stamps the marker
+   * with the rebuild's start time. Enabled with a marker: rows enqueued since
+   * the marker minus a 60s margin are (re-)indexed — so a rolling deploy
+   * whose old, index-less writers kept inserting after the marker landed is
+   * healed by the last new-code boot — and the marker is re-stamped.
+   * Disabled: only the marker is deleted (a future re-enable then does a full
+   * rebuild instead of trusting stale zsets). The zsets themselves are NEVER
+   * deleted at init — this store cannot know whether an enabled sibling is
+   * serving reads from them. After disabling everywhere, reclaim the memory
+   * manually, e.g.:
+   * `redis-cli --scan --pattern '<prefix>:byname:*' | xargs redis-cli del`.
+   *
+   * @since 0.7.0
+   */
+  readonly indexes?: { readonly name?: boolean | undefined; readonly queue?: boolean | undefined } | false | undefined
+}
+
+/**
+ * A `list` query routed to a list index this store is configured not to
+ * maintain (`RedisJobStoreOptions.indexes`). Delivered as a defect, not a
+ * typed failure: the configuration said "we never list this way", so the
+ * query contradicting it is a programming mistake, matching the library's
+ * die-on-config-mistake idiom.
+ *
+ * @since 0.7.0
+ */
+export class ListIndexDisabledError extends Data.TaggedError("ListIndexDisabledError")<{
+  readonly index: "name" | "queue"
+  readonly message: string
+}> {}
+
+const TERMINAL_STATES: ReadonlySet<JobStore.JobState> = new Set(["completed", "failed", "cancelled"])
+
+/**
+ * The `list` predicates the routed structure does NOT pin, applied per row
+ * inside the list script. Field names are part of the script's contract.
+ */
+interface ResidualFilters {
+  readonly queue?: JobStore.QueueName | undefined
+  readonly name?: string | undefined
+  readonly states?: ReadonlyArray<JobStore.JobState> | undefined
+  readonly metadata?: Readonly<Record<string, string>> | undefined
 }
 
 const storeError = (message: string) => (cause: unknown) => new JobStore.JobStoreError({ message, cause })
@@ -202,34 +274,104 @@ export const make = (
     const redis = yield* Redis.Redis
     const prefix = options?.prefix ?? "effect-mq"
     const wakeChannel = `${prefix}:wake`
+    const indexOptions = options?.indexes
+    const indexes: scripts.IndexConfig = indexOptions === false
+      ? { name: false, queue: false }
+      : { name: indexOptions?.name ?? true, queue: indexOptions?.queue ?? true }
+    const HELPERS = scripts.helpers(indexes)
+
+    const evalEnqueue = redis.eval(scripts.enqueue(HELPERS))
+    const evalClaim = redis.eval(scripts.claim(HELPERS))
+    const evalAck = redis.eval(scripts.ack(HELPERS))
+    const evalRelease = redis.eval(scripts.release(HELPERS))
+    const evalExtendLocks = redis.eval(scripts.extendLocks(HELPERS))
+    const evalRecoverStalled = redis.eval(scripts.recoverStalled(HELPERS))
+    const evalGetJob = redis.eval(scripts.getJob(HELPERS))
+    const evalList = redis.eval(scripts.list(HELPERS))
+    const evalIndexMembers = redis.eval(scripts.indexMembers(HELPERS))
+    const evalIndexTailPage = redis.eval(scripts.indexTailPage(HELPERS))
+    const evalCounts = redis.eval(scripts.counts(HELPERS))
+    const evalRemove = redis.eval(scripts.remove(HELPERS))
+    const evalRetry = redis.eval(scripts.retry(HELPERS))
+    const evalCancel = redis.eval(scripts.cancel(HELPERS))
+    const evalPromote = redis.eval(scripts.promote(HELPERS))
+    const evalUpsertSchedule = redis.eval(scripts.upsertSchedule(HELPERS))
+    const evalRemoveSchedule = redis.eval(scripts.removeSchedule(HELPERS))
+    const evalListSchedules = redis.eval(scripts.listSchedules(HELPERS))
+    const evalDueSchedules = redis.eval(scripts.dueSchedules(HELPERS))
+    const evalAdvanceSchedule = redis.eval(scripts.advanceSchedule(HELPERS))
+    const evalTickSchedule = redis.eval(scripts.tickSchedule(HELPERS))
+    const evalEnqueueMany = redis.eval(scripts.enqueueMany(HELPERS))
+    const evalSweepState = redis.eval(scripts.sweepState(HELPERS))
+    const evalSweepDedupes = redis.eval(scripts.sweepDedupes(HELPERS))
+    const evalFanOut = redis.eval(scripts.fanOut(HELPERS))
+    const evalRecordChildResults = redis.eval(scripts.recordChildResults(HELPERS))
+    const evalListChildResults = redis.eval(scripts.listChildResults(HELPERS))
+    const evalFlowSweepWork = redis.eval(scripts.flowSweepWork(HELPERS))
+    const evalMarkChildrenCascaded = redis.eval(scripts.markChildrenCascaded(HELPERS))
 
-    const evalEnqueue = redis.eval(scripts.enqueue)
-    const evalClaim = redis.eval(scripts.claim)
-    const evalAck = redis.eval(scripts.ack)
-    const evalRelease = redis.eval(scripts.release)
-    const evalExtendLocks = redis.eval(scripts.extendLocks)
-    const evalRecoverStalled = redis.eval(scripts.recoverStalled)
-    const evalGetJob = redis.eval(scripts.getJob)
-    const evalList = redis.eval(scripts.list)
-    const evalCounts = redis.eval(scripts.counts)
-    const evalRemove = redis.eval(scripts.remove)
-    const evalRetry = redis.eval(scripts.retry)
-    const evalCancel = redis.eval(scripts.cancel)
-    const evalPromote = redis.eval(scripts.promote)
-    const evalUpsertSchedule = redis.eval(scripts.upsertSchedule)
-    const evalRemoveSchedule = redis.eval(scripts.removeSchedule)
-    const evalListSchedules = redis.eval(scripts.listSchedules)
-    const evalDueSchedules = redis.eval(scripts.dueSchedules)
-    const evalAdvanceSchedule = redis.eval(scripts.advanceSchedule)
-    const evalTickSchedule = redis.eval(scripts.tickSchedule)
-    const evalEnqueueMany = redis.eval(scripts.enqueueMany)
-    const evalSweepState = redis.eval(scripts.sweepState)
-    const evalSweepDedupes = redis.eval(scripts.sweepDedupes)
-    const evalFanOut = redis.eval(scripts.fanOut)
-    const evalRecordChildResults = redis.eval(scripts.recordChildResults)
-    const evalListChildResults = redis.eval(scripts.listChildResults)
-    const evalFlowSweepWork = redis.eval(scripts.flowSweepWork)
-    const evalMarkChildrenCascaded = redis.eval(scripts.markChildrenCascaded)
+    // List-index reconcile, once per boot per index. All work is driver-paged
+    // — never one giant Lua call — so the single-threaded server is never
+    // held. There is no build lock: concurrent boots duplicate idempotent
+    // ZADDs, a crash before the marker stamp makes the next boot redo the
+    // work, and rows inserted meanwhile are indexed live by insertJobRow.
+    //
+    // - enabled, no marker: full rebuild via ZSCAN over `all` (cursor-based
+    //   and linear — immune to score ties and rank shifts; every member
+    //   present for the whole scan is guaranteed returned). Rows deleted
+    //   mid-scan leave at most stale members the read path self-heals.
+    // - enabled, marker present: heal the tail. Index writes are per-process,
+    //   so writers without them (an older version mid-rolling-deploy, or a
+    //   misconfigured indexes-off store) may have inserted unindexed rows
+    //   AFTER the marker landed. Re-indexing everything enqueued since the
+    //   marker minus a 60s margin closes that window: the last enabled boot
+    //   after such writers stop covers everything they wrote before it.
+    // - disabled: delete ONLY the marker (a later re-enable must not trust
+    //   stale zsets). The zsets stay — an enabled sibling may be reading
+    //   them, and this store cannot know.
+    //
+    // Both paths re-stamp the marker with this boot's start time. Init-time
+    // infra failures die — the store never starts half-configured.
+    yield* Effect.gen(function*() {
+      const bootAt = yield* Clock.currentTimeMillis
+      for (const kind of ["name", "queue"] as const) {
+        const marker = `${prefix}:index:${kind}:ready`
+        if (!indexes[kind]) {
+          yield* redis.send("DEL", marker)
+          continue
+        }
+        // SAFETY: GET always replies with a bulk string or null.
+        const stamped = (yield* redis.send("GET", marker)) as string | null
+        const markerAt = stamped === null || stamped === "" ? Number.NaN : Number(stamped)
+        if (Number.isNaN(markerAt)) {
+          let cursor = "0"
+          do {
+            const reply = yield* redis.send("ZSCAN", `${prefix}:all`, cursor, "COUNT", "500")
+            // SAFETY: ZSCAN always replies [nextCursor, member/score pairs].
+            const [next, flat] = reply as [string, ReadonlyArray<string>]
+            cursor = next
+            const ids: Array<string> = []
+            for (let i = 0; i < flat.length; i += 2) {
+              const id = flat[i]
+              if (id !== undefined) ids.push(id)
+            }
+            // COUNT is only a hint — chunk what actually came back.
+            for (let start = 0; start < ids.length; start += 500) {
+              yield* evalIndexMembers(prefix, kind, JSON.stringify(ids.slice(start, start + 500)))
+            }
+          } while (cursor !== "0")
+        } else {
+          const min = String(markerAt - 60_000)
+          let offset = 0
+          while (true) {
+            const scanned = Number(yield* evalIndexTailPage(prefix, kind, min, offset, 500))
+            if (scanned < 500) break
+            offset += scanned
+          }
+        }
+        yield* redis.send("SET", marker, String(bootAt))
+      }
+    }).pipe(Effect.orDie)
 
     // Wake protocol: a queue-filtered waiter registry (same-process wake-ups
     // never depend on the pub/sub round trip), with the channel carrying
@@ -756,24 +898,102 @@ export const make = (
       list: (listOptions) =>
         Effect.gen(function*() {
           const limit = Math.max(1, listOptions.limit ?? 50)
-          const filters = {
-            queue: listOptions.queue,
-            name: listOptions.name,
-            states: listOptions.states,
-            metadata: listOptions.metadata
+          const { metadata, name, queue, states } = listOptions
+          const orderBy = listOptions.orderBy ?? "enqueuedAt"
+          const order = listOptions.order ?? "desc"
+          // Routing: the narrowest structure whose zset score IS the
+          // requested order value; everything it does not pin stays a
+          // residual predicate applied in-script. Routing runs BEFORE the
+          // disabled-index check — a query another structure serves (e.g.
+          // name + terminal states ordered by finishedAt) must never die.
+          let sources: ReadonlyArray<string>
+          let residual: ResidualFilters
+          if (orderBy === "finishedAt") {
+            if (states === undefined || states.some((state) => !TERMINAL_STATES.has(state))) {
+              return yield* Effect.die(
+                new JobStore.ListOrderUnsupportedError({
+                  orderBy,
+                  message: "effect-mq: the Redis store serves orderBy \"finishedAt\" only with " +
+                    "states ⊆ {completed, failed, cancelled} (the finished/terminal zsets carry that order)"
+                })
+              )
+            }
+            // ≤3 per-state sources, merged by (finishedAt, id) in-script.
+            const uniqueStates = [...new Set(states)]
+            sources = name === undefined
+              ? uniqueStates.map((state) => `${prefix}:finished:${state}`)
+              : uniqueStates.map((state) => `${prefix}:terminal:${name}:${state}`)
+            residual = { queue, metadata }
+          } else if (orderBy === "runAt") {
+            const onlyDelayed = states !== undefined && states.length > 0 &&
+              states.every((state) => state === "delayed")
+            if (queue === undefined || !onlyDelayed) {
+              return yield* Effect.die(
+                new JobStore.ListOrderUnsupportedError({
+                  orderBy,
+                  message: "effect-mq: the Redis store serves orderBy \"runAt\" only with " +
+                    "states: [\"delayed\"] and a queue (the delayed:<queue> zset carries that order)"
+                })
+              )
+            }
+            sources = [`${prefix}:delayed:${queue}`]
+            residual = { name, metadata }
+          } else if (name !== undefined) {
+            if (!indexes.name) {
+              return yield* Effect.die(
+                new ListIndexDisabledError({
+                  index: "name",
+                  message: "effect-mq: list({ name }) routes to the byname index, " +
+                    "but RedisJobStoreOptions.indexes.name is disabled for this store"
+                })
+              )
+            }
+            sources = [`${prefix}:byname:${name}`]
+            residual = { queue, states, metadata }
+          } else if (queue !== undefined) {
+            if (!indexes.queue) {
+              return yield* Effect.die(
+                new ListIndexDisabledError({
+                  index: "queue",
+                  message: "effect-mq: list({ queue }) routes to the byqueue index, " +
+                    "but RedisJobStoreOptions.indexes.queue is disabled for this store"
+                })
+              )
+            }
+            sources = [`${prefix}:byqueue:${queue}`]
+            residual = { states, metadata }
+          } else {
+            sources = [`${prefix}:all`]
+            residual = { states, metadata }
           }
           const reply: { items: ReadonlyArray<ReadonlyArray<string>> | Record<string, never>; more: boolean } = JSON
             .parse(
-              yield* evalList(prefix, JSON.stringify(filters), listOptions.cursor ?? "", limit)
+              yield* evalList(
+                prefix,
+                JSON.stringify(sources),
+                order,
+                JSON.stringify(residual),
+                listOptions.cursor ?? "",
+                limit
+              ).pipe(Effect.mapError(storeError("list failed")))
             )
           const items = asArray(reply.items).map((flat) => toRecord(foldPairs(flat)))
           const last = items[items.length - 1]
+          // The cursor value is the order field, which equals the routed
+          // zset's score for every row the script returned.
+          const orderValue = last === undefined
+            ? 0
+            : orderBy === "enqueuedAt"
+            ? last.enqueuedAt
+            : orderBy === "runAt"
+            ? last.runAt
+            : last.finishedAt ?? 0
           const result: JobStore.ListResult = {
             items,
-            cursor: reply.more && last !== undefined ? `${last.enqueuedAt}:${last.id}` : undefined
+            cursor: reply.more && last !== undefined ? `${orderValue}:${last.id}` : undefined
           }
           return result
-        }).pipe(Effect.mapError(storeError("list failed"))),
+        }),
 
       retry: (id) =>
         Effect.gen(function*() {