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

package/src/ProductDemand/Aggregate/ProductDemand.res.mjs

@@ -0,0 +1,51 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Record",
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Revoke",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Recorded",
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Revoked",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApi(commandSchema);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ProductDemand";
+
+let Id;
+
+let errorSchema = S.unit;
+
+let moduleUrl = "@reventlessdev/online-shop-aggregates-catalog/src/ProductDemand/Aggregate/ProductDemand.res.mjs";
+
+export {
+  name,
+  Id,
+  eventSchema,
+  errorSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+}
+/* commandSchema Not a pure module */

package/src/ProductDemand/Aggregate/ProductDemand_Behavior.res

@@ -0,0 +1,39 @@
+// ProductDemand aggregate behavior.
+// Idempotently records and revokes order demand per product.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Created({recordedOrderIds: array<string>})
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Recorded({orderId})) => Created({recordedOrderIds: [orderId]})
+  | (Created(s), Recorded({orderId})) =>
+    Created({recordedOrderIds: Array.concat(s.recordedOrderIds, [orderId])})
+  | (Created(s), Revoked({orderId})) =>
+    Created({recordedOrderIds: s.recordedOrderIds->Array.filter(id => id !== orderId)})
+  | (NotCreated, Revoked(_)) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Record({orderId})) => Ok([Recorded({orderId: orderId})])
+  | (NotCreated, Revoke(_)) => Ok([]) // nothing recorded yet — idempotent
+  | (Created(s), Record({orderId})) =>
+    if s.recordedOrderIds->Array.includes(orderId) {
+      Ok([]) // idempotent
+    } else {
+      Ok([Recorded({orderId: orderId})])
+    }
+  | (Created(s), Revoke({orderId})) =>
+    if !(s.recordedOrderIds->Array.includes(orderId)) {
+      Ok([]) // idempotent
+    } else {
+      Ok([Revoked({orderId: orderId})])
+    }
+  }

