@reventlessdev/reventless-local 3.0.0-alpha.300 → 3.0.0-alpha.302

package/tests/capability/{Capability_IdentityProvider_UserStoreTest.res.mjs → Capability_IdentityProvider_AccountStoreTest.res.mjs}

@@ -7,9 +7,9 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as LocalAuth$ReventlessLocal from "../../src/adapter/Auth/LocalAuth.res.mjs";
-import * as UserStore$ReventlessLocal from "../../src/adapter/Auth/UserStore.res.mjs";
 import * as Auth_UserId$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Auth/Auth_UserId.res.mjs";
-import * as Capability_IdentityProvider_UserStore$ReventlessLocal from "../../src/capability/Capability_IdentityProvider_UserStore.res.mjs";
+import * as AccountStore$ReventlessLocal from "../../src/adapter/Auth/AccountStore.res.mjs";
+import * as Capability_IdentityProvider_AccountStore$ReventlessLocal from "../../src/capability/Capability_IdentityProvider_AccountStore.res.mjs";
 
 function email(address) {
   return {
@@ -20,18 +20,18 @@ function email(address) {
 
 function freshFile() {
   let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-identity-"));
-  return Nodepath.join(dir, ".reventless", "users.yaml");
+  return Nodepath.join(dir, ".reventless", "accounts.yaml");
 }
 
 function resetAll() {
   LocalAuth$ReventlessLocal.resetUsers();
   LocalAuth$ReventlessLocal.Login.resetStore();
-  UserStore$ReventlessLocal.resetResolution();
+  AccountStore$ReventlessLocal.resetResolution();
 }
 
 function restartFrom(file) {
   resetAll();
-  let message = UserStore$ReventlessLocal.load(undefined, file, undefined);
+  let message = AccountStore$ReventlessLocal.load(undefined, file, undefined);
   if (message.TAG === "Ok") {
     return;
   } else {
@@ -39,9 +39,9 @@ function restartFrom(file) {
   }
 }
 
-globalThis.describe("Capability_IdentityProvider_UserStore", () => {
+globalThis.describe("Capability_IdentityProvider_AccountStore", () => {
   globalThis.test("publishes all four operations", () => {
-    globalThis.expect(Capability_IdentityProvider_UserStore$ReventlessLocal.make(freshFile(), undefined).operations).toEqual([
+    globalThis.expect(Capability_IdentityProvider_AccountStore$ReventlessLocal.make(freshFile(), undefined).operations).toEqual([
       "CreatePrincipal",
       "AddToGroup",
       "RemoveFromGroup",
@@ -51,7 +51,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   globalThis.test("a created principal can log in now and after a restart", async () => {
     resetAll();
     let file = freshFile();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(file, undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(file, undefined);
     let created = await provider.createPrincipal({
       TAG: "ToEmail",
       _0: "new@example.com"
@@ -75,7 +75,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   });
   globalThis.test("the same contact twice is a Conflict, not a second account", async () => {
     resetAll();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(freshFile(), undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(freshFile(), undefined);
     let create = () => provider.createPrincipal({
       TAG: "ToEmail",
       _0: "twice@example.com"
@@ -88,7 +88,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   });
   globalThis.test("NoCredential writes an account no password opens", async () => {
     resetAll();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(freshFile(), undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(freshFile(), undefined);
     await provider.createPrincipal({
       TAG: "ToEmail",
       _0: "later@example.com"
@@ -97,7 +97,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
     globalThis.expect(Stdlib_Result.isOk(await LocalAuth$ReventlessLocal.Login.issue("later@example.com", "", undefined))).toBe(true);
   });
   globalThis.test("a push address is refused, since nothing signs in with one", async () => {
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(freshFile(), undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(freshFile(), undefined);
     let answer = await provider.createPrincipal({
       TAG: "ToPush",
       _0: {
@@ -117,7 +117,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   globalThis.test("groups round-trip through the file", async () => {
     resetAll();
     let file = freshFile();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(file, undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(file, undefined);
     let principal = {
       providerId: "grp@example.com"
     };
@@ -150,7 +150,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   });
   globalThis.test("grouping a principal that does not exist is refused", async () => {
     resetAll();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(freshFile(), undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(freshFile(), undefined);
     let answer = await provider.addToGroup({
       providerId: "ghost"
     }, "Shopper");
@@ -165,7 +165,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   globalThis.test("deleting removes the account from the file and the login, twice", async () => {
     resetAll();
     let file = freshFile();
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(file, undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(file, undefined);
     let principal = {
       providerId: "gone@example.com"
     };
@@ -198,7 +198,7 @@ globalThis.describe("Capability_IdentityProvider_UserStore", () => {
   password: pw
   groups: [Admin]
 `, "utf8");
-    let provider = Capability_IdentityProvider_UserStore$ReventlessLocal.make(file, undefined);
+    let provider = Capability_IdentityProvider_AccountStore$ReventlessLocal.make(file, undefined);
     await provider.createPrincipal({
       TAG: "ToEmail",
       _0: "c@example.com"

package/tests/capability/LocalCapabilitiesTest.res

@@ -22,14 +22,14 @@ describe("LocalCapabilities.unmetWarning", () => {
     let message = LocalCapabilities.unmetWarning(~declared)->Option.getOr("")
     expect(message->String.includes("Geocoding (GeocodeAddress)"))->toBe(true)
     expect(message->String.includes("Capability_Messaging_Log.make()"))->toBe(true)
-    expect(message->String.includes("Capability_IdentityProvider_UserStore.make()"))->toBe(true)
+    expect(message->String.includes("Capability_IdentityProvider_AccountStore.make()"))->toBe(true)
   })
 
   testSync("a registered provider leaves the warning", () => {
     reset()
     LocalCapabilities.registerMessagingSender("Shop <shop@example.test>")
     LocalCapabilities.registerIdentityProvider(
-      Capability_IdentityProvider_UserStore.make(~path="/nonexistent/users.yaml", ()),
+      Capability_IdentityProvider_AccountStore.make(~path="/nonexistent/accounts.yaml", ()),
     )
     expect(LocalCapabilities.provisioned())->toEqual([
       Reventless.CapabilityNeed.Messaging,

package/tests/capability/LocalCapabilitiesTest.res.mjs

@@ -3,7 +3,7 @@
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as LocalCapabilities$ReventlessLocal from "../../src/adapter/LocalCapabilities.res.mjs";
-import * as Capability_IdentityProvider_UserStore$ReventlessLocal from "../../src/capability/Capability_IdentityProvider_UserStore.res.mjs";
+import * as Capability_IdentityProvider_AccountStore$ReventlessLocal from "../../src/capability/Capability_IdentityProvider_AccountStore.res.mjs";
 
 let declared = [
   [
@@ -32,12 +32,12 @@ globalThis.describe("LocalCapabilities.unmetWarning", () => {
     let message = Stdlib_Option.getOr(LocalCapabilities$ReventlessLocal.unmetWarning(declared), "");
     globalThis.expect(message.includes("Geocoding (GeocodeAddress)")).toBe(true);
     globalThis.expect(message.includes("Capability_Messaging_Log.make()")).toBe(true);
-    globalThis.expect(message.includes("Capability_IdentityProvider_UserStore.make()")).toBe(true);
+    globalThis.expect(message.includes("Capability_IdentityProvider_AccountStore.make()")).toBe(true);
   });
   globalThis.test("a registered provider leaves the warning", () => {
     reset();
     LocalCapabilities$ReventlessLocal.registerMessagingSender("Shop <shop@example.test>");
-    LocalCapabilities$ReventlessLocal.registerIdentityProvider(Capability_IdentityProvider_UserStore$ReventlessLocal.make("/nonexistent/users.yaml", undefined));
+    LocalCapabilities$ReventlessLocal.registerIdentityProvider(Capability_IdentityProvider_AccountStore$ReventlessLocal.make("/nonexistent/accounts.yaml", undefined));
     globalThis.expect(LocalCapabilities$ReventlessLocal.provisioned()).toEqual([
       "Messaging",
       "IdentityProvider",

package/tests/components/dcb/DcbRepeatTest.res

@@ -0,0 +1,291 @@
+// Another plugin's fact arrives through an Extension and a slice, and delivery is
+// at-least-once. The slice here has no check of its own — every RecordDemand
+// appends — so what keeps a redelivered ItemOrdered from counting twice is the
+// framework: the Extension's command carries a stable id, and the handler drops a
+// command the partition already holds events for. On both local backends, and
+// for two concurrent copies.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+module Message = ReventlessCore.Message
+
+// ─── The provider's extension point and the consumer's slice ────────────────
+
+module Port = {
+  let name = "Ordering.Orders"
+
+  @schema
+  type command = Noop
+
+  @schema
+  type event = ItemOrdered({productId: string, orderId: string})
+
+  @schema
+  type directive = NoDirective
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+module DemandSlice = {
+  let name = "RecordDemandNoCheck"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  // The produced event joins a product and an order, so the partition is
+  // declared, as the shop's RecordProductDemand does.
+  @schema
+  type event =
+    DemandRecorded({productId: @s.matches(Reventless.DcbTag.partition) string, orderId: string})
+
+  @schema
+  type consumedEvent =
+    DemandRecorded({productId: @s.matches(Reventless.DcbTag.string) string, orderId: string})
+
+  @schema
+  type command =
+    RecordDemand({productId: @s.matches(Reventless.DcbTag.string) string, orderId: string})
+
+  @schema
+  type error = Never
+
+  type role = Reventless.Role.name
+  let authorizationOf = (_: string): Reventless.Authorization.rule<role> => AllowAuthenticated
+  type lifecycleState = unit
+  let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
+  let traits: array<Reventless.Trait.t> = []
+}
+
+module DemandDecision = {
+  type state = {orders: array<string>}
+  let initialState = {orders: []}
+  let moduleUrl = DemandSlice.moduleUrl
+
+  let evolve = (state, event: DemandSlice.consumedEvent) =>
+    switch event {
+    | DemandRecorded({orderId}) => {orders: state.orders->Array.concat([orderId])}
+    }
+
+  // Deliberately no "already counted" rule.
+  let decide = (_state, command: DemandSlice.command): result<
+    array<DemandSlice.event>,
+    DemandSlice.error,
+  > =>
+    switch command {
+    | RecordDemand({productId, orderId}) => Ok([DemandRecorded({productId, orderId})])
+    }
+}
+
+module DemandHandler = ReventlessCore.StateChangeSlice_Callback.Make(DemandSlice, DemandDecision)
+
+let partitionTag = Reventless.DcbTag.Simple({key: "productId"})
+
+// The consumer's Extension, as the catalog's Orders_Extension is written.
+module DemandExtension = ReventlessInfra.ExtensionMapping.Make({
+  module ExtensionPoint = Port
+  module Delegate = DemandSlice
+  let moduleUrl: string = %raw(`import.meta.url`)
+  let delegateModuleUrl = DemandSlice.moduleUrl
+  let mapIncomingEvent = (_id, event: Port.event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ItemOrdered({productId, orderId}) => [
+        ReventlessInfra.ExtensionMapping.PublishStateChangeSliceCommand(
+          DemandSlice.RecordDemand({productId, orderId}),
+        ),
+      ]
+    }
+  let mapOutgoingEvent = None
+  let handledEvents = []
+  let issuedCommands = []
+})
+
+let queryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+let pluginDefinition: Reventless.Plugin.pluginDefinition = {
+  id: "Catalog@1",
+  name: "Catalog",
+  version: "1",
+  extensionPoints: [],
+  extensions: [{name: "Catalog", extensionPointName: Port.name}],
+  eventCollector: "eventCollector",
+  extensionProtocols: [],
+  apiSchemaFragment: None,
+  structure: None,
+  kind: Domain,
+}
+
+// One published ItemOrdered, as the extension point stored and published it;
+// every delivery of it carries this same envelope.
+let published: Message.event'<string, Port.event> = {
+  id: "order-1",
+  meta: {
+    service: Port.name,
+    time: "2024-01-01T00:00:00Z",
+    msgId: "item-ordered-msg",
+    correlationId: "place-order-cmd",
+    causationId: "order-placed-event",
+  },
+  event: ItemOrdered({productId: "product-1", orderId: "order-1"}),
+}
+
+// What the Extension sends for one delivery of `published`.
+let commandOf = (event': Message.event'<string, Port.event>) =>
+  switch DemandExtension.mapIncomingEvent(event', pluginDefinition, queryEngine) {
+  | [ReventlessInfra.ExtensionMapping.AbstractPublishAggregateCommand(_, cmdJson)] => cmdJson
+  | _ => JsError.throwWithMessage("expected one slice command")
+  }
+
+// ─── Backends ───────────────────────────────────────────────────────────────
+
+let eventLogOn = async (~name) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalDcbEventLogStorage.Make(Bus)
+  let s = Storage.make(~name, ~indexes=[], ~partitionTag, ~opts)
+  let storage = await s.operations->TestRunner.resolve
+  module Log = ReventlessCore.DcbEventLog_Operations.Make({
+    let name = name
+    let serviceName = name
+    let storage = storage
+    let publishJson = async (_, _, _) => ()
+  })
+  let eventLog: ReventlessCore.DcbEventLog.operations = {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream,
+  }
+  eventLog
+}
+
+let runUnderMemory = async fn => {
+  BackendState.setMemory()
+  await fn()
+}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+let deliver = (eventLog, cmd: Message.commandJson) =>
+  DemandHandler.handleCommands(
+    ~partitionTag,
+    eventLog,
+    Stream.fromIterable([
+      {
+        ReventlessInfra.CommandTopic.command: cmd
+        ->ReventlessCore.CommandTopic_Helpers.encodeCommandJson
+        ->Message.decodeCommand'(Reventless.Id.String.schema, DemandSlice.commandSchema),
+        reference: cmd.meta.msgId,
+      },
+    ]),
+  )->Effect.runPromise
+
+let recordedDemands = async (eventLog: ReventlessCore.DcbEventLog.operations) =>
+  (await eventLog.read(~query=[{eventTypes: ["DemandRecorded"]}])).events
+
+let counter = ref(0)
+let fresh = prefix => {
+  counter := counter.contents + 1
+  `${prefix}-${counter.contents->Int.toString}`
+}
+
+let _ = beforeEach(() => DemandHandler.resetCache())
+
+let backends = [("in-memory", runUnderMemory), ("SQLite", runUnderSqlite)]
+
+backends->Array.forEach(((label, runUnder)) =>
+  describe(`a redelivered fact is recorded once (${label} backend)`, () => {
+    testPromise(
+      "the same published event delivered twice appends one event",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatOnce"))
+            let first = await deliver(log, commandOf(published))
+            let again = await deliver(log, commandOf(published))
+            expect(first->Array.length)->toBe(1)
+            expect(again)->toEqual(first) // accepted both times
+            let events = await recordedDemands(log)
+            expect(events->Array.length)->toBe(1)
+            // The command is the stored event's cause, and the published event the command's.
+            let cmd = commandOf(published)
+            expect((events->Array.getUnsafe(0)).meta.causationId)->toEqual(Some(cmd.meta.msgId))
+            expect(cmd.meta.causationId)->toEqual(Some(published.meta.msgId))
+          },
+        ),
+    )
+
+    testPromise(
+      "a different order for the same product still counts",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatOther"))
+            let _ = await deliver(log, commandOf(published))
+            let second: Message.event'<string, Port.event> = {
+              id: "order-2",
+              meta: {...published.meta, msgId: "item-ordered-msg-2"},
+              event: Port.ItemOrdered({productId: "product-1", orderId: "order-2"}),
+            }
+            let _ = await deliver(log, commandOf(second))
+            let _ = await deliver(log, commandOf(published))
+            let _ = await deliver(log, commandOf(second))
+            expect((await recordedDemands(log))->Array.length)->toBe(2)
+          },
+        ),
+    )
+
+    testPromise(
+      "a command with a random id is decided every time",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatRandom"))
+            let cmd = commandOf(published)
+            // The envelope of a command nobody derived: fresh id, no mark.
+            let plain = {...cmd, meta: Message.deriveMeta(~parent=cmd.meta)}
+            let _ = await deliver(log, plain)
+            let _ = await deliver(log, plain)
+            expect((await recordedDemands(log))->Array.length)->toBe(2)
+          },
+        ),
+    )
+
+    testPromise(
+      "two concurrent copies append one event",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatConcurrent"))
+            let cmd = commandOf(published)
+            // Both read an empty partition; the second append conflicts, re-reads,
+            // and finds the first one's event.
+            let (a, b) = await Promise.all2((deliver(log, cmd), deliver(log, cmd)))
+            expect(a->Array.length)->toBe(1)
+            expect(b->Array.length)->toBe(1)
+            expect(a->Array.getUnsafe(0)->Result.isOk && b->Array.getUnsafe(0)->Result.isOk)->toBe(
+              true,
+            )
+            expect((await recordedDemands(log))->Array.length)->toBe(1)
+          },
+        ),
+    )
+  })
+)