@reventlessdev/reventless-core 3.0.0-alpha.190 → 3.0.0-alpha.192

package/tests/plugin/PluginStructureTest.res.mjs

@@ -1,15 +1,23 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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 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 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 = {
@@ -206,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,
@@ -395,6 +433,218 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ]);
     });
   });
+  globalThis.describe("labelField — the shape rule", () => {
+    let labelOf = (entityNameOpt, schema) => {
+      let entityName = entityNameOpt !== undefined ? entityNameOpt : "Test";
+      let r = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, schema);
+      return [
+        r.field,
+        r.searchableFields
+      ];
+    };
+    globalThis.test("a DateTime is not a name — a state whose only string is one falls to id", () => {
+      let schema = S.schema(s => ({
+        orderId: s.m(Reference$Reventless.to_(undefined, undefined, "Order")),
+        placedAt: s.m(DateTime$Reventless.string),
+        shippedAt: s.m(DateTime$Reventless.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "id",
+        []
+      ]);
+    });
+    globalThis.test("a DateTime is skipped, not fatal — a later plain string still wins", () => {
+      let schema = S.schema(s => ({
+        placedAt: s.m(DateTime$Reventless.string),
+        reference: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "reference",
+        ["reference"]
+      ]);
+    });
+    globalThis.test("an optional string is still the entity's name", () => {
+      let schema = S.schema(s => ({
+        nickname: s.m(S.option(S.string))
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "nickname",
+        ["nickname"]
+      ]);
+    });
+    globalThis.test("a reference is not a name even when its field is not called `*Id`", () => {
+      let schema = S.schema(s => ({
+        customer: s.m(Reference$Reventless.to_(undefined, undefined, "Customer")),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "note",
+        ["note"]
+      ]);
+    });
+    globalThis.test("a DCB-tagged string is not a name", () => {
+      let schema = S.schema(s => ({
+        partition: s.m(DcbTag$Reventless.string),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "note",
+        ["note"]
+      ]);
+    });
+    globalThis.test("the `*Id` test is case-insensitive — `productID` is a reference", () => {
+      let schema = S.schema(s => ({
+        productID: s.m(S.string),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "note",
+        ["note"]
+      ]);
+    });
+    globalThis.test("a semantic-carrying string is a value, not a name", () => {
+      let schema = S.schema(s => ({
+        imageUrl: s.m(StorageRef$Reventless.forStore(undefined, "productImages")),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "note",
+        ["note"]
+      ]);
+    });
+    globalThis.test("a state whose only string is a semantic falls to id", () => {
+      let schema = S.schema(s => ({
+        imageUrl: s.m(StorageRef$Reventless.forStore(undefined, "productImages"))
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "id",
+        []
+      ]);
+    });
+    globalThis.test("`id` itself is still excluded by name", () => {
+      let schema = S.schema(s => ({
+        id: s.m(S.string),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(undefined, schema)).toEqual([
+        "note",
+        ["note"]
+      ]);
+    });
+  });
+  globalThis.describe("labelField — the conventional-name rung", () => {
+    let labelOf = schema => {
+      let r = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema("Test", schema);
+      return [
+        r.field,
+        r.searchableFields
+      ];
+    };
+    globalThis.test("a field named `name` beats an earlier string", () => {
+      let schema = S.schema(s => ({
+        sku: s.m(S.string),
+        name: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(schema)).toEqual([
+        "name",
+        ["name"]
+      ]);
+    });
+    globalThis.test("`title` counts too, case-insensitively", () => {
+      let schema = S.schema(s => ({
+        body: s.m(S.string),
+        Title: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(schema)).toEqual([
+        "Title",
+        ["Title"]
+      ]);
+    });
+    globalThis.test("the match is exact — `customerName` is a customer's name, not this record's", () => {
+      let schema = S.schema(s => ({
+        customerName: s.m(S.string),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(labelOf(schema)).toEqual([
+        "customerName",
+        ["customerName"]
+      ]);
+    });
+    globalThis.test("an optional `name` still outranks an earlier string", () => {
+      let schema = S.schema(s => ({
+        sku: s.m(S.string),
+        name: s.m(S.option(S.string))
+      }));
+      globalThis.expect(labelOf(schema)).toEqual([
+        "name",
+        ["name"]
+      ]);
+    });
+  });
+  globalThis.describe("labelFieldSource — which rung answered", () => {
+    let sourceOf = schema => Plugin_Structure$ReventlessCore.labelFieldSourceToString(Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema("Test", schema).source);
+    globalThis.test("a @displayName spec is a declaration", () => {
+      let customers = structure.stateViewSlices[2];
+      globalThis.expect([
+        customers.labelField,
+        customers.labelFieldSource
+      ]).toEqual([
+        "displayName",
+        "annotation"
+      ]);
+    });
+    globalThis.test("a field named `name` is a guess the consumer can also make", () => {
+      let schema = S.schema(s => ({
+        sku: s.m(S.string),
+        name: s.m(S.string)
+      }));
+      globalThis.expect(sourceOf(schema)).toEqual("convention");
+    });
+    globalThis.test("declaration order is a guess only this side can make", () => {
+      let schema = S.schema(s => ({
+        customerName: s.m(S.string),
+        note: s.m(S.string)
+      }));
+      globalThis.expect(sourceOf(schema)).toEqual("position");
+    });
+    globalThis.test("no candidate at all is the state saying it has no human field", () => {
+      let schema = S.schema(s => ({
+        orderId: s.m(Reference$Reventless.to_(undefined, undefined, "Order")),
+        placedAt: s.m(DateTime$Reventless.string)
+      }));
+      globalThis.expect(sourceOf(schema)).toEqual("fallback");
+    });
+    globalThis.test("every built def states one", () => {
+      let stated = structure.readModels.concat(structure.stateViewSlices).every(q => Stdlib_Option.isSome(q.labelFieldSource));
+      globalThis.expect(stated).toEqual(true);
+    });
+  });
+  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 => ({
+        status: s.m(S.union([
+          S.literal("Placed"),
+          S.literal("Shipped")
+        ]))
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual("status");
+    });
+    globalThis.test("an optional one counts too", () => {
+      let schema = S.schema(s => ({
+        status: s.m(S.option(S.union([
+          S.literal("Placed"),
+          S.literal("Shipped")
+        ])))
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual("status");
+    });
+    globalThis.test("free text named `status` is not a lifecycle", () => {
+      let schema = S.schema(s => ({
+        status: s.m(S.string)
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual(undefined);
+    });
+  });
   globalThis.describe("queryableDef.schema propagates x-reventless-* annotations", () => {
     let getProperty = (json, key) => {
       let obj = Stdlib_JSON.Decode.object(json);
@@ -502,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
+      ]);
+    });
   });
 });
 
@@ -513,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 */