@reventlessdev/reventless-core 3.0.0-alpha.222 → 3.0.0-alpha.224

package/tests/plugin/PluginStructureTest.res.mjs

@@ -5,20 +5,24 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as Api_Naming$ReventlessCore from "../../src/components/Api/Api_Naming.res.mjs";
 import * as PsShipOrder$ReventlessCore from "./StateChangeSlice/PsShipOrder.res.mjs";
 import * as PsOrdersView$ReventlessCore from "./StateViewSlice/PsOrdersView.res.mjs";
 import * as PsPlaceOrder$ReventlessCore from "./StateChangeSlice/PsPlaceOrder.res.mjs";
 import * as PsChangePhoto$ReventlessCore from "./StateChangeSlice/PsChangePhoto.res.mjs";
 import * as CapabilityManifest$Reventless from "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs";
+import * as PsReserveStock$ReventlessCore from "./StateChangeSlice/PsReserveStock.res.mjs";
 import * as PsUploadAvatar$ReventlessCore from "./StateChangeSlice/PsUploadAvatar.res.mjs";
 import * as PsAnnotatedView$ReventlessCore from "./StateViewSlice/PsAnnotatedView.res.mjs";
 import * as PsAttachInvoice$ReventlessCore from "./StateChangeSlice/PsAttachInvoice.res.mjs";
 import * as PsCustomersView$ReventlessCore from "./StateViewSlice/PsCustomersView.res.mjs";
 import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+import * as PsCategoriesView$ReventlessCore from "./StateViewSlice/PsCategoriesView.res.mjs";
 import * as Capability_Inference$ReventlessCore from "../../src/plugin/component/Capability_Inference.res.mjs";
 import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
 
@@ -186,6 +190,32 @@ let PsAnnotatedViewSlice = {
   make: make$5
 };
 
