@reventlessdev/reventless-core 3.0.0-alpha.191 → 3.0.0-alpha.193

package/tests/plugin/PluginStructureTest.res.mjs

@@ -11,10 +11,13 @@ import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/seman
 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 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 Capability_Inference$ReventlessCore from "../../src/plugin/component/Capability_Inference.res.mjs";
 import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
 
 let Behavior = {
@@ -211,6 +214,36 @@ let PsAttachInvoiceSlice = {
   make: make$6
 };
 
+let Behavior$3 = {
+  initialState: false,
+  evolve: PsChangePhoto$ReventlessCore.evolve,
+  decide: PsChangePhoto$ReventlessCore.decide,
+  moduleUrl: PsChangePhoto$ReventlessCore.moduleUrl
+};
+
+function make$7(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsChangePhotoSlice_Spec = {
+  name: PsChangePhoto$ReventlessCore.name,
+  moduleUrl: PsChangePhoto$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsChangePhoto$ReventlessCore.consumedEventSchema,
+  errorSchema: PsChangePhoto$ReventlessCore.errorSchema,
+  eventSchema: PsChangePhoto$ReventlessCore.eventSchema,
+  commandSchema: PsChangePhoto$ReventlessCore.commandSchema,
+  commandAuthorization: PsChangePhoto$ReventlessCore.commandAuthorization,
+  readConsistency: PsChangePhoto$ReventlessCore.readConsistency
+};
+
+let PsChangePhotoSlice = {
+  Spec: PsChangePhotoSlice_Spec,
+  Behavior: Behavior$3,
+  isAsync: false,
+  make: make$7
+};
+
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
   PsOrdersViewSlice,
   PsAvailableProductsViewSlice,
@@ -719,6 +752,110 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     globalThis.test("a plugin declaring no stores collects none — not None", () => {
       globalThis.expect(structure.requiredStores).toEqual([]);
     });
+    globalThis.test("each requirement keeps its declaring (component, field) sites", () => {
+      let expected = [
+        {
+          store: "TestPlugin.documents",
+          component: "AttachInvoice",
+          field: "documentUrl"
+        },
+        {
+          store: "branding.logos",
+          component: "AttachInvoice",
+          field: "logoUrl"
+        }
+      ];
+      globalThis.expect(withStores.requiredStoreDeclarations).toEqual(expected);
+    });
+    globalThis.describe("capability manifest", () => {
+      let manifest = CapabilityManifest$Reventless.fromStructure(withStores);
+      globalThis.test("keys are byte-identical to requiredStores", () => {
+        globalThis.expect(manifest.capabilities.map(c => c.key)).toEqual(Stdlib_Option.getOr(withStores.requiredStores, []));
+      });
+      globalThis.test("each entry carries its provenance", () => {
+        let entry = Stdlib_Option.getOrThrow(manifest.capabilities.find(c => c.key === "TestPlugin.documents"), undefined);
+        let expected = [{
+            component: "AttachInvoice",
+            field: "documentUrl"
+          }];
+        globalThis.expect(entry.declaredBy).toEqual(expected);
+      });
+      globalThis.test("a structure declaring nothing yields an empty list, not a missing manifest", () => {
+        globalThis.expect(CapabilityManifest$Reventless.fromStructure(structure).capabilities).toEqual([]);
+      });
+      globalThis.test("rendering is deterministic and newline-terminated", () => {
+        let rendered = CapabilityManifest$Reventless.renderForStructure(withStores);
+        globalThis.expect(rendered).toBe(`{
+  "capabilities": [
+    {
+      "kind": "ObjectStore",
+      "key": "TestPlugin.documents",
+      "declaredBy": [
+        {
+          "component": "AttachInvoice",
+          "field": "documentUrl"
+        }
+      ]
+    },
+    {
+      "kind": "ObjectStore",
+      "key": "branding.logos",
+      "declaredBy": [
+        {
+          "component": "AttachInvoice",
+          "field": "logoUrl"
+        }
+      ]
+    }
+  ]
+}
+`);
+      });
+    });
+  });
+  globalThis.describe("capability inference", () => {
+    let commandWarnings = Capability_Inference$ReventlessCore.scanSchema("ChangePhoto", PsChangePhoto$ReventlessCore.commandSchema);
+    let eventWarnings = Capability_Inference$ReventlessCore.scanSchema("ChangePhoto", PsChangePhoto$ReventlessCore.eventSchema);
+    globalThis.test("a heuristic-only match produces a warning", () => {
+      let expected = [{
+          component: "ChangePhoto",
+          field: "photoUrl"
+        }];
+      globalThis.expect(commandWarnings).toEqual(expected);
+    });
+    globalThis.test("a declared field with a heuristic name does not warn", () => {
+      let expected = [{
+          component: "ChangePhoto",
+          field: "photoUrl"
+        }];
+      globalThis.expect(eventWarnings).toEqual(expected);
+    });
+    globalThis.test("a heuristic-only match reaches no manifest entry", () => {
+      let withHeuristicField = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsChangePhotoSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+      globalThis.expect(withHeuristicField.requiredStores).toEqual(["TestPlugin.productPhotos"]);
+      let manifest = CapabilityManifest$Reventless.fromStructure(withHeuristicField);
+      globalThis.expect(manifest.capabilities.every(entry => entry.declaredBy.every(site => site.field !== "photoUrl"))).toBe(true);
+    });
+    globalThis.test("the warning names the field and the settling annotation", () => {
+      let text = Capability_Inference$ReventlessCore.message(commandWarnings[0]);
+      globalThis.expect(text.includes("ChangePhoto.photoUrl")).toBe(true);
+      globalThis.expect(text.includes("@storageRef")).toBe(true);
+    });
+    globalThis.test("suffix and exact name rules match; ordinary names do not", () => {
+      globalThis.expect([
+        "invoiceFileRef",
+        "upload",
+        "thumbnail",
+        "customerName",
+        "documentUrl"
+      ].map(Capability_Inference$ReventlessCore.nameMatches)).toEqual([
+        true,
+        true,
+        true,
+        false,
+        false
+      ]);
+    });
   });
 });
 