package/src/ProductDemand/Aggregate/ProductDemand_Behavior.res.mjs

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let stateSchema = S.union([
+  S.literal("NotCreated"),
+  S.schema(s => ({
+    TAG: "Created",
+    recordedOrderIds: s.m(S.array(S.string))
+  }))
+]);
+
+function evolve(state, event) {
+  if (typeof state !== "object") {
+    if (event.TAG === "Recorded") {
+      return {
+        TAG: "Created",
+        recordedOrderIds: [event.orderId]
+      };
+    } else {
+      return state;
+    }
+  }
+  if (event.TAG === "Recorded") {
+    return {
+      TAG: "Created",
+      recordedOrderIds: state.recordedOrderIds.concat([event.orderId])
+    };
+  }
+  let orderId = event.orderId;
+  return {
+    TAG: "Created",
+    recordedOrderIds: state.recordedOrderIds.filter(id => id !== orderId)
+  };
+}
+
+function decide(state, command) {
+  if (typeof state !== "object") {
+    if (command.TAG === "Record") {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "Recorded",
+            orderId: command.orderId
+          }]
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  }
+  if (command.TAG === "Record") {
+    let orderId = command.orderId;
+    if (state.recordedOrderIds.includes(orderId)) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "Recorded",
+            orderId: orderId
+          }]
+      };
+    }
+  }
+  let orderId$1 = command.orderId;
+  if (state.recordedOrderIds.includes(orderId$1)) {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Revoked",
+          orderId: orderId$1
+        }]
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+}
+
+let Spec;
+
+let initialState = "NotCreated";
+
+let moduleUrl = "@reventlessdev/online-shop-aggregates-catalog/src/ProductDemand/Aggregate/ProductDemand_Behavior.res.mjs";
+
+export {
+  Spec,
+  stateSchema,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* stateSchema Not a pure module */

package/src/ProductDemand/ReadModel/ProductDemands.res

@@ -0,0 +1,8 @@
+// ProductDemand read model specification.
+// Tracks per-product order demand counts, combining data from Product and ProductDemand aggregates.
+
+@@reventless.spec
+
+@schema
+type state = {name: string, orderCount: int}
+

package/src/ProductDemand/ReadModel/ProductDemands.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  orderCount: s.m(S.int)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "ProductDemands";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/online-shop-aggregates-catalog/src/ProductDemand/ReadModel/ProductDemands.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  stateSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* stateSchema Not a pure module */

package/src/ProductDemand/ReadModel/ProductDemands_Projections.res

@@ -0,0 +1,36 @@
+// ProductDemands projection mappings.
+// Multi-source read model: combines events from two aggregates.
+// Source 1: Product — initialises the entry on Added.
+// Source 2: ProductDemand — increments / decrements the order count.
+@@reventless.mappings
+
+module ProductMapping = Mapping.Make(
+  Product,
+  ProductDemands,
+  {
+    open Product
+    let project = ({event, id, _}) =>
+      switch event {
+      | Added({name}) =>
+        Set(id, {ProductDemands.name: name, orderCount: 0})
+      | _ => Ignore
+      }
+  },
+)
+
+module ProductDemandMapping = Mapping.Make(
+  ProductDemand,
+  ProductDemands,
+  {
+    open ProductDemand
+    let project = ({event, id, _}) =>
+      switch event {
+      | Recorded(_) =>
+        Update(id, (state: ProductDemands.state) => {...state, orderCount: state.orderCount + 1})
+      | Revoked(_) =>
+        Update(id, (state: ProductDemands.state) => {...state, orderCount: max(0, state.orderCount - 1)})
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(ProductMapping), module(ProductDemandMapping)]

package/src/ProductDemand/ReadModel/ProductDemands_Projections.res.mjs

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Product$CatalogPlugin from "../../Product/Aggregate/Product.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as ProductDemand$CatalogPlugin from "../Aggregate/ProductDemand.res.mjs";
+import * as ProductDemands$CatalogPlugin from "./ProductDemands.res.mjs";
+
+let M = Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: ProductDemands$CatalogPlugin.name,
+  stateSchema: ProductDemands$CatalogPlugin.stateSchema,
+  subIdConfig: undefined
+});
+
+function project(param) {
+  let event = param.event;
+  if (event.TAG === "Added") {
+    return {
+      TAG: "Set",
+      _0: param.id,
+      _1: {
+        name: event.name,
+        orderCount: 0
+      }
+    };
+  } else {
+    return "Ignore";
+  }
+}
+
+let ProductMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Product$CatalogPlugin.name,
+  eventSchema: Product$CatalogPlugin.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: ProductDemands$CatalogPlugin.name,
+  stateSchema: ProductDemands$CatalogPlugin.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+function project$1(param) {
+  let id = param.id;
+  if (param.event.TAG === "Recorded") {
+    return {
+      TAG: "Update",
+      _0: id,
+      _1: state => ({
+        name: state.name,
+        orderCount: state.orderCount + 1 | 0
+      })
+    };
+  } else {
+    return {
+      TAG: "Update",
+      _0: id,
+      _1: state => ({
+        name: state.name,
+        orderCount: Primitive_int.max(0, state.orderCount - 1 | 0)
+      })
+    };
+  }
+}
+
+let ProductDemandMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: ProductDemand$CatalogPlugin.name,
+  eventSchema: ProductDemand$CatalogPlugin.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: ProductDemands$CatalogPlugin.name,
+  stateSchema: ProductDemands$CatalogPlugin.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project$1
+});
+
+let mappings = [
+  ProductMapping,
+  ProductDemandMapping
+];
+
+let Target;
+
+let moduleUrl = "@reventlessdev/online-shop-aggregates-catalog/src/ProductDemand/ReadModel/ProductDemands_Projections.res.mjs";
+
+export {
+  Target,
+  M,
+  ProductMapping,
+  ProductDemandMapping,
+  mappings,
+  moduleUrl,
+}
+/* M Not a pure module */

package/src/Task/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/src/Task/ImportProducts.res.mjs

@@ -0,0 +1,58 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Product$CatalogPlugin from "../Product/Aggregate/Product.res.mjs";
+
+function importCallback(eventName, key) {
+  if (!eventName.includes("ObjectCreated")) {
+    return Promise.resolve([]);
+  }
+  console.log("[ImportProducts] Processing file: " + key);
+  let meta_time = Date.now().toString();
+  let meta_ip = "";
+  let meta_user = "system";
+  let meta = {
+    service: "ImportProducts",
+    time: meta_time,
+    ip: meta_ip,
+    user: meta_user,
+    msgId: key,
+    correlationId: key
+  };
+  return Promise.resolve([{
+      TAG: "PublishCommands",
+      _0: "Product",
+      _1: [{
+          id: key,
+          meta: meta,
+          commandJson: Message$Reventless.encode({
+            TAG: "Add",
+            name: "Imported Product",
+            description: "Imported from " + key,
+            price: 9.99
+          }, Product$CatalogPlugin.commandSchema)
+        }]
+    }]);
+}
+
+function setup(_queryEngine, _queryBucketName, _opts) {
+  return {
+    buckets: [{
+        bucketName: "product-imports",
+        bucketMode: "Read",
+        callback: importCallback
+      }]
+  };
+}
+
+let name = "ImportProducts";
+
+let moduleUrl = "@reventlessdev/online-shop-aggregates-catalog/src/Task/ImportProducts.res.mjs";
+
+export {
+  name,
+  importCallback,
+  setup,
+  moduleUrl,
+}
+/* Message-Reventless Not a pure module */