+let Projection$4 = {
+  project: PsCategoriesView$ReventlessCore.project,
+  moduleUrl: PsCategoriesView$ReventlessCore.moduleUrl
+};
+
+function make$6(param, param$1, param$2) {
+  return 0;
+}
+
+let PsCategoriesViewSlice_Spec = {
+  name: PsCategoriesView$ReventlessCore.name,
+  moduleUrl: PsCategoriesView$ReventlessCore.moduleUrl,
+  stateSchema: PsCategoriesView$ReventlessCore.stateSchema,
+  consumedEventSchema: PsCategoriesView$ReventlessCore.consumedEventSchema,
+  config: PsCategoriesView$ReventlessCore.config,
+  subIdConfig: undefined,
+  authorization: PsCategoriesView$ReventlessCore.authorization,
+  visibility: PsCategoriesView$ReventlessCore.visibility
+};
+
+let PsCategoriesViewSlice = {
+  Spec: PsCategoriesViewSlice_Spec,
+  Projection: Projection$4,
+  make: make$6
+};
+
 let Behavior$2 = {
   initialState: false,
   evolve: PsAttachInvoice$ReventlessCore.evolve,
@@ -193,7 +223,7 @@ let Behavior$2 = {
   moduleUrl: PsAttachInvoice$ReventlessCore.moduleUrl
 };
 
-function make$6(param, param$1, param$2, param$3, param$4, param$5) {
+function make$7(param, param$1, param$2, param$3, param$4, param$5) {
   return 0;
 }
 
@@ -213,7 +243,7 @@ let PsAttachInvoiceSlice = {
   Spec: PsAttachInvoiceSlice_Spec,
   Behavior: Behavior$2,
   isAsync: false,
-  make: make$6
+  make: make$7
 };
 
 let Behavior$3 = {
@@ -223,7 +253,7 @@ let Behavior$3 = {
   moduleUrl: PsUploadAvatar$ReventlessCore.moduleUrl
 };
 
-function make$7(param, param$1, param$2, param$3, param$4, param$5) {
+function make$8(param, param$1, param$2, param$3, param$4, param$5) {
   return 0;
 }
 
@@ -243,7 +273,7 @@ let PsUploadAvatarSlice = {
   Spec: PsUploadAvatarSlice_Spec,
   Behavior: Behavior$3,
   isAsync: false,
-  make: make$7
+  make: make$8
 };
 
 let Behavior$4 = {
@@ -253,7 +283,7 @@ let Behavior$4 = {
   moduleUrl: PsChangePhoto$ReventlessCore.moduleUrl
 };
 
-function make$8(param, param$1, param$2, param$3, param$4, param$5) {
+function make$9(param, param$1, param$2, param$3, param$4, param$5) {
   return 0;
 }
 
@@ -273,7 +303,37 @@ let PsChangePhotoSlice = {
   Spec: PsChangePhotoSlice_Spec,
   Behavior: Behavior$4,
   isAsync: false,
-  make: make$8
+  make: make$9
+};
+
+let Behavior$5 = {
+  initialState: false,
+  evolve: PsReserveStock$ReventlessCore.evolve,
+  decide: PsReserveStock$ReventlessCore.decide,
+  moduleUrl: PsReserveStock$ReventlessCore.moduleUrl
+};
+
+function make$10(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsReserveStockSlice_Spec = {
+  name: PsReserveStock$ReventlessCore.name,
+  moduleUrl: PsReserveStock$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsReserveStock$ReventlessCore.consumedEventSchema,
+  errorSchema: PsReserveStock$ReventlessCore.errorSchema,
+  eventSchema: PsReserveStock$ReventlessCore.eventSchema,
+  commandSchema: PsReserveStock$ReventlessCore.commandSchema,
+  commandAuthorization: PsReserveStock$ReventlessCore.commandAuthorization,
+  readConsistency: PsReserveStock$ReventlessCore.readConsistency
+};
+
+let PsReserveStockSlice = {
+  Spec: PsReserveStockSlice_Spec,
+  Behavior: Behavior$5,
+  isAsync: false,
+  make: make$10
 };
 
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
@@ -678,6 +738,54 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.expect(stated).toEqual(true);
     });
   });
+  globalThis.describe("singleQueryField — the singular the schema actually serves", () => {
+    let withIrregularPlural = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [PsCategoriesViewSlice], [], undefined, undefined, undefined, undefined, undefined, undefined);
+    let categories = withIrregularPlural.stateViewSlices[0];
+    globalThis.test("an `-ies` plural publishes the `y` singular, not a truncation", () => {
+      globalThis.expect([
+        categories.queryField,
+        categories.singleQueryField
+      ]).toEqual([
+        "TestPlugin_Categories",
+        "TestPlugin_Category"
+      ]);
+    });
+    globalThis.test("every built def states the name Api_Naming returned", () => {
+      let stated = structure.stateViewSlices.every(q => Primitive_object.equal(q.singleQueryField, Api_Naming$ReventlessCore.queryFieldNamesForStateView("TestPlugin", q.name, undefined).singleFieldName));
+      globalThis.expect(stated).toEqual(true);
+    });
+  });
+  globalThis.describe("idField / idFieldSource — the key and its provenance", () => {
+    let keyOf = q => [
+      q.idField,
+      q.idFieldSource
+    ];
+    let withCategories = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [PsCategoriesViewSlice], [], undefined, undefined, undefined, undefined, undefined, undefined);
+    globalThis.test("a name-matching `*Id` field is a guess the consumer can also make", () => {
+      globalThis.expect(keyOf(structure.stateViewSlices[0])).toEqual([
+        "orderId",
+        "convention"
+      ]);
+    });
+    globalThis.test("a sole `*Id` field is a fact only this side can see", () => {
+      globalThis.expect(keyOf(structure.stateViewSlices[1])).toEqual([
+        "productId",
+        "sole"
+      ]);
+    });
+    globalThis.test("an `-ies` component name singularises to its key", () => {
+      globalThis.expect(keyOf(withCategories.stateViewSlices[0])).toEqual([
+        "categoryId",
+        "convention"
+      ]);
+    });
+    globalThis.test("a declared @id is used where inference would decline", () => {
+      globalThis.expect(keyOf(structure.stateViewSlices[3])).toEqual([
+        "itemId",
+        "annotation"
+      ]);
+    });
+  });
   globalThis.describe("statusField — the shape rule", () => {
     globalThis.test("a `status` field holding a closed set of values is the lifecycle field", () => {
       let schema = S.schema(s => ({
@@ -962,6 +1070,50 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ]);
     });
   });
+  globalThis.describe("plural references reach the manifest", () => {
+    let withPluralRefs = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsReserveStockSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+    let slice = withPluralRefs.stateChangeSlices[0];
+    let referencesOf = refs => refs.map(param => [
+      param.fieldName,
+      param.entity
+    ]);
+    globalThis.test("a command collects its array refs alongside its scalar one", () => {
+      let cmd = slice.commands[0];
+      globalThis.expect(referencesOf(cmd.references)).toEqual([
+        [
+          "customerId",
+          "Customers"
+        ],
+        [
+          "productIds",
+          "AvailableProducts"
+        ],
+        [
+          "warehouseIds",
+          "Warehouses"
+        ]
+      ]);
+    });
+    globalThis.test("an optional array ref is collected under the field's own name", () => {
+      let cmd = slice.commands[0];
+      globalThis.expect(cmd.references.find(param => param.fieldName === "warehouseIds")).toEqual({
+        fieldName: "warehouseIds",
+        entity: "Warehouses",
+        plugin: undefined
+      });
+    });
+    globalThis.test("an event collects its array ref too", () => {
+      let evt = slice.events[0];
+      globalThis.expect(referencesOf(evt.references)).toEqual([[
+          "productIds",
+          "AvailableProducts"
+        ]]);
+    });
+    globalThis.test("the declared entity wins over the one the field name suggests", () => {
+      let cmd = slice.commands[0];
+      globalThis.expect(Stdlib_Option.map(cmd.references.find(param => param.fieldName === "productIds"), param => param.entity)).toEqual("AvailableProducts");
+    });
+  });
 });
 
 export {
@@ -971,9 +1123,11 @@ export {
   PsAvailableProductsViewSlice,
   PsCustomersViewSlice,
   PsAnnotatedViewSlice,
+  PsCategoriesViewSlice,
   PsAttachInvoiceSlice,
   PsUploadAvatarSlice,
   PsChangePhotoSlice,
+  PsReserveStockSlice,
   structure,
 }
 /* structure Not a pure module */

package/tests/plugin/StateChangeSlice/PsReserveStock.res

@@ -0,0 +1,44 @@
+// Test fixture spec where every reference carrier is PLURAL.
+//
+// `Reference.to_` returns an *element* schema, so the ppx annotates the `string`
+// inside `array<string>` and the field's own schema carries no marker. A walk
+// that asks the field directly finds nothing and drops the declaration — and a
+// dropped `@ref` is not the same as an absent one: the consuming side falls back
+// to a naming heuristic and resolves the field to whatever entity the name
+// suggests, so the author's declaration is both ignored and reported as missing.
+//
+// The command declares the scalar and plural forms side by side so a regression
+// shows up as one of the two disappearing rather than as an empty list, and
+// `warehouseIds?` covers the plural-inside-optional shape, where the array sits
+// one wrapper further down still.
+
+@@reventless.spec("ReserveStock")
+
+type state = bool
+let initialState = false
+
+@schema
+type consumedEvent = StockReserved({reservationId: string})
+
+let evolve = (_state, _event) => true
+
+@schema
+type command =
+  | ReserveStock({
+      @partitionTag reservationId: string,
+      @ref("Customers") customerId: string,
+      @ref("AvailableProducts") productIds: array<string>,
+      @ref("Warehouses") warehouseIds?: array<string>,
+    })
+
+@schema
+type error = OutOfStock
+
+@schema
+type event =
+  StockReserved({
+    @partitionTag reservationId: string,
+    @ref("AvailableProducts") productIds: array<string>,
+  })
+
+let decide = (_state, _command): result<array<event>, error> => Ok([])

package/tests/plugin/StateChangeSlice/PsReserveStock.res.mjs

@@ -0,0 +1,67 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "StockReserved",
+  reservationId: s.m(DcbTag$Reventless.string)
+}));
+
+function evolve(_state, _event) {
+  return true;
+}
+
+let commandSchema = S.schema(s => ({
+  TAG: "ReserveStock",
+  reservationId: s.m(DcbTag$Reventless.partition),
+  customerId: s.m(Reference$Reventless.to_(undefined, undefined, "Customers")),
+  productIds: s.m(S.array(Reference$Reventless.to_(undefined, "productId", "AvailableProducts"))),
+  warehouseIds: s.m(S.option(S.array(Reference$Reventless.to_(undefined, "warehouseId", "Warehouses"))))
+}));
+
+let errorSchema = S.literal("OutOfStock");
+
+let eventSchema = S.schema(s => ({
+  TAG: "StockReserved",
+  reservationId: s.m(DcbTag$Reventless.partition),
+  productIds: s.m(S.array(Reference$Reventless.to_(undefined, "productId", "AvailableProducts")))
+}));
+
+function decide(_state, _command) {
+  return {
+    TAG: "Ok",
+    _0: []
+  };
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ReserveStock";
+
+let Id;
+
+let initialState = false;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/plugin/StateChangeSlice/PsReserveStock.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  initialState,
+  consumedEventSchema,
+  evolve,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  decide,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/tests/plugin/StateViewSlice/PsCategoriesView.res

@@ -0,0 +1,17 @@
+// Test fixture for the published singular query field.
+// "Categories" is the name a naive "strip a trailing s" derivation gets wrong
+// (`Categorie`), so it is the one that proves `singleQueryField` comes from
+// `Api_Naming` rather than from a rule re-invented at the consumer.
+
+@@reventless.spec("Categories")
+
+@schema
+type consumedEvent = CategoryAdded({categoryId: string, name: string})
+
+@schema
+type state = {categoryId: string, name: string}
+
+let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
+  switch event {
+  | CategoryAdded({categoryId, name}) => [Set(categoryId, {categoryId, name})]
+  }

package/tests/plugin/StateViewSlice/PsCategoriesView.res.mjs

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let stateSchema = S.schema(s => ({
+  categoryId: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+function project(param) {
+  let event = param.event;
+  let categoryId = event.categoryId;
+  return [{
+      TAG: "Set",
+      _0: categoryId,
+      _1: {
+        categoryId: categoryId,
+        name: event.name
+      }
+    }];
+}
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "Categories";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/plugin/StateViewSlice/PsCategoriesView.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  stateSchema,
+  project,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* consumedEventSchema Not a pure module */