@reventlessdev/reventless-local 3.0.0-alpha.161 → 3.0.0-alpha.162

package/tests/adapter/BackendParityTest.res

@@ -57,7 +57,7 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalEventLogStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-events", ~opts)
+      let s = Storage.make(~name="parity-events", ~owner=None, ~opts)
       let ops = await s.operations->TestRunner.resolve
 
       let e1 = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("A"))]))
@@ -81,7 +81,7 @@ 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=(), ~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(
@@ -108,7 +108,7 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-count", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      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.
@@ -143,7 +143,7 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~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))]))
@@ -172,7 +172,7 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()
       module Storage = LocalEventLogStorage.Make(TestBus)
-      let s = Storage.make(~name="parity-conflict", ~opts)
+      let s = Storage.make(~name="parity-conflict", ~owner=None, ~opts)
       let ops = await s.operations->TestRunner.resolve
 
       let e = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("C"))]))

package/tests/adapter/BackendParityTest.res.mjs

@@ -59,7 +59,7 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let Storage = LocalEventLogStorage$ReventlessLocal.Make(TestBus);
-      let s = Storage.make("parity-events", opts);
+      let s = Storage.make("parity-events", undefined, opts);
       let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
       let e1 = Object.fromEntries([[
           "t",
@@ -84,7 +84,7 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
-      let s = Storage.make("parity-qdb", [], undefined, undefined, undefined, undefined, opts);
+      let s = Storage.make("parity-qdb", [], undefined, undefined, undefined, undefined, undefined, opts);
       let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
       await ops.save("k", "val", "Any", undefined);
       let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("k")), param => Effect.succeed([])));
