@reventlessdev/online-shop-aggregates-catalog 3.0.0-alpha.101

package/lib/bs/tests/ProductDemand/Aggregate/ProductDemand_GWT.res.mjs

@@ -0,0 +1,114 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as ProductDemand$CatalogPlugin from "../../../src/ProductDemand/Aggregate/ProductDemand.res.mjs";
+import * as ProductDemand_Behavior$CatalogPlugin from "../../../src/ProductDemand/Aggregate/ProductDemand_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.MakeFromAggregate({
+  name: ProductDemand$CatalogPlugin.name,
+  commandSchema: ProductDemand$CatalogPlugin.commandSchema,
+  eventSchema: ProductDemand$CatalogPlugin.eventSchema,
+  errorSchema: ProductDemand$CatalogPlugin.errorSchema
+})({
+  Spec: {
+    name: ProductDemand$CatalogPlugin.name,
+    commandSchema: ProductDemand$CatalogPlugin.commandSchema,
+    eventSchema: ProductDemand$CatalogPlugin.eventSchema,
+    errorSchema: ProductDemand$CatalogPlugin.errorSchema
+  },
+  initialState: ProductDemand_Behavior$CatalogPlugin.initialState,
+  evolve: ProductDemand_Behavior$CatalogPlugin.evolve,
+  decide: ProductDemand_Behavior$CatalogPlugin.decide,
+  moduleUrl: ProductDemand_Behavior$CatalogPlugin.moduleUrl
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenNoEvent = include.thenNoEvent;
+
+describe("ProductDemand Behavior", () => {
+  test("Record on new aggregate produces Recorded", () => thenEvent(whenCmd(givenEvents([]), {
+    TAG: "Record",
+    orderId: "order-1"
+  }), {
+    TAG: "Recorded",
+    orderId: "order-1"
+  }));
+  test("Record with new orderId on existing aggregate produces Recorded", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "Recorded",
+      orderId: "order-1"
+    }]), {
+    TAG: "Record",
+    orderId: "order-2"
+  }), {
+    TAG: "Recorded",
+    orderId: "order-2"
+  }));
+  test("Record with already-recorded orderId produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([{
+      TAG: "Recorded",
+      orderId: "order-1"
+    }]), {
+    TAG: "Record",
+    orderId: "order-1"
+  })));
+  test("Revoke on never-recorded aggregate produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([]), {
+    TAG: "Revoke",
+    orderId: "order-1"
+  })));
+  test("Revoke of unrecorded orderId on existing aggregate produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([{
+      TAG: "Recorded",
+      orderId: "order-1"
+    }]), {
+    TAG: "Revoke",
+    orderId: "order-2"
+  })));
+  test("Revoke of recorded orderId produces Revoked", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "Recorded",
+      orderId: "order-1"
+    }]), {
+    TAG: "Revoke",
+    orderId: "order-1"
+  }), {
+    TAG: "Revoked",
+    orderId: "order-1"
+  }));
+});
+
+let Spec = include.Spec;
+
+let thenCompareEvent = include.thenCompareEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEvents = include.thenEvents;
+
+let thenCompareEvents = include.thenCompareEvents;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenError = include.thenError;
+
+export {
+  Spec,
+  describe,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenCompareEvent,
+  thenNoEvent,
+  thenEventWithError,
+  thenEvents,
+  thenCompareEvents,
+  thenEventsWithError,
+  thenError,
+}
+/* include Not a pure module */

package/lib/bs/tests/ProductDemand/ReadModel/ProductDemands_GWT.res