package/src/plugin.json

@@ -0,0 +1 @@
+{"name": "Catalog"}

package/tests/Category/Aggregate/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/tests/Category/Aggregate/Category_GWT.res.mjs

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Category$CatalogPlugin from "../../../src/Category/Aggregate/Category.res.mjs";
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as Category_Behavior$CatalogPlugin from "../../../src/Category/Aggregate/Category_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.MakeFromAggregate({
+  name: Category$CatalogPlugin.name,
+  commandSchema: Category$CatalogPlugin.commandSchema,
+  eventSchema: Category$CatalogPlugin.eventSchema,
+  errorSchema: Category$CatalogPlugin.errorSchema
+})({
+  Spec: {
+    name: Category$CatalogPlugin.name,
+    commandSchema: Category$CatalogPlugin.commandSchema,
+    eventSchema: Category$CatalogPlugin.eventSchema,
+    errorSchema: Category$CatalogPlugin.errorSchema
+  },
+  initialState: Category_Behavior$CatalogPlugin.initialState,
+  evolve: Category_Behavior$CatalogPlugin.evolve,
+  decide: Category_Behavior$CatalogPlugin.decide,
+  moduleUrl: Category_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;
+
+let thenError = include.thenError;
+
+describe("Category Behavior", () => {
+  test("Add on new aggregate produces Added", () => thenEvent(whenCmd(givenEvents([]), {
+    TAG: "Add",
+    name: "Electronics"
+  }), {
+    TAG: "Added",
+    name: "Electronics"
+  }));
+  test("Add on existing aggregate returns CategoryAlreadyExists", () => thenError(whenCmd(givenEvents([{
+      TAG: "Added",
+      name: "Electronics"
+    }]), {
+    TAG: "Add",
+    name: "Electronics 2"
+  }), "CategoryAlreadyExists"));
+  test("Rename on non-existent aggregate returns CategoryNotFound", () => thenError(whenCmd(givenEvents([]), {
+    TAG: "Rename",
+    name: "New Name"
+  }), "CategoryNotFound"));
+  test("Rename on active category produces Renamed", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "Added",
+      name: "Electronics"
+    }]), {
+    TAG: "Rename",
+    name: "Consumer Electronics"
+  }), {
+    TAG: "Renamed",
+    name: "Consumer Electronics"
+  }));
+  test("Rename to same name produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([{
+      TAG: "Added",
+      name: "Electronics"
+    }]), {
+    TAG: "Rename",
+    name: "Electronics"
+  })));
+  test("Rename on archived category returns CategoryAlreadyArchived", () => thenError(whenCmd(givenEvents([
+    {
+      TAG: "Added",
+      name: "Electronics"
+    },
+    "Archived"
+  ]), {
+    TAG: "Rename",
+    name: "New Name"
+  }), "CategoryAlreadyArchived"));
+  test("Archive on active category produces Archived", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "Added",
+      name: "Electronics"
+    }]), "Archive"), "Archived"));
+  test("Archive on archived category produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([
+    {
+      TAG: "Added",
+      name: "Electronics"
+    },
+    "Archived"
+  ]), "Archive")));
+});
+
+let Spec = include.Spec;
+
+let thenCompareEvent = include.thenCompareEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEvents = include.thenEvents;
+
+let thenCompareEvents = include.thenCompareEvents;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+export {
+  Spec,
+  describe,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenCompareEvent,
+  thenNoEvent,
+  thenEventWithError,
+  thenEvents,
+  thenCompareEvents,
+  thenEventsWithError,
+  thenError,
+}
+/* include Not a pure module */

package/tests/Category/ReadModel/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})
+  )
+})