@@ -98,7 +98,7 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
-      let s = Storage.make("parity-count", [], undefined, undefined, undefined, undefined, opts);
+      let s = Storage.make("parity-count", [], undefined, undefined, undefined, undefined, undefined, opts);
       let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
       let r1 = await ops.count("prod-1", "orderCount", 3);
       globalThis.expect(r1).toEqual({
@@ -122,7 +122,7 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
-      let s = Storage.make("parity-ttl", [], undefined, undefined, undefined, undefined, opts);
+      let s = Storage.make("parity-ttl", [], undefined, undefined, undefined, undefined, undefined, opts);
       let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
       let item = k => Object.fromEntries([[
           "id",
@@ -141,7 +141,7 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let Storage = LocalEventLogStorage$ReventlessLocal.Make(TestBus);
-      let s = Storage.make("parity-conflict", opts);
+      let s = Storage.make("parity-conflict", undefined, opts);
       let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
       let e = Object.fromEntries([[
           "t",

package/tests/adapter/CommandTopicChannelTest.res

@@ -72,7 +72,7 @@ describe("LocalCommandTopicChannel", () => {
       TestBus.registerCommandHandler("myCmd", async (json, _) => {
         received := Some(json)
       })
-      let ch = TestChannel.make(~name="myCmd")
+      let ch = TestChannel.make(~name="myCmd", ~owner=None)
       let publishFn = await ch.publishJsons->TestRunner.resolve
       await publishFn([
         {
@@ -96,7 +96,7 @@ describe("LocalCommandTopicChannel", () => {
       TestBus.registerCommandHandler("multiCmd", async (_, _) => {
         count := count.contents + 1
       })
-      let ch = TestChannel.make(~name="multiCmd")
+      let ch = TestChannel.make(~name="multiCmd", ~owner=None)
       let publishFn = await ch.publishJsons->TestRunner.resolve
       await publishFn([
         {
@@ -131,7 +131,7 @@ describe("LocalCommandTopicChannel", () => {
         },
         resources: [],
       }
-      let ch = TestChannel.make(~name="testCmd")
+      let ch = TestChannel.make(~name="testCmd", ~owner=None)
       let _ = ch.connect(
         ~name="testCmd",
         ~channel=ch,
@@ -156,7 +156,7 @@ describe("LocalCommandTopicChannel", () => {
         },
         resources: [],
       }
-      let ch = TestChannel.make(~name="noHandlerCmd")
+      let ch = TestChannel.make(~name="noHandlerCmd", ~owner=None)
       let _ = ch.connect(
         ~name="noHandlerCmd",
         ~channel=ch,

package/tests/adapter/CommandTopicChannelTest.res.mjs

@@ -79,7 +79,7 @@ globalThis.describe("LocalCommandTopicChannel", () => {
       TestBus.registerCommandHandler("myCmd", async (json, param) => {
         received.contents = json;
       });
-      let ch = TestChannel.make("myCmd", undefined);
+      let ch = TestChannel.make("myCmd", undefined, undefined);
       let publishFn = await TestRunner$ReventlessLocal.resolve(ch.publishJsons);
       await publishFn([{
           id: "item-1",
@@ -100,7 +100,7 @@ globalThis.describe("LocalCommandTopicChannel", () => {
       TestBus.registerCommandHandler("multiCmd", async (param, param$1) => {
         count.contents = count.contents + 1 | 0;
       });
-      let ch = TestChannel.make("multiCmd", undefined);
+      let ch = TestChannel.make("multiCmd", undefined, undefined);
       let publishFn = await TestRunner$ReventlessLocal.resolve(ch.publishJsons);
       await publishFn([
         {
@@ -137,7 +137,7 @@ globalThis.describe("LocalCommandTopicChannel", () => {
         parts: runtime_parts,
         resources: runtime_resources
       };
-      let ch = TestChannel.make("testCmd", undefined);
+      let ch = TestChannel.make("testCmd", undefined, undefined);
       ch.connect("testCmd", ch, runtime, [], {});
       await TestBus.dispatchCommand("testCmd", "test-payload");
       globalThis.expect(received.contents).toEqual("test-payload");
@@ -155,7 +155,7 @@ globalThis.describe("LocalCommandTopicChannel", () => {
         parts: runtime_parts,
         resources: runtime_resources
       };
-      let ch = TestChannel.make("noHandlerCmd", undefined);
+      let ch = TestChannel.make("noHandlerCmd", undefined, undefined);
       ch.connect("noHandlerCmd", ch, runtime, [], {});
       TestBus.dispatchCommand("noHandlerCmd", null);
       globalThis.expect(true).toBe(true);

package/tests/adapter/EventCollectorChannelTest.res

@@ -39,13 +39,13 @@ describe("LocalEventCollectorChannel", () => {
       module TestBus = LocalBus.Make()
       module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
       module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let pubA = TestPublisher.make(~name="topicA", ~storageResources=[], ~opts={})
-      let pubB = TestPublisher.make(~name="topicB", ~storageResources=[], ~opts={})
+      let pubA = TestPublisher.make(~name="topicA", ~storageResources=[], ~owner=None, ~opts={})
+      let pubB = TestPublisher.make(~name="topicB", ~storageResources=[], ~owner=None, ~opts={})
       let eventTopics = Dict.fromArray([
         ("topicA", {ReventlessInfra.EventTopic.resources: pubA.resources}),
         ("topicB", {ReventlessInfra.EventTopic.resources: pubB.resources}),
       ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~opts={})
+      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
       // Each publisher returns 1 resource, so 2 total
       expect(ch.resources->Array.length)->toBe(2)
     })
@@ -53,7 +53,7 @@ describe("LocalEventCollectorChannel", () => {
     testPromise("empty eventTopics produces empty resources", async () => {
       module TestBus = LocalBus.Make()
       module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let ch = TestCollector.make(~name="collector", ~eventTopics=Dict.make(), ~opts={})
+      let ch = TestCollector.make(~name="collector", ~eventTopics=Dict.make(), ~owner=None, ~opts={})
       expect(ch.resources->Array.length)->toBe(0)
     })
   })
@@ -67,11 +67,11 @@ describe("LocalEventCollectorChannel", () => {
       let runtime = makeRuntime(async (_, _ctx) => {
         received := received.contents + 1
       })
-      let pub = TestPublisher.make(~name="eventA", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="eventA", ~storageResources=[], ~owner=None, ~opts={})
       let eventTopics = Dict.fromArray([
         ("eventA", {ReventlessInfra.EventTopic.resources: pub.resources}),
       ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~opts={})
+      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
       let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
         channel: ch,
         eventTopics,
@@ -98,13 +98,13 @@ describe("LocalEventCollectorChannel", () => {
       let runtime = makeRuntime(async (_, _) => {
         received := received.contents + 1
       })
-      let pub1 = TestPublisher.make(~name="topicX", ~storageResources=[], ~opts={})
-      let pub2 = TestPublisher.make(~name="topicY", ~storageResources=[], ~opts={})
+      let pub1 = TestPublisher.make(~name="topicX", ~storageResources=[], ~owner=None, ~opts={})
+      let pub2 = TestPublisher.make(~name="topicY", ~storageResources=[], ~owner=None, ~opts={})
       let eventTopics = Dict.fromArray([
         ("topicX", {ReventlessInfra.EventTopic.resources: pub1.resources}),
         ("topicY", {ReventlessInfra.EventTopic.resources: pub2.resources}),
       ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~opts={})
+      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
       let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
         channel: ch,
         eventTopics,
@@ -138,11 +138,11 @@ describe("LocalEventCollectorChannel", () => {
         },
         resources: [],
       }
-      let pub = TestPublisher.make(~name="noHandlerTopic", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="noHandlerTopic", ~storageResources=[], ~owner=None, ~opts={})
       let eventTopics = Dict.fromArray([
         ("noHandlerTopic", {ReventlessInfra.EventTopic.resources: pub.resources}),
       ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~opts={})
+      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
       let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
         channel: ch,
         eventTopics,

package/tests/adapter/EventCollectorChannelTest.res.mjs

@@ -36,8 +36,8 @@ globalThis.describe("LocalEventCollectorChannel", () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let TestPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(TestBus);
       let TestCollector = LocalEventCollectorChannel$ReventlessLocal.Make(TestBus);
-      let pubA = TestPublisher.make("topicA", [], {});
-      let pubB = TestPublisher.make("topicB", [], {});
+      let pubA = TestPublisher.make("topicA", [], undefined, {});
+      let pubB = TestPublisher.make("topicB", [], undefined, {});
       let eventTopics = Object.fromEntries([
         [
           "topicA",
@@ -52,13 +52,13 @@ globalThis.describe("LocalEventCollectorChannel", () => {
           }
         ]
       ]);
-      let ch = TestCollector.make("collector", eventTopics, {});
+      let ch = TestCollector.make("collector", eventTopics, undefined, {});
       globalThis.expect(ch.resources.length).toBe(2);
     });
     globalThis.test("empty eventTopics produces empty resources", async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let TestCollector = LocalEventCollectorChannel$ReventlessLocal.Make(TestBus);
-      let ch = TestCollector.make("collector", {}, {});
+      let ch = TestCollector.make("collector", {}, undefined, {});
       globalThis.expect(ch.resources.length).toBe(0);
     });
   });
@@ -73,14 +73,14 @@ globalThis.describe("LocalEventCollectorChannel", () => {
       let runtime = makeRuntime(async (param, _ctx) => {
         received.contents = received.contents + 1 | 0;
       });
-      let pub = TestPublisher.make("eventA", [], {});
+      let pub = TestPublisher.make("eventA", [], undefined, {});
       let eventTopics = Object.fromEntries([[
           "eventA",
           {
             resources: pub.resources
           }
         ]]);
-      let ch = TestCollector.make("collector", eventTopics, {});
+      let ch = TestCollector.make("collector", eventTopics, undefined, {});
       let channelSpec_resources = [];
       let channelSpec = {
         channel: ch,
@@ -103,8 +103,8 @@ globalThis.describe("LocalEventCollectorChannel", () => {
       let runtime = makeRuntime(async (param, param$1) => {
         received.contents = received.contents + 1 | 0;
       });
-      let pub1 = TestPublisher.make("topicX", [], {});
-      let pub2 = TestPublisher.make("topicY", [], {});
+      let pub1 = TestPublisher.make("topicX", [], undefined, {});
+      let pub2 = TestPublisher.make("topicY", [], undefined, {});
       let eventTopics = Object.fromEntries([
         [
           "topicX",
@@ -119,7 +119,7 @@ globalThis.describe("LocalEventCollectorChannel", () => {
           }
         ]
       ]);
-      let ch = TestCollector.make("collector", eventTopics, {});
+      let ch = TestCollector.make("collector", eventTopics, undefined, {});
       let channelSpec_resources = [];
       let channelSpec = {
         channel: ch,
@@ -147,14 +147,14 @@ globalThis.describe("LocalEventCollectorChannel", () => {
         parts: runtime_parts,
         resources: runtime_resources
       };
-      let pub = TestPublisher.make("noHandlerTopic", [], {});
+      let pub = TestPublisher.make("noHandlerTopic", [], undefined, {});
       let eventTopics = Object.fromEntries([[
           "noHandlerTopic",
           {
             resources: pub.resources
           }
         ]]);
-      let ch = TestCollector.make("collector", eventTopics, {});
+      let ch = TestCollector.make("collector", eventTopics, undefined, {});
       let channelSpec_resources = [];
       let channelSpec = {
         channel: ch,

package/tests/adapter/EventLogSnapshotParityTest.res

@@ -10,7 +10,7 @@ let _ = TestRunner.setup()
 let opts: Pulumi.CustomResourceOptions.t = {}
 
 let makeMemoryOps = () => {
-  let s = EventLogStorage_InMemory.make(~name="parity", ~opts)
+  let s = EventLogStorage_InMemory.make(~name="parity", ~owner=None, ~opts)
   s.operations->TestRunner.resolve
 }
 
@@ -20,7 +20,7 @@ let makeSqliteOps = () => {
     let db = SqliteDriver.openDb(~path=":memory:")
   }
   module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-  let s = Storage.make(~name="parity", ~opts)
+  let s = Storage.make(~name="parity", ~owner=None, ~opts)
   s.operations->TestRunner.resolve
 }
 

package/tests/adapter/EventLogSnapshotParityTest.res.mjs

@@ -13,7 +13,7 @@ TestRunner$ReventlessLocal.setup();
 let opts = {};
 
 function makeMemoryOps() {
-  let s = EventLogStorage_InMemory$ReventlessLocal.make("parity", opts);
+  let s = EventLogStorage_InMemory$ReventlessLocal.make("parity", undefined, opts);
   return TestRunner$ReventlessLocal.resolve(s.operations);
 }
 
@@ -24,7 +24,7 @@ function makeSqliteOps() {
     db: db
   };
   let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-  let s = Storage.make("parity", opts);
+  let s = Storage.make("parity", undefined, opts);
   return TestRunner$ReventlessLocal.resolve(s.operations);
 }
 

package/tests/adapter/EventLogStorageSqliteTest.res

@@ -16,7 +16,7 @@ describe("EventLogStorage_Sqlite", () => {
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
 
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let event1 = JSON.Encode.object(
@@ -45,7 +45,7 @@ describe("EventLogStorage_Sqlite", () => {
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
 
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let e = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("X"))]))
@@ -67,7 +67,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = makeFreshDb()
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
@@ -92,7 +92,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = makeFreshDb()
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
@@ -114,7 +114,7 @@ describe("EventLogStorage_Sqlite", () => {
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
 
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let replayed = await ops.replay("not-there")
@@ -127,7 +127,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = makeFreshDb()
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
@@ -145,7 +145,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = makeFreshDb()
     }
     module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-    let s = Storage.make(~name="agg", ~opts)
+    let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
     let none = await ops.latestSnapshot("id-snap")
@@ -182,7 +182,7 @@ describe("EventLogStorage_Sqlite", () => {
         let db = SqliteDriver.openDb(~path)
       }
       module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-      let s = Storage.make(~name="persist", ~opts)
+      let s = Storage.make(~name="persist", ~owner=None, ~opts)
       let ops = await s.operations->TestRunner.resolve
       let _ = await ops.writeSnapshot(
         "id-sp",
@@ -196,7 +196,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = SqliteDriver.openDb(~path)
     }
     module Storage2 = EventLogStorage_Sqlite.Make(TestBus2, DbProvider2)
-    let s2 = Storage2.make(~name="persist", ~opts)
+    let s2 = Storage2.make(~name="persist", ~owner=None, ~opts)
     let ops2 = await s2.operations->TestRunner.resolve
     let r = await ops2.latestSnapshot("id-sp")
     expect(r)->toEqual(Ok(Some({ReventlessCore.EventLog.seqNr: 3, state, schemaHash: "h"})))
@@ -213,7 +213,7 @@ describe("EventLogStorage_Sqlite", () => {
         let db = SqliteDriver.openDb(~path)
       }
       module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
-      let s = Storage.make(~name="persist", ~opts)
+      let s = Storage.make(~name="persist", ~owner=None, ~opts)
       let ops = await s.operations->TestRunner.resolve
       let ev = JSON.Encode.object(Dict.fromArray([("v", JSON.Encode.int(42))]))
       let _ = await ops.append(0, "id-p", [ev])
@@ -226,7 +226,7 @@ describe("EventLogStorage_Sqlite", () => {
       let db = SqliteDriver.openDb(~path)
     }
     module Storage2 = EventLogStorage_Sqlite.Make(TestBus2, DbProvider2)
-    let s2 = Storage2.make(~name="persist", ~opts)
+    let s2 = Storage2.make(~name="persist", ~owner=None, ~opts)
     let ops2 = await s2.operations->TestRunner.resolve
     let replayed = await ops2.replay("id-p")
     expect(replayed->Array.length)->toBe(1)

package/tests/adapter/EventLogStorageSqliteTest.res.mjs

@@ -24,7 +24,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let event1 = Object.fromEntries([[
         "tag",
@@ -56,7 +56,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let e = Object.fromEntries([[
         "t",
@@ -82,7 +82,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let ev = i => Object.fromEntries([[
         "i",
@@ -123,7 +123,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let ev = i => Object.fromEntries([[
         "i",
@@ -147,7 +147,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let replayed = await ops.replay("not-there");
     globalThis.expect(replayed.length).toBe(0);
@@ -159,7 +159,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let ev = i => Object.fromEntries([[
         "i",
@@ -186,7 +186,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("agg", opts);
+    let s = Storage.make("agg", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let none = await ops.latestSnapshot("id-snap");
     globalThis.expect(none).toEqual({
@@ -246,7 +246,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("persist", opts);
+    let s = Storage.make("persist", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     await ops.writeSnapshot("id-sp", {
       seqNr: 3,
@@ -260,7 +260,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db$1
     };
     let Storage2 = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus2)(DbProvider2);
-    let s2 = Storage2.make("persist", opts);
+    let s2 = Storage2.make("persist", undefined, opts);
     let ops2 = await TestRunner$ReventlessLocal.resolve(s2.operations);
     let r = await ops2.latestSnapshot("id-sp");
     globalThis.expect(r).toEqual({
@@ -281,7 +281,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db
     };
     let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
-    let s = Storage.make("persist", opts);
+    let s = Storage.make("persist", undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let ev = Object.fromEntries([[
         "v",
@@ -295,7 +295,7 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       db: db$1
     };
     let Storage2 = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus2)(DbProvider2);
-    let s2 = Storage2.make("persist", opts);
+    let s2 = Storage2.make("persist", undefined, opts);
     let ops2 = await TestRunner$ReventlessLocal.resolve(s2.operations);
     let replayed = await ops2.replay("id-p");
     globalThis.expect(replayed.length).toBe(1);

package/tests/adapter/EventTopicPublisherTest.res

@@ -20,7 +20,7 @@ describe("LocalEventTopicPublisher", () => {
     testPromise("returns one resource whose name resolves to the topic name", async () => {
       module TestBus = LocalBus.Make()
       module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
-      let pub = TestPublisher.make(~name="MyTopic", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="MyTopic", ~storageResources=[], ~owner=None, ~opts={})
       expect(pub.resources->Array.length)->toBe(1)
       let resource = pub.resources->Array.getUnsafe(0)
       let name = await resource.name->TestRunner.resolve
@@ -36,7 +36,7 @@ describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("TestTopic", async (_, _, json) => {
         received := Some(json)
       })
-      let pub = TestPublisher.make(~name="TestTopic", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="TestTopic", ~storageResources=[], ~owner=None, ~opts={})
       let publishFn = await pub.publishJson->TestRunner.resolve
       await publishFn("svc", testMeta, JSON.Encode.string("hello"))
       expect(received.contents)->toEqual(Some(JSON.Encode.string("hello")))
@@ -53,7 +53,7 @@ describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("topic-b", async (_, _, _) => {
         countB := countB.contents + 1
       })
-      let pub = TestPublisher.make(~name="topic-a", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="topic-a", ~storageResources=[], ~owner=None, ~opts={})
       let publishFn = await pub.publishJson->TestRunner.resolve
       await publishFn("svc", testMeta, JSON.Null)
       expect(countA.contents)->toBe(1)
@@ -67,7 +67,7 @@ describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("svcTopic", async (service, _, _) => {
         receivedService := service
       })
-      let pub = TestPublisher.make(~name="svcTopic", ~storageResources=[], ~opts={})
+      let pub = TestPublisher.make(~name="svcTopic", ~storageResources=[], ~owner=None, ~opts={})
       let publishFn = await pub.publishJson->TestRunner.resolve
       await publishFn("MyService", testMeta, JSON.Null)
       expect(receivedService.contents)->toBe("MyService")

package/tests/adapter/EventTopicPublisherTest.res.mjs

@@ -20,7 +20,7 @@ globalThis.describe("LocalEventTopicPublisher", () => {
     globalThis.test("returns one resource whose name resolves to the topic name", async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});
       let TestPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(TestBus);
-      let pub = TestPublisher.make("MyTopic", [], {});
+      let pub = TestPublisher.make("MyTopic", [], undefined, {});
       globalThis.expect(pub.resources.length).toBe(1);
       let resource = pub.resources[0];
       let name = await TestRunner$ReventlessLocal.resolve(resource.name);
@@ -37,7 +37,7 @@ globalThis.describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("TestTopic", async (param, param$1, json) => {
         received.contents = json;
       });
-      let pub = TestPublisher.make("TestTopic", [], {});
+      let pub = TestPublisher.make("TestTopic", [], undefined, {});
       let publishFn = await TestRunner$ReventlessLocal.resolve(pub.publishJson);
       await publishFn("svc", testMeta, "hello");
       globalThis.expect(received.contents).toEqual("hello");
@@ -57,7 +57,7 @@ globalThis.describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("topic-b", async (param, param$1, param$2) => {
         countB.contents = countB.contents + 1 | 0;
       });
-      let pub = TestPublisher.make("topic-a", [], {});
+      let pub = TestPublisher.make("topic-a", [], undefined, {});
       let publishFn = await TestRunner$ReventlessLocal.resolve(pub.publishJson);
       await publishFn("svc", testMeta, null);
       globalThis.expect(countA.contents).toBe(1);
@@ -72,7 +72,7 @@ globalThis.describe("LocalEventTopicPublisher", () => {
       TestBus.subscribeToEvents("svcTopic", async (service, param, param$1) => {
         receivedService.contents = service;
       });
-      let pub = TestPublisher.make("svcTopic", [], {});
+      let pub = TestPublisher.make("svcTopic", [], undefined, {});
       let publishFn = await TestRunner$ReventlessLocal.resolve(pub.publishJson);
       await publishFn("MyService", testMeta, null);
       globalThis.expect(receivedService.contents).toBe("MyService");

package/tests/adapter/LocalAuthHttpTest.res

@@ -8,7 +8,11 @@ open JestGlobals
 
 let _ = TestRunner.setup()
 
-let port = 4321
+// High port in the dynamic/ephemeral range — deliberately clear of well-known
+// dev-server defaults (Astro 4321, Vite 5173, 3000/4000/8080) so a running dev
+// server doesn't shadow this test's server via EADDRINUSE (the listen success
+// callback never fires on collision, and requests silently hit the other server).
+let port = 49321
 
 // ── Minimal node:http POST helper ──────────────────────────────────────────
 // Jest 27's VM context strips Node's global `fetch` (and undici needs more