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

package/tests/adapter/BackendParityTest.res

@@ -10,7 +10,6 @@
 
 open JestGlobals
 
-
 let _ = TestRunner.setup()
 let opts: Pulumi.CustomResourceOptions.t = {}
 
@@ -80,21 +79,22 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-qdb", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let s = Storage.make(
+        ~name="parity-qdb",
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~owner=None,
+        ~opts,
+      )
       let ops = await s.operations->TestRunner.resolve
 
-      let _ = await ops.save(
-        "k",
-        JSON.Encode.string("val"),
-        ReventlessCore.QueryDb.Any,
-        None,
-      )
+      let _ = await ops.save("k", JSON.Encode.string("val"), ReventlessCore.QueryDb.Any, None)
 
-      let items =
-        await ops.loadStream("k")
-        ->Stream.runCollect
-        ->Effect.catchAll(_ => Effect.succeed([]))
-        ->Effect.runPromise
+      let items = await ops.loadStream("k")
+      ->Stream.runCollect
+      ->Effect.catchAll(_ => Effect.succeed([]))
+      ->Effect.runPromise
       expect(items->Array.length)->toBe(1)
       expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val"))
     }
@@ -103,46 +103,62 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
-  testPromise("QueryDb: count returns a running total and loadStream reflects it under both", async () => {
-    let scenario = async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-count", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
+  testPromise(
+    "QueryDb: count returns a running total and loadStream reflects it under both",
+    async () => {
+      let scenario = async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(
+          ~name="parity-count",
+          ~indexes=[],
+          ~api=(),
+          ~apiRole=(),
+          ~owner=None,
+          ~opts,
+        )
+        let ops = await s.operations->TestRunner.resolve
 
-      // First increment creates the counter item and returns the new total.
-      let r1 = await ops.count("prod-1", "orderCount", 3)
-      expect(r1)->toEqual(Ok(3))
-      // Second increment accumulates (not just echoes the increment).
-      let r2 = await ops.count("prod-1", "orderCount", 2)
-      expect(r2)->toEqual(Ok(5))
+        // First increment creates the counter item and returns the new total.
+        let r1 = await ops.count("prod-1", "orderCount", 3)
+        expect(r1)->toEqual(Ok(3))
+        // Second increment accumulates (not just echoes the increment).
+        let r2 = await ops.count("prod-1", "orderCount", 2)
+        expect(r2)->toEqual(Ok(5))
 
-      // loadStream must see the persisted counter — count is not a side channel.
-      let items =
-        await ops.loadStream("prod-1")
+        // loadStream must see the persisted counter — count is not a side channel.
+        let items = await ops.loadStream("prod-1")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(items->Array.length)->toBe(1)
-      let field =
-        items
-        ->Array.getUnsafe(0)
-        ->JSON.Decode.object
-        ->Option.flatMap(o => o->Dict.get("orderCount"))
-        ->Option.flatMap(JSON.Decode.float)
-        ->Option.mapOr(0, Float.toInt)
-      expect(field)->toBe(5)
-    }
+        expect(items->Array.length)->toBe(1)
+        let field =
+          items
+          ->Array.getUnsafe(0)
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("orderCount"))
+          ->Option.flatMap(JSON.Decode.float)
+          ->Option.mapOr(0, Float.toInt)
+        expect(field)->toBe(5)
+      }
 
-    await runUnderMemory(scenario)
-    await runUnderSqlite(scenario)
-  })
+      await runUnderMemory(scenario)
+      await runUnderSqlite(scenario)
+    },
+  )
 
   testPromise("QueryDb: an expired-TTL item is filtered from loadStream under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let s = Storage.make(
+        ~name="parity-ttl",
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~owner=None,
+        ~opts,
+      )
       let ops = await s.operations->TestRunner.resolve
 
       let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
@@ -171,16 +187,25 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-kind", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let s = Storage.make(
+        ~name="parity-kind",
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~owner=None,
+        ~opts,
+      )
       let ops = await s.operations->TestRunner.resolve
 
       let kinds = []
-      TestBus.subscribeToStateChanges("parity-kind", descriptor =>
-        descriptor
-        ->JSON.Decode.object
-        ->Option.flatMap(o => o->Dict.get("changeKind"))
-        ->Option.flatMap(JSON.Decode.string)
-        ->Option.forEach(k => kinds->Array.push(k))
+      TestBus.subscribeToStateChanges(
+        "parity-kind",
+        descriptor =>
+          descriptor
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("changeKind"))
+          ->Option.flatMap(JSON.Decode.string)
+          ->Option.forEach(k => kinds->Array.push(k)),
       )
 
       let item = (k, v) =>