@@ -0,0 +1,56 @@
+// Multi-source ReadModel: separate `_GWT` instances per source mapping.
+// `MultiSourceProjection_GWT.Make` is single-source; spec-stem uniqueness keeps
+// the file name singular while we instantiate one functor per mapping.
+
+module ProductGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  ProductDemands_Projections.ProductMapping,
+)
+module ProductDemandGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  ProductDemands_Projections.ProductDemandMapping,
+)
+
+ProductGwt.describe("ProductDemands ReadModel ← Product", () => {
+  ProductGwt.test("Added initialises the entry with orderCount = 0", () =>
+    ProductGwt.givenEvents([])
+    ->ProductGwt.whenEvent(Product.Added({name: "Laptop", description: "x", price: 1.0}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("NameUpdated is ignored (handled by Products read model)", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.NameUpdated({name: "Gaming Laptop"}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("DescriptionUpdated is ignored", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.DescriptionUpdated({description: "y"}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("PriceUpdated is ignored", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.PriceUpdated({price: 2.0}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+})
+
+// `MultiSourceProjection_GWT` is single-source: the ProductDemand mapping
+// emits `Update(...)` that needs initial state seeded by the Product
+// mapping's `Set(...)`. Tested in isolation, both Update branches surface
+// a `StaleState` error. We assert the throw to lock in that the mapping
+// never tries to initialise its own row — the integration relies on
+// Product.Added arriving first.
+ProductDemandGwt.describe("ProductDemands ReadModel ← ProductDemand", () => {
+  ProductDemandGwt.test("Recorded without prior Product.Added throws StaleState", () =>
+    ProductDemandGwt.givenEvents([])
+    ->ProductDemandGwt.whenEvent(ProductDemand.Recorded({orderId: "order-1"}))
+    ->ProductDemandGwt.thenThrow
+  )
+
+  ProductDemandGwt.test("Revoked without prior Product.Added throws StaleState", () =>
+    ProductDemandGwt.givenEvents([])
+    ->ProductDemandGwt.whenEvent(ProductDemand.Revoked({orderId: "order-1"}))
+    ->ProductDemandGwt.thenThrow
+  )
+})

package/lib/bs/tests/ProductDemand/ReadModel/ProductDemands_GWT.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as MultiSourceProjection_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/MultiSourceProjection_GWT.res.mjs";
+import * as ProductDemands_Projections$CatalogPlugin from "../../../src/ProductDemand/ReadModel/ProductDemands_Projections.res.mjs";
+
+let ProductGwt = MultiSourceProjection_GWT$ReventlessGwt.Make(ProductDemands_Projections$CatalogPlugin.ProductMapping);
+
+let ProductDemandGwt = MultiSourceProjection_GWT$ReventlessGwt.Make(ProductDemands_Projections$CatalogPlugin.ProductDemandMapping);
+
+ProductGwt.describe("ProductDemands ReadModel ← Product", () => {
+  ProductGwt.test("Added initialises the entry with orderCount = 0", undefined, () => ProductGwt.thenState(ProductGwt.whenEvent(ProductGwt.givenEvents([]), {
+    TAG: "Added",
+    name: "Laptop",
+    description: "x",
+    price: 1.0
+  }), {
+    name: "Laptop",
+    orderCount: 0
+  }));
+  ProductGwt.test("NameUpdated is ignored (handled by Products read model)", undefined, () => ProductGwt.thenState(ProductGwt.whenEvent(ProductGwt.givenEvents([{
+      TAG: "Added",
+      name: "Laptop",
+      description: "x",
+      price: 1.0
+    }]), {
+    TAG: "NameUpdated",
+    name: "Gaming Laptop"
+  }), {
+    name: "Laptop",
+    orderCount: 0
+  }));
+  ProductGwt.test("DescriptionUpdated is ignored", undefined, () => ProductGwt.thenState(ProductGwt.whenEvent(ProductGwt.givenEvents([{
+      TAG: "Added",
+      name: "Laptop",
+      description: "x",
+      price: 1.0
+    }]), {
+    TAG: "DescriptionUpdated",
+    description: "y"
+  }), {
+    name: "Laptop",
+    orderCount: 0
+  }));
+  ProductGwt.test("PriceUpdated is ignored", undefined, () => ProductGwt.thenState(ProductGwt.whenEvent(ProductGwt.givenEvents([{
+      TAG: "Added",
+      name: "Laptop",
+      description: "x",
+      price: 1.0
+    }]), {
+    TAG: "PriceUpdated",
+    price: 2.0
+  }), {
+    name: "Laptop",
+    orderCount: 0
+  }));
+});
+
+ProductDemandGwt.describe("ProductDemands ReadModel ← ProductDemand", () => {
+  ProductDemandGwt.test("Recorded without prior Product.Added throws StaleState", undefined, () => ProductDemandGwt.thenThrow(ProductDemandGwt.whenEvent(ProductDemandGwt.givenEvents([]), {
+    TAG: "Recorded",
+    orderId: "order-1"
+  })));
+  ProductDemandGwt.test("Revoked without prior Product.Added throws StaleState", undefined, () => ProductDemandGwt.thenThrow(ProductDemandGwt.whenEvent(ProductDemandGwt.givenEvents([]), {
+    TAG: "Revoked",
+    orderId: "order-1"
+  })));
+});
+
+export {
+  ProductGwt,
+  ProductDemandGwt,
+}
+/* ProductGwt Not a pure module */

package/lib/ocaml/.compiler.log

@@ -0,0 +1,2 @@
+#Start(1782549919688)
+#Done(1782549921003)

package/lib/ocaml/CatalogPlugin.mlmap

@@ -0,0 +1,25 @@
+randjbuildsystem
+Categories
+Categories_GWT
+Categories_Projections
+Category
+Category_Behavior
+Category_GWT
+ImportProducts
+Orders_Extension
+Orders_Extension_GWT
+Plugin
+Product
+ProductDemand
+ProductDemand_Behavior
+ProductDemand_GWT
+ProductDemands
+ProductDemands_GWT
+ProductDemands_Projections
+Product_Behavior
+Product_GWT
+Products
+Products_ExtensionPointMapping
+Products_ExtensionPointMapping_GWT
+Products_GWT
+Products_Projections

package/lib/ocaml/Categories.res

@@ -0,0 +1,11 @@
+// Categories read model specification.
+// Query-side state for product categories.
+
+@@reventless.spec
+
+@schema
+type state = {
+  name: string,
+  archived: bool,
+}
+

package/lib/ocaml/Categories_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt(Categories_Projections.CategoryMapping)
+
+describe("Categories ReadModel ← Category", () => {
+  test("Added sets initial read model state", () =>
+    givenEvents([])
+    ->whenEvent(Category.Added({name: "Electronics"}))
+    ->thenState({Categories.name: "Electronics", archived: false})
+  )
+
+  test("Renamed updates the name", () =>
+    givenEvents([Category.Added({name: "Electronics"})])
+    ->whenEvent(Category.Renamed({name: "Consumer Electronics"}))
+    ->thenState({Categories.name: "Consumer Electronics", archived: false})
+  )
+
+  test("Archived sets archived flag", () =>
+    givenEvents([Category.Added({name: "Electronics"})])
+    ->whenEvent(Category.Archived)
+    ->thenState({Categories.name: "Electronics", archived: true})
+  )
+})

package/lib/ocaml/Categories_Projections.res

@@ -0,0 +1,19 @@
+// Category projection mappings.
+// Maps Category aggregate events to Categories read model state changes.
+@@reventless.mappings
+
+module CategoryMapping = Mapping.Make(
+  Category,
+  Categories,
+  {
+    open Category
+    let project = ({event, id, _}) =>
+      switch event {
+      | Added({name}) => Set(id, {Categories.name, archived: false})
+      | Renamed({name}) => Update(id, state => {...state, name})
+      | Archived => Update(id, state => {...state, archived: true})
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(CategoryMapping)]

package/lib/ocaml/Category.res

@@ -0,0 +1,22 @@
+// Category aggregate specification.
+// A named grouping of products (e.g. "Books", "Electronics").
+
+@@reventless.spec
+
+@schema
+type command =
+  | Add({name: string})
+  | Rename({name: string})
+  | @authorize(AllowGroups(["Admin"])) Archive
+
+@schema
+type event =
+  | Added({name: string})
+  | Renamed({name: string})
+  | Archived
+
+@schema
+type error =
+  | CategoryAlreadyExists
+  | CategoryNotFound
+  | CategoryAlreadyArchived

package/lib/ocaml/Category_Behavior.res

@@ -0,0 +1,36 @@
+// Category aggregate behavior.
+// Implements the state machine for adding, renaming, and archiving categories.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Active({name: string})
+  | Archived
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Added({name})) => Active({name: name})
+  | (Active(_), Added({name})) => Active({name: name})
+  | (Active(_), Renamed({name})) => Active({name: name})
+  | (Active(_), Category.Archived) => Archived
+  | (Archived, _) => state
+  | (NotCreated, _) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Add({name})) => Ok([Added({name: name})])
+  | (NotCreated, Rename(_)) => Error(CategoryNotFound)
+  | (NotCreated, Archive) => Error(CategoryNotFound)
+  | (Active(_), Add(_)) => Error(CategoryAlreadyExists)
+  | (Active(s), Rename({name})) if name == s.name => Ok([])
+  | (Active(_), Rename({name})) => Ok([Renamed({name: name})])
+  | (Active(_), Archive) => Ok([Category.Archived])
+  | (Archived, Add(_)) => Error(CategoryAlreadyArchived)
+  | (Archived, Rename(_)) => Error(CategoryAlreadyArchived)
+  | (Archived, Archive) => Ok([]) // idempotent
+  }

package/lib/ocaml/Category_GWT.res

@@ -0,0 +1,51 @@
+@@reventless.gwt
+
+describe("Category Behavior", () => {
+  test("Add on new aggregate produces Added", () =>
+    givenEvents([])
+    ->whenCmd(Add({name: "Electronics"}))
+    ->thenEvent(Added({name: "Electronics"}))
+  )
+
+  test("Add on existing aggregate returns CategoryAlreadyExists", () =>
+    givenEvents([Added({name: "Electronics"})])
+    ->whenCmd(Add({name: "Electronics 2"}))
+    ->thenError(CategoryAlreadyExists)
+  )
+
+  test("Rename on non-existent aggregate returns CategoryNotFound", () =>
+    givenEvents([])
+    ->whenCmd(Rename({name: "New Name"}))
+    ->thenError(CategoryNotFound)
+  )
+
+  test("Rename on active category produces Renamed", () =>
+    givenEvents([Added({name: "Electronics"})])
+    ->whenCmd(Rename({name: "Consumer Electronics"}))
+    ->thenEvent(Renamed({name: "Consumer Electronics"}))
+  )
+
+  test("Rename to same name produces no events (idempotent)", () =>
+    givenEvents([Added({name: "Electronics"})])
+    ->whenCmd(Rename({name: "Electronics"}))
+    ->thenNoEvent
+  )
+
+  test("Rename on archived category returns CategoryAlreadyArchived", () =>
+    givenEvents([Added({name: "Electronics"}), Archived])
+    ->whenCmd(Rename({name: "New Name"}))
+    ->thenError(CategoryAlreadyArchived)
+  )
+
+  test("Archive on active category produces Archived", () =>
+    givenEvents([Added({name: "Electronics"})])
+    ->whenCmd(Archive)
+    ->thenEvent(Archived)
+  )
+
+  test("Archive on archived category produces no events (idempotent)", () =>
+    givenEvents([Added({name: "Electronics"}), Archived])
+    ->whenCmd(Archive)
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/ImportProducts.res

@@ -0,0 +1,48 @@
+// Import products from a CSV file uploaded to S3.
+// Each row is translated to a Product.Add command.
+
+@@reventless.task
+
+let importCallback = (~eventName, ~key) => {
+  if eventName->String.includes("ObjectCreated") {
+    Console.log("[ImportProducts] Processing file: " ++ key)
+
+    let meta: Message.meta = {
+      service: "ImportProducts",
+      time: Date.now()->Float.toString,
+      ip: "",
+      user: "system",
+      msgId: key,
+      correlationId: key,
+    }
+
+    [
+      Task.PublishCommands(
+        "Product",
+        [
+          {
+            id: key,
+            meta,
+            commandJson: Product.Add({
+              name: "Imported Product",
+              description: "Imported from " ++ key,
+              price: 9.99,
+            })->Message.encode(Product.commandSchema),
+          },
+        ],
+      ),
+    ]->Promise.resolve
+  } else {
+    []->Promise.resolve
+  }
+}
+
+let setup = (_queryEngine, _queryBucketName, _opts) => {
+  Task.buckets: [
+    {
+      bucketName: "product-imports",
+      bucketMode: Task.Read,
+      callback: importCallback,
+    },
+  ],
+}

package/lib/ocaml/Orders_Extension.res

@@ -0,0 +1,23 @@
+// Catalog's extension subscribing to Ordering's OrdersExtensionPoint.
+// Routes ItemOrdered / ItemOrderCancelled events to ProductDemand commands.
+
+@@reventless.extension
+
+module Mapping = {
+  module ExtensionPoint = OrderingSpec.Orders_ExtensionPoint
+  module Delegate = ProductDemand
+
+  open ExtensionPoint
+  open Delegate
+  let mapIncomingEvent = (_id, event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ItemOrdered({productId, orderId}) => [
+        PublishAggregateCommand(productId, Record({orderId: orderId})),
+      ]
+    | ItemOrderCancelled({productId, orderId}) => [
+        PublishAggregateCommand(productId, Revoke({orderId: orderId})),
+      ]
+    }
+
+  let mapOutgoingEvent = None
+}

package/lib/ocaml/Orders_Extension_GWT.res

@@ -0,0 +1,21 @@
+// Boundary GWT for Catalog's Orders extension: public Ordering events become
+// ProductDemand commands on Catalog's aggregate.
+@@reventless.gwt
+
+// `Mapping` is brought into scope by the PPX `open Orders_Extension`; opening
+// it surfaces the extension point's events and the delegate's commands.
+open Mapping
+
+describe("Orders Extension delegate", () => {
+  test("ItemOrdered records demand for the product", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ItemOrdered({productId: "p1", orderId: "o1", customerId: "c1"}),
+    )->thenPublishesAggregateCommand("p1", Delegate.Record({orderId: "o1"}))
+  )
+
+  test("ItemOrderCancelled revokes demand for the product", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ItemOrderCancelled({productId: "p1", orderId: "o1"}),
+    )->thenPublishesAggregateCommand("p1", Delegate.Revoke({orderId: "o1"}))
+  )
+})