@reventlessdev/reventless-local 3.0.0-alpha.248 → 3.0.0-alpha.250

package/tests/adapter/ScheduledPublisherTest.res

@@ -51,149 +51,185 @@ let makeTopicResource = (topicName: string): ReventlessInfra.Adapter.resolvedRes
 
 describe("LocalScheduledPublisher", () => {
   describe("createSchedule", () => {
-    testPromise("single-shot schedule fires event after runAllTimers", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("sched-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="scheduler", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "one-shot",
-        rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("sched-topic")], schedule)
-      jest->runAllTimers
-      // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
-      // child fibers via startFork — one tick for the child fiber to offer to the Queue,
-      // a second tick for the drain fiber to run the callback.
-      let _ = await Promise.resolve(())
-      let _ = await Promise.resolve(())
-      expect(count.contents)->toBe(1)
-      SP.reset()
-    })
-
-    testPromise("recurring schedule fires on each interval advance", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("repeat-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="scheduler2", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "every-minute",
-        rate: Reventless.Schedule.Minutes(1),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("repeat-topic")], schedule)
-      jest->advanceTimersByTime(60 * 1000)
-      let _ = await Promise.resolve(())
-      let _ = await Promise.resolve(())
-      jest->advanceTimersByTime(60 * 1000)
-      let _ = await Promise.resolve(())
-      let _ = await Promise.resolve(())
-      expect(count.contents)->toBe(2)
-      SP.reset()
-    })
+    testPromise(
+      "single-shot schedule fires event after runAllTimers",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "sched-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="scheduler", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "one-shot",
+          rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("sched-topic")], schedule)
+        jest->runAllTimers
+        // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
+        // child fibers via startFork — one tick for the child fiber to offer to the Queue,
+        // a second tick for the drain fiber to run the callback.
+        let _ = await Promise.resolve()
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(1)
+        SP.reset()
+      },
+    )
+
+    testPromise(
+      "recurring schedule fires on each interval advance",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "repeat-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="scheduler2", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "every-minute",
+          rate: Reventless.Schedule.Minutes(1),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("repeat-topic")], schedule)
+        jest->advanceTimersByTime(60 * 1000)
+        let _ = await Promise.resolve()
+        let _ = await Promise.resolve()
+        jest->advanceTimersByTime(60 * 1000)
+        let _ = await Promise.resolve()
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(2)
+        SP.reset()
+      },
+    )
   })
 
   describe("deleteSchedule", () => {
-    testPromise("clears a named schedule; advancing timers does not fire it", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("del-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="scheduler3", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "to-delete",
-        rate: Reventless.Schedule.Minutes(1),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("del-topic")], schedule)
-      await ops.deleteSchedule([], "to-delete")
-      jest->advanceTimersByTime(60 * 1000)
-      expect(count.contents)->toBe(0)
-      SP.reset()
-    })
+    testPromise(
+      "clears a named schedule; advancing timers does not fire it",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "del-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="scheduler3", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "to-delete",
+          rate: Reventless.Schedule.Minutes(1),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("del-topic")], schedule)
+        await ops.deleteSchedule([], "to-delete")
+        jest->advanceTimersByTime(60 * 1000)
+        expect(count.contents)->toBe(0)
+        SP.reset()
+      },
+    )
   })
 
   describe("reset", () => {
-    testPromise("clears all active timers; subsequent advance does not fire", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("reset-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="scheduler4", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "reset-sched",
-        rate: Reventless.Schedule.Minutes(5),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("reset-topic")], schedule)
-      SP.reset()
-      jest->advanceTimersByTime(5 * 60 * 1000)
-      expect(count.contents)->toBe(0)
-    })
+    testPromise(
+      "clears all active timers; subsequent advance does not fire",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "reset-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="scheduler4", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "reset-sched",
+          rate: Reventless.Schedule.Minutes(5),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("reset-topic")], schedule)
+        SP.reset()
+        jest->advanceTimersByTime(5 * 60 * 1000)
+        expect(count.contents)->toBe(0)
+      },
+    )
   })
 
   describe("rateToMs", () => {
-    testPromise("Minutes(n) fires after n minutes", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("rate-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="rate-scheduler", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "rate-sched",
-        rate: Reventless.Schedule.Minutes(3),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("rate-topic")], schedule)
-      // Advance by slightly less than 3 minutes — should not fire
-      jest->advanceTimersByTime(3 * 60 * 1000 - 1)
-      expect(count.contents)->toBe(0)
-      // Advance the remaining millisecond — now fires; two ticks for Effect.all drain
-      jest->advanceTimersByTime(1)
-      let _ = await Promise.resolve(())
-      let _ = await Promise.resolve(())
-      expect(count.contents)->toBe(1)
-      SP.reset()
-    })
-
-    testPromise("Hours(n) fires after n hours", async () => {
-      module TestBus = LocalBus.Make()
-      module SP = LocalScheduledPublisher.Make(TestBus)
-      let count: ref<int> = ref(0)
-      TestBus.subscribeToEvents("hours-topic", async (_, _, _) => {
-        count := count.contents + 1
-      })
-      let pub = SP.make(~name="hours-scheduler", ~opts={})
-      let ops = await pub.operations->TestRunner.resolve
-      let schedule: Reventless.Schedule.schedule = {
-        name: "hours-sched",
-        rate: Reventless.Schedule.Hours(2),
-        payload: "{}",
-      }
-      await ops.createSchedule([makeTopicResource("hours-topic")], schedule)
-      jest->advanceTimersByTime(2 * 60 * 60 * 1000)
-      let _ = await Promise.resolve(())
-      let _ = await Promise.resolve(())
-      expect(count.contents)->toBe(1)
-      SP.reset()
-    })
+    testPromise(
+      "Minutes(n) fires after n minutes",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "rate-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="rate-scheduler", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "rate-sched",
+          rate: Reventless.Schedule.Minutes(3),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("rate-topic")], schedule)
+        // Advance by slightly less than 3 minutes — should not fire
+        jest->advanceTimersByTime(3 * 60 * 1000 - 1)
+        expect(count.contents)->toBe(0)
+        // Advance the remaining millisecond — now fires; two ticks for Effect.all drain
+        jest->advanceTimersByTime(1)
+        let _ = await Promise.resolve()
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(1)
+        SP.reset()
+      },
+    )
+
+    testPromise(
+      "Hours(n) fires after n hours",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module SP = LocalScheduledPublisher.Make(TestBus)
+        let count: ref<int> = ref(0)
+        TestBus.subscribeToEvents(
+          "hours-topic",
+          async (_, _, _) => {
+            count := count.contents + 1
+          },
+        )
+        let pub = SP.make(~name="hours-scheduler", ~opts={})
+        let ops = await pub.operations->TestRunner.resolve
+        let schedule: Reventless.Schedule.schedule = {
+          name: "hours-sched",
+          rate: Reventless.Schedule.Hours(2),
+          payload: "{}",
+        }
+        await ops.createSchedule([makeTopicResource("hours-topic")], schedule)
+        jest->advanceTimersByTime(2 * 60 * 60 * 1000)
+        let _ = await Promise.resolve()
+        let _ = await Promise.resolve()
+        expect(count.contents)->toBe(1)
+        SP.reset()
+      },
+    )
   })
 })

package/tests/adapter/ServedBucketHttpTest.res

@@ -44,31 +44,32 @@ type httpRes
 let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
   Promise.make((resolve, reject) => {
     let bodyStr = body->JSON.Encode.object->JSON.stringify
-    let req =
-      _request(
-        {
-          hostname: "localhost",
-          port,
-          path,
-          method: "POST",
-          headers: Dict.fromArray([
-            ("content-type", "application/json"),
-            ("content-length", bodyStr->String.length->Int.toString),
-          ]),
-        },
-        res => {
-          let status = _resStatusCode(res)
-          let buf = ref("")
-          res->_resSetEncoding("utf8")
-          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
-          res->_resOnEnd(() => {
+    let req = _request(
+      {
+        hostname: "localhost",
+        port,
+        path,
+        method: "POST",
+        headers: Dict.fromArray([
+          ("content-type", "application/json"),
+          ("content-length", bodyStr->String.length->Int.toString),
+        ]),
+      },
+      res => {
+        let status = _resStatusCode(res)
+        let buf = ref("")
+        res->_resSetEncoding("utf8")
+        res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+        res->_resOnEnd(
+          () => {
             let parsed = try buf.contents->JSON.parseOrThrow catch {
             | _ => JSON.Encode.null
             }
             resolve((status, parsed))
-          })
-        },
-      )
+          },
+        )
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqWrite(bodyStr)
     req->_reqEnd
@@ -78,24 +79,23 @@ let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
 // only for ASCII payloads, which the SVG fixture below is.
 let putRaw = (path: string, body: string, ~contentType: string): promise<int> =>
   Promise.make((resolve, reject) => {
-    let req =
-      _request(
-        {
-          hostname: "localhost",
-          port,
-          path,
-          method: "PUT",
-          headers: Dict.fromArray([
-            ("content-type", contentType),
-            ("content-length", body->String.length->Int.toString),
-          ]),
-        },
-        res => {
-          let status = _resStatusCode(res)
-          res->_resOnData(_ => ())
-          res->_resOnEnd(() => resolve(status))
-        },
-      )
+    let req = _request(
+      {
+        hostname: "localhost",
+        port,
+        path,
+        method: "PUT",
+        headers: Dict.fromArray([
+          ("content-type", contentType),
+          ("content-length", body->String.length->Int.toString),
+        ]),
+      },
+      res => {
+        let status = _resStatusCode(res)
+        res->_resOnData(_ => ())
+        res->_resOnEnd(() => resolve(status))
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqWrite(body)
     req->_reqEnd
@@ -103,24 +103,27 @@ let putRaw = (path: string, body: string, ~contentType: string): promise<int> =>
 
 let getRaw = (path: string): promise<(int, string, string)> =>
   Promise.make((resolve, reject) => {
-    let req =
-      _request(
-        {hostname: "localhost", port, path, method: "GET", headers: Dict.make()},
-        res => {
-          let status = _resStatusCode(res)
-          let contentType = _resHeaders(res)->Dict.get("content-type")->Option.getOr("")
-          let buf = ref("")
-          res->_resSetEncoding("utf8")
-          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
-          res->_resOnEnd(() => resolve((status, buf.contents, contentType)))
-        },
-      )
+    let req = _request(
+      {hostname: "localhost", port, path, method: "GET", headers: Dict.make()},
+      res => {
+        let status = _resStatusCode(res)
+        let contentType = _resHeaders(res)->Dict.get("content-type")->Option.getOr("")
+        let buf = ref("")
+        res->_resSetEncoding("utf8")
+        res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+        res->_resOnEnd(() => resolve((status, buf.contents, contentType)))
+      },
+    )
     req->_reqOnError(err => reject(Obj.magic(err)))
     req->_reqEnd
   })
 
 let getString = (j: JSON.t, k: string): string =>
-  j->JSON.Decode.object->Option.flatMap(d => d->Dict.get(k))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+  j
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(k))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("")
 
 // ── Lifecycle ────────────────────────────────────────────────────────────────
 
@@ -198,13 +201,16 @@ testPromise("presign → PUT → GET → release → GET(404) is the full loop",
   expect(goneStatus)->toEqual(404)
 })
 
-testPromise("Upload_Release of a ref outside a served prefix is refused with a reason", async () => {
-  let r = await releaseRef(~storageRef="/not-a-store/x/y.svg")
-  expect(r->JSON.Decode.object->Option.flatMap(d => d->Dict.get("released")))->toEqual(
-    Some(JSON.Encode.bool(false)),
-  )
-  expect(getString(r, "reason"))->toEqual("not_in_store")
-})
+testPromise(
+  "Upload_Release of a ref outside a served prefix is refused with a reason",
+  async () => {
+    let r = await releaseRef(~storageRef="/not-a-store/x/y.svg")
+    expect(r->JSON.Decode.object->Option.flatMap(d => d->Dict.get("released")))->toEqual(
+      Some(JSON.Encode.bool(false)),
+    )
+    expect(getString(r, "reason"))->toEqual("not_in_store")
+  },
+)
 
 testPromise("GET a missing served object returns 404", async () => {
   let (status, _, _) = await getRaw("/uploads/missing/none.svg")

package/tests/adapter/SortKey_FilterTest.res

@@ -20,14 +20,24 @@ let skField = "_subId"
 
 let getSks = result =>
   result.SortKey_Filter.items->Array.map(item =>
-    item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(skField))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+    item
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get(skField))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("")
   )
 
 describe("SortKey_Filter.apply:", () => {
   testPromise("no filters returns all items in order", async () => {
     let r = SortKey_Filter.apply(~items, ~skField)
     expect(r.items->Array.length)->toBe(5)
-    expect(getSks(r))->toEqual(["art/2026-01", "art/2026-02", "math/2026-01", "math/2026-02", "science/2026-01"])
+    expect(getSks(r))->toEqual([
+      "art/2026-01",
+      "art/2026-02",
+      "math/2026-01",
+      "math/2026-02",
+      "science/2026-01",
+    ])
     expect(r.nextToken)->toBe(None)
   })
 
@@ -59,7 +69,13 @@ describe("SortKey_Filter.apply:", () => {
 
   testPromise("reverse returns items in descending order", async () => {
     let r = SortKey_Filter.apply(~items, ~skField, ~reverse=true)
-    expect(getSks(r))->toEqual(["science/2026-01", "math/2026-02", "math/2026-01", "art/2026-02", "art/2026-01"])
+    expect(getSks(r))->toEqual([
+      "science/2026-01",
+      "math/2026-02",
+      "math/2026-01",
+      "art/2026-02",
+      "art/2026-01",
+    ])
   })
 
   testPromise("limit returns first N items", async () => {

package/tests/adapter/SqliteDriverTest.res

@@ -37,20 +37,24 @@ describe("SqliteDriver", () => {
     let insert = db->SqliteDriver.prepare("INSERT INTO t(id) VALUES(?)")
     let countAll = db->SqliteDriver.prepare("SELECT COUNT(*) AS c FROM t")
 
-    db->SqliteDriver.transaction(() => {
-      insert->SqliteDriver.run([JSON.Encode.int(1)])
-      insert->SqliteDriver.run([JSON.Encode.int(2)])
-    })
+    db->SqliteDriver.transaction(
+      () => {
+        insert->SqliteDriver.run([JSON.Encode.int(1)])
+        insert->SqliteDriver.run([JSON.Encode.int(2)])
+      },
+    )
 
     let row = countAll->SqliteDriver.get([])->Option.getOrThrow
     expect(row->Dict.get("c")->Option.getOr(JSON.Encode.null))->toEqual(JSON.Encode.int(2))
 
     let didThrow = ref(false)
     try {
-      db->SqliteDriver.transaction(() => {
-        insert->SqliteDriver.run([JSON.Encode.int(3)])
-        throw(Failure("boom"))
-      })
+      db->SqliteDriver.transaction(
+        () => {
+          insert->SqliteDriver.run([JSON.Encode.int(3)])
+          throw(Failure("boom"))
+        },
+      )
     } catch {
     | Failure(_) => didThrow := true
     }
@@ -63,8 +67,7 @@ describe("SqliteDriver", () => {
   })
 
   testPromise("Backend.fromEnv parses sqlite path and reset flag", async () => {
-    let originalEnv =
-      NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND")
+    let originalEnv = NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND")
 
     NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
     let parsed = Backend.fromEnv()