@@ -205,101 +230,126 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
-  testPromise("QueryDb: a descriptor carries the saved row and a rising seq under both", async () => {
-    let scenario = async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(
-        ~name="parity-payload",
-        ~indexes=[],
-        ~api=(),
-        ~apiRole=(),
-        ~owner=None,
-        ~opts,
-      )
-      let ops = await s.operations->TestRunner.resolve
-
-      let descriptors = []
-      TestBus.subscribeToStateChanges("parity-payload", d => descriptors->Array.push(d))
-
-      let field = (d, key) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
-      let item = (k, v) =>
-        JSON.Encode.object(
-          Dict.fromArray([("id", JSON.Encode.string(k)), ("v", JSON.Encode.string(v))]),
+  testPromise(
+    "QueryDb: a descriptor carries the saved row and a rising seq under both",
+    async () => {
+      let scenario = async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(
+          ~name="parity-payload",
+          ~indexes=[],
+          ~api=(),
+          ~apiRole=(),
+          ~owner=None,
+          ~opts,
         )
-      let stateAt = i => descriptors->Array.get(i)->Option.flatMap(d => field(d, "state"))
-
-      let _ = await ops.save("p1", item("p1", "one"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.save("p1", item("p1", "two"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.delete("p1", None)
+        let ops = await s.operations->TestRunner.resolve
+
+        let descriptors = []
+        TestBus.subscribeToStateChanges("parity-payload", d => descriptors->Array.push(d))
+
+        let field = (d, key) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
+        let item = (k, v) =>
+          JSON.Encode.object(
+            Dict.fromArray([("id", JSON.Encode.string(k)), ("v", JSON.Encode.string(v))]),
+          )
+        let stateAt = i => descriptors->Array.get(i)->Option.flatMap(d => field(d, "state"))
+
+        let _ = await ops.save("p1", item("p1", "one"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.save("p1", item("p1", "two"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.delete("p1", None)
+
+        // The point of the payload: a subscriber can apply the row it was handed
+        // instead of spending a round-trip to fetch what the platform already had.
+        expect(stateAt(0))->toEqual(Some(item("p1", "one")))
+        expect(stateAt(1))->toEqual(Some(item("p1", "two")))
+        // A delete has no new row to carry.
+        expect(stateAt(2))->toEqual(None)
+
+        // seq only has to rise — it is monotonic, not consecutive, so a client can
+        // reject a stale payload but cannot count gaps.
+        let seqs =
+          descriptors->Array.filterMap(
+            d =>
+              field(d, "seq")->Option.flatMap(JSON.Decode.string)->Option.flatMap(Float.fromString),
+          )
+        expect(seqs->Array.length)->toBe(3)
+        let rising =
+          seqs->Array.everyWithIndex((v, i) => i == 0 || v > seqs->Array.getUnsafe(i - 1))
+        expect(rising)->toBe(true)
+      }
 
-      // The point of the payload: a subscriber can apply the row it was handed
-      // instead of spending a round-trip to fetch what the platform already had.
-      expect(stateAt(0))->toEqual(Some(item("p1", "one")))
-      expect(stateAt(1))->toEqual(Some(item("p1", "two")))
-      // A delete has no new row to carry.
-      expect(stateAt(2))->toEqual(None)
-
-      // seq only has to rise — it is monotonic, not consecutive, so a client can
-      // reject a stale payload but cannot count gaps.
-      let seqs =
-        descriptors->Array.filterMap(d =>
-          field(d, "seq")->Option.flatMap(JSON.Decode.string)->Option.flatMap(Float.fromString)
+      await runUnderMemory(scenario)
+      await runUnderSqlite(scenario)
+    },
+  )
+
+  testPromise(
+    "QueryDb: saveBatch reports Added then Updated for a repeated key under both",
+    async () => {
+      let scenario = async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(
+          ~name="parity-batch",
+          ~indexes=[],
+          ~api=(),
+          ~apiRole=(),
+          ~owner=None,
+          ~opts,
+        )
+        let ops = await s.operations->TestRunner.resolve
+
+        let kinds = []
+        TestBus.subscribeToStateChanges(
+          "parity-batch",
+          descriptor =>
+            descriptor
+            ->JSON.Decode.object
+            ->Option.flatMap(o => o->Dict.get("changeKind"))
+            ->Option.flatMap(JSON.Decode.string)
+            ->Option.forEach(k => kinds->Array.push(k)),
         )
-      expect(seqs->Array.length)->toBe(3)
-      let rising =
-        seqs->Array.everyWithIndex((v, i) => i == 0 || v > seqs->Array.getUnsafe(i - 1))
-      expect(rising)->toBe(true)
-    }
-
-    await runUnderMemory(scenario)
-    await runUnderSqlite(scenario)
-  })
-
-  testPromise("QueryDb: saveBatch reports Added then Updated for a repeated key under both", async () => {
-    let scenario = async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-batch", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
 
-      let kinds = []
-      TestBus.subscribeToStateChanges("parity-batch", descriptor =>
-        descriptor
-        ->JSON.Decode.object
-        ->Option.flatMap(o => o->Dict.get("changeKind"))
-        ->Option.flatMap(JSON.Decode.string)
-        ->Option.forEach(k => kinds->Array.push(k))
-      )
+        let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
+        let _ = await ops.saveBatch([
+          ("a", item("a"), None),
+          ("b", item("b"), None),
+          ("a", item("a"), None),
+        ])
 
-      let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
-      let _ = await ops.saveBatch([
-        ("a", item("a"), None),
-        ("b", item("b"), None),
-        ("a", item("a"), None),
-      ])
+        expect(kinds)->toEqual(["Added", "Added", "Updated"])
+      }
 
-      expect(kinds)->toEqual(["Added", "Added", "Updated"])
-    }
-
-    await runUnderMemory(scenario)
-    await runUnderSqlite(scenario)
-  })
+      await runUnderMemory(scenario)
+      await runUnderSqlite(scenario)
+    },
+  )
 
   testPromise("QueryDb: a counter's first increment is Added under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-ckind", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let s = Storage.make(
+        ~name="parity-ckind",
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~owner=None,
+        ~opts,
+      )
       let ops = await s.operations->TestRunner.resolve
 
       let kinds = []
-      TestBus.subscribeToStateChanges("parity-ckind", descriptor =>
-        descriptor
-        ->JSON.Decode.object
-        ->Option.flatMap(o => o->Dict.get("changeKind"))
-        ->Option.flatMap(JSON.Decode.string)
-        ->Option.forEach(k => kinds->Array.push(k))
+      TestBus.subscribeToStateChanges(
+        "parity-ckind",
+        descriptor =>
+          descriptor
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("changeKind"))
+          ->Option.flatMap(JSON.Decode.string)
+          ->Option.forEach(k => kinds->Array.push(k)),
       )
 
       let _ = await ops.count("prod-1", "orderCount", 1)

package/tests/adapter/CollectNEventsTest.res

@@ -50,10 +50,12 @@ describe("TestRunner.collectNEvents", () => {
     let collecting = TestRunner.collectNEvents(Bus.subscribeToEvents, "T", 3)
     let json = JSON.parseOrThrow("{}")
     let resolved = ref(false)
-    let _ = collecting->Promise.then(events => {
-      resolved := true
-      Promise.resolve(events)
-    })
+    let _ = collecting->Promise.then(
+      events => {
+        resolved := true
+        Promise.resolve(events)
+      },
+    )
     await Bus.publishEvent("T", "svc", meta, json)
     await Bus.publishEvent("T", "svc", meta, json)
     // Only 2 events so far — promise should not yet be resolved.

package/tests/adapter/CommandAuthorizationTest.res

@@ -49,14 +49,11 @@ let userIdentity: Reventless.Identity.t = {
 }
 
 let ctxFor = (identity: Reventless.Identity.t): JSON.t =>
-  JSON.Encode.object(
-    Dict.fromArray([("identity", (identity: Reventless.Identity.t)->Obj.magic)]),
-  )
+  JSON.Encode.object(Dict.fromArray([("identity", (identity: Reventless.Identity.t)->Obj.magic)]))
 
-let anonymousCtx: JSON.t =
-  JSON.Encode.object(
-    Dict.fromArray([("identity", (Reventless.Identity.anonymous: Reventless.Identity.t)->Obj.magic)]),
-  )
+let anonymousCtx: JSON.t = JSON.Encode.object(
+  Dict.fromArray([("identity", (Reventless.Identity.anonymous: Reventless.Identity.t)->Obj.magic)]),
+)
 
 let getTypename = (response: JSON.t): string =>
   response
@@ -125,16 +122,22 @@ describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization",
 
   testPromise("admin invoking payload-less Archive succeeds", async () => {
     let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat1")
-    let response =
-      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), ctxFor(adminIdentity))
+    let response = await archiveResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.make()),
+      ctxFor(adminIdentity),
+    )
     expect(getTypename(response))->toEqual("CommandAccepted")
     expect(calls.contents)->toEqual(["Archive"])
   })
 
   testPromise("regular user invoking Archive is rejected with Forbidden", async () => {
     let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat2")
-    let response =
-      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), ctxFor(userIdentity))
+    let response = await archiveResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.make()),
+      ctxFor(userIdentity),
+    )
     expect(getTypename(response))->toEqual("CommandRejected")
     expect(getErrorCode(response))->toEqual("Forbidden")
     expect(calls.contents)->toEqual([])
@@ -142,8 +145,11 @@ describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization",
 
   testPromise("anonymous invoking Archive is rejected with Forbidden", async () => {
     let (_, _, archiveResolver, calls) = buildFixture(~namespace="Cat3")
-    let response =
-      await archiveResolver(JSON.Encode.null, JSON.Encode.object(Dict.make()), anonymousCtx)
+    let response = await archiveResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.make()),
+      anonymousCtx,
+    )
     expect(getTypename(response))->toEqual("CommandRejected")
     expect(getErrorCode(response))->toEqual("Forbidden")
     expect(calls.contents)->toEqual([])
@@ -151,24 +157,22 @@ describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization",
 
   testPromise("regular user invoking Add (default AllowAuthenticated) succeeds", async () => {
     let (addResolver, _, _, calls) = buildFixture(~namespace="Cat4")
-    let response =
-      await addResolver(
-        JSON.Encode.null,
-        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
-        ctxFor(userIdentity),
-      )
+    let response = await addResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+      ctxFor(userIdentity),
+    )
     expect(getTypename(response))->toEqual("CommandAccepted")
     expect(calls.contents)->toEqual(["Add"])
   })
 
   testPromise("anonymous invoking Add is rejected (AllowAuthenticated default)", async () => {
     let (addResolver, _, _, calls) = buildFixture(~namespace="Cat5")
-    let response =
-      await addResolver(
-        JSON.Encode.null,
-        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
-        anonymousCtx,
-      )
+    let response = await addResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+      anonymousCtx,
+    )
     expect(getTypename(response))->toEqual("CommandRejected")
     expect(getErrorCode(response))->toEqual("Forbidden")
     expect(calls.contents)->toEqual([])
@@ -176,12 +180,11 @@ describe("CommandGeneratorResolvers_GraphQL — per-constructor authorization",
 
   testPromise("admin invoking Add also succeeds (admin has User group too)", async () => {
     let (addResolver, _, _, calls) = buildFixture(~namespace="Cat6")
-    let response =
-      await addResolver(
-        JSON.Encode.null,
-        JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
-        ctxFor(adminIdentity),
-      )
+    let response = await addResolver(
+      JSON.Encode.null,
+      JSON.Encode.object(Dict.fromArray([("name", JSON.Encode.string("Books"))])),
+      ctxFor(adminIdentity),
+    )
     expect(getTypename(response))->toEqual("CommandAccepted")
     expect(calls.contents)->toEqual(["Add"])
   })
@@ -246,10 +249,10 @@ describe("CommandGeneratorResolvers_GraphQL — a failure the caller may read",
   })
 
   testPromise("a caller-fault failure is rethrown as an unmasked GraphQL error", async () => {
-    let resolver = failingFixture(~namespace="Fault1", ~failWith=() =>
-      ReventlessCore.Plugin_ResolverError.throwCallerFault(
-        `Error: Couldn't decode: Expected string | undefined, received null`,
-      )
+    let resolver = failingFixture(
+      ~namespace="Fault1",
+      ~failWith=() =>
+        ReventlessCore.Plugin_ResolverError.throwCallerFault(`Error: Couldn't decode: Expected string | undefined, received null`),
     )
     let caught = await invoke(resolver)
     expect((
@@ -261,10 +264,12 @@ describe("CommandGeneratorResolvers_GraphQL — a failure the caller may read",
   // The reason is the point: masked, the caller learns only that something
   // went wrong on a request that is theirs to fix.
   testPromise("and carries the reason it was given", async () => {
-    let resolver = failingFixture(~namespace="Fault2", ~failWith=() =>
-      ReventlessCore.Plugin_ResolverError.throwCallerFault(
-        "Expected string | undefined, received null",
-      )
+    let resolver = failingFixture(
+      ~namespace="Fault2",
+      ~failWith=() =>
+        ReventlessCore.Plugin_ResolverError.throwCallerFault(
+          "Expected string | undefined, received null",
+        ),
     )
     let caught = await invoke(resolver)
     expect(
@@ -277,8 +282,9 @@ describe("CommandGeneratorResolvers_GraphQL — a failure the caller may read",
   // The control, and the reason the mark exists: an internal failure is not the
   // caller's business and must keep being masked.
   testPromise("an unmarked failure is left to be masked", async () => {
-    let resolver = failingFixture(~namespace="Fault3", ~failWith=() =>
-      JsError.throwWithMessage("connection to the event store was reset")
+    let resolver = failingFixture(
+      ~namespace="Fault3",
+      ~failWith=() => JsError.throwWithMessage("connection to the event store was reset"),
     )
     let caught = await invoke(resolver)
     expect(caught->Option.flatMap(JsExn.name))->not_->toEqual(Some("GraphQLError"))