@@ -730,6 +867,7 @@ export {
   PsCustomersViewSlice,
   PsAnnotatedViewSlice,
   PsAttachInvoiceSlice,
+  PsChangePhotoSlice,
   structure,
 }
 /* structure Not a pure module */

package/tests/plugin/StateChangeSlice/PsChangePhoto.res

@@ -0,0 +1,33 @@
+// Test fixture spec for heuristic capability inference.
+//
+// `photoUrl` matches the stored-object name heuristic but carries no
+// `@storageRef` — the case that must produce a warning and no manifest entry.
+// `caption` matches nothing, so the scan's silence on it is also exercised.
+
+@@reventless.spec("ChangePhoto")
+
+type state = bool
+let initialState = false
+
+@schema
+type consumedEvent = OrderPlaced
+
+let evolve = (_state, _event) => true
+
+@schema
+type command = ChangePhoto({productId: string, photoUrl: string, caption: string})
+
+@schema
+type error = ProductNotFound
+
+// `thumbnail` matches the same name heuristic but IS declared — the case the
+// lint must stay silent on, because the declaration already provisions it.
+@schema
+type event =
+  | PhotoChanged({
+      productId: string,
+      photoUrl: string,
+      @storageRef("productPhotos") thumbnail: string,
+    })
+
+let decide = (_state, _command): result<array<event>, error> => Ok([])

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

@@ -0,0 +1,64 @@
+// 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 StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+
+let consumedEventSchema = S.literal("OrderPlaced");
+
+function evolve(_state, _event) {
+  return true;
+}
+
+let commandSchema = S.schema(s => ({
+  TAG: "ChangePhoto",
+  productId: s.m(DcbTag$Reventless.string),
+  photoUrl: s.m(S.string),
+  caption: s.m(S.string)
+}));
+
+let errorSchema = S.literal("ProductNotFound");
+
+let eventSchema = S.schema(s => ({
+  TAG: "PhotoChanged",
+  productId: s.m(DcbTag$Reventless.string),
+  photoUrl: s.m(S.string),
+  thumbnail: s.m(StorageRef$Reventless.forStore(undefined, "productPhotos"))
+}));
+
+function decide(_state, _command) {
+  return {
+    TAG: "Ok",
+    _0: []
+  };
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ChangePhoto";
+
+let Id;
+
+let initialState = false;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/plugin/StateChangeSlice/PsChangePhoto.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  initialState,
+  consumedEventSchema,
+  evolve,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  decide,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */