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

package/tests/plugin/PluginStructureTest.res

@@ -79,6 +79,20 @@ module PsAnnotatedViewSlice: ReventlessInfra.StateViewSlice.T = {
   let make = (~dcbEventLog as _, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
 }
 
+module PsAttachInvoiceSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsAttachInvoice
+  module Behavior = {
+    type state = PsAttachInvoice.state
+    let initialState = PsAttachInvoice.initialState
+    let evolve = PsAttachInvoice.evolve
+    let decide = PsAttachInvoice.decide
+    let moduleUrl = PsAttachInvoice.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+
 let structure = Plugin_Structure.make(
   ~name="TestPlugin",
   ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
@@ -261,6 +275,252 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     })
   })
 
+  // What a field *is* comes from `SchemaType`, the IR every other schema
+  // consumer reads, rather than from a `String(_)` match here. These pin the
+  // shapes that separates the two: a date, a reference, a semantic-carrying
+  // string and an optional one all match `String(_)` loosely or not at all, and
+  // each was answered wrong before.
+  describe("labelField — the shape rule", () => {
+    let labelOf = (~entityName="Test", schema) => {
+      let r = Plugin_Structure.labelFieldsFromStateSchema(~entityName, schema->S.castToUnknown)
+      (r.field, r.searchableFields)
+    }
+
+    testSync("a DateTime is not a name — a state whose only string is one falls to id", () => {
+      // The shipped `Orders` case: `placedAt` was added so date views have a
+      // field to key off, and a positional rule let it rename the entity.
+      let schema = S.schema(s =>
+        {
+          "orderId": s.matches(Reventless.Reference.to_("Order")),
+          "placedAt": s.matches(Reventless.DateTime.string),
+          "shippedAt": s.matches(Reventless.DateTime.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("id", []))
+    })
+
+    testSync("a DateTime is skipped, not fatal — a later plain string still wins", () => {
+      let schema = S.schema(s =>
+        {
+          "placedAt": s.matches(Reventless.DateTime.string),
+          "reference": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("reference", ["reference"]))
+    })
+
+    testSync("an optional string is still the entity's name", () => {
+      let schema = S.schema(s =>
+        {
+          "nickname": s.matches(S.option(S.string)),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("nickname", ["nickname"]))
+    })
+
+    testSync("a reference is not a name even when its field is not called `*Id`", () => {
+      let schema = S.schema(s =>
+        {
+          "customer": s.matches(Reventless.Reference.to_("Customer")),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("note", ["note"]))
+    })
+
+    testSync("a DCB-tagged string is not a name", () => {
+      let schema = S.schema(s =>
+        {
+          "partition": s.matches(Reventless.DcbTag.string),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("note", ["note"]))
+    })
+
+    testSync("the `*Id` test is case-insensitive — `productID` is a reference", () => {
+      let schema = S.schema(s =>
+        {
+          "productID": s.matches(S.string),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("note", ["note"]))
+    })
+
+    testSync("a semantic-carrying string is a value, not a name", () => {
+      // `imageUrl` names a stored object. A bucket key read as a product's name
+      // is what the previous rule did whenever no plain string preceded it.
+      let schema = S.schema(s =>
+        {
+          "imageUrl": s.matches(Reventless.StorageRef.forStore(~store="productImages")),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("note", ["note"]))
+    })
+
+    testSync("a state whose only string is a semantic falls to id", () => {
+      let schema = S.schema(s =>
+        {
+          "imageUrl": s.matches(Reventless.StorageRef.forStore(~store="productImages")),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("id", []))
+    })
+
+    testSync("`id` itself is still excluded by name", () => {
+      // `SchemaType` reads a name that short as an ordinary string, so the
+      // exclusion cannot come from the IR.
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("note", ["note"]))
+    })
+  })
+
+  describe("labelField — the conventional-name rung", () => {
+    let labelOf = schema => {
+      let r = Plugin_Structure.labelFieldsFromStateSchema(~entityName="Test", schema->S.castToUnknown)
+      (r.field, r.searchableFields)
+    }
+
+    testSync("a field named `name` beats an earlier string", () => {
+      let schema = S.schema(s =>
+        {
+          "sku": s.matches(S.string),
+          "name": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("name", ["name"]))
+    })
+
+    testSync("`title` counts too, case-insensitively", () => {
+      let schema = S.schema(s =>
+        {
+          "body": s.matches(S.string),
+          "Title": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("Title", ["Title"]))
+    })
+
+    testSync("the match is exact — `customerName` is a customer's name, not this record's", () => {
+      // The shipped `OrdersView` fixture depends on this: it has exactly one
+      // eligible field and must be picked by position, not by convention.
+      let schema = S.schema(s =>
+        {
+          "customerName": s.matches(S.string),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("customerName", ["customerName"]))
+    })
+
+    testSync("an optional `name` still outranks an earlier string", () => {
+      let schema = S.schema(s =>
+        {
+          "sku": s.matches(S.string),
+          "name": s.matches(S.option(S.string)),
+        }
+      )
+      expect(labelOf(schema))->toEqual(("name", ["name"]))
+    })
+  })
+
+  // The rung is published because the four are not equally believable: a
+  // consumer with a name rule of its own has to know whether it is ranking
+  // against a declaration or against a guess.
+  describe("labelFieldSource — which rung answered", () => {
+    let sourceOf = schema =>
+      Plugin_Structure.labelFieldsFromStateSchema(
+        ~entityName="Test",
+        schema->S.castToUnknown,
+      ).source->Plugin_Structure.labelFieldSourceToString
+
+    testSync("a @displayName spec is a declaration", () => {
+      let customers = structure.stateViewSlices->Array.getUnsafe(2)
+      expect((customers.labelField, customers.labelFieldSource))->toEqual((
+        "displayName",
+        Some("annotation"),
+      ))
+    })
+
+    testSync("a field named `name` is a guess the consumer can also make", () => {
+      let schema = S.schema(s =>
+        {
+          "sku": s.matches(S.string),
+          "name": s.matches(S.string),
+        }
+      )
+      expect(sourceOf(schema))->toEqual("convention")
+    })
+
+    testSync("declaration order is a guess only this side can make", () => {
+      // `customerName` is eligible and unconventional, so it wins by position —
+      // and a consumer told only "customerName" could not tell that from a
+      // declaration.
+      let schema = S.schema(s =>
+        {
+          "customerName": s.matches(S.string),
+          "note": s.matches(S.string),
+        }
+      )
+      expect(sourceOf(schema))->toEqual("position")
+    })
+
+    testSync("no candidate at all is the state saying it has no human field", () => {
+      let schema = S.schema(s =>
+        {
+          "orderId": s.matches(Reventless.Reference.to_("Order")),
+          "placedAt": s.matches(Reventless.DateTime.string),
+        }
+      )
+      expect(sourceOf(schema))->toEqual("fallback")
+    })
+
+    testSync("every built def states one", () => {
+      let stated =
+        Array.concat(structure.readModels, structure.stateViewSlices)->Array.every(q =>
+          q.labelFieldSource->Option.isSome
+        )
+      expect(stated)->toEqual(true)
+    })
+  })
+
+  describe("statusField — the shape rule", () => {
+    let statusOf = schema =>
+      Plugin_Structure.statusFieldFromStateSchema(~entityName="Test", schema->S.castToUnknown)
+
+    testSync("a `status` field holding a closed set of values is the lifecycle field", () => {
+      let schema = S.schema(s =>
+        {
+          "status": s.matches(S.union([S.literal("Placed"), S.literal("Shipped")])),
+        }
+      )
+      expect(statusOf(schema))->toEqual(Some("status"))
+    })
+
+    testSync("an optional one counts too", () => {
+      let schema = S.schema(s =>
+        {
+          "status": s.matches(S.option(S.union([S.literal("Placed"), S.literal("Shipped")]))),
+        }
+      )
+      expect(statusOf(schema))->toEqual(Some("status"))
+    })
+
+    testSync("free text named `status` is not a lifecycle", () => {
+      // `allowedStates` filtering needs states to compare against; a string
+      // field named `status` gives a command menu nothing to match.
+      let schema = S.schema(s => {"status": s.matches(S.string)})
+      expect(statusOf(schema))->toEqual(None)
+    })
+  })
+
   // Phase 4: queryableDef.schema must carry x-reventless-* extension keys for
   // annotated state types. Plugin_Structure now uses SuryToJsonSchema.deriveObjectSchema
   // (annotation-aware) instead of S.toJSONSchema (metadata-blind).
@@ -384,4 +644,36 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       expect(placeOrder.chapter)->toEqual(None)
     })
   })
+
+  // A field typed as a storage ref states that the deployment needs that store
+  // to exist. Collecting the requirement onto the structure is what lets the
+  // deploy read it without re-walking every component's schema.
+  describe("requiredStores", () => {
+    let withStores = Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsAttachInvoiceSlice)],
+    )
+    let stores = withStores.requiredStores->Option.getOr([])
+
+    testSync("an unqualified store resolves against the declaring plugin", () =>
+      expect(stores->Array.includes("TestPlugin.documents"))->toBe(true)
+    )
+
+    testSync("a qualified store keeps its own plugin", () =>
+      expect(stores->Array.includes("branding.logos"))->toBe(true)
+    )
+
+    // `documents` is declared on both a command field and an event field.
+    testSync("a store declared by several fields is collected once", () =>
+      expect(stores->Array.filter(s => s == "TestPlugin.documents")->Array.length)->toBe(1)
+    )
+
+    testSync("only the declared stores are collected", () =>
+      expect(stores->Array.length)->toBe(2)
+    )
+
+    testSync("a plugin declaring no stores collects none — not None", () =>
+      expect(structure.requiredStores)->toEqual(Some([]))
+    )
+  })
 })

package/tests/plugin/PluginStructureTest.res.mjs

@@ -1,12 +1,18 @@
 // 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 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 PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
@@ -175,6 +181,36 @@ let PsAnnotatedViewSlice = {
   make: make$5
 };
 
+let Behavior$2 = {
+  initialState: false,
+  evolve: PsAttachInvoice$ReventlessCore.evolve,
+  decide: PsAttachInvoice$ReventlessCore.decide,
+  moduleUrl: PsAttachInvoice$ReventlessCore.moduleUrl
+};
+
+function make$6(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsAttachInvoiceSlice_Spec = {
+  name: PsAttachInvoice$ReventlessCore.name,
+  moduleUrl: PsAttachInvoice$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsAttachInvoice$ReventlessCore.consumedEventSchema,
+  errorSchema: PsAttachInvoice$ReventlessCore.errorSchema,
+  eventSchema: PsAttachInvoice$ReventlessCore.eventSchema,
+  commandSchema: PsAttachInvoice$ReventlessCore.commandSchema,
+  commandAuthorization: PsAttachInvoice$ReventlessCore.commandAuthorization,
+  readConsistency: PsAttachInvoice$ReventlessCore.readConsistency
+};
+
+let PsAttachInvoiceSlice = {
+  Spec: PsAttachInvoiceSlice_Spec,
+  Behavior: Behavior$2,
+  isAsync: false,
+  make: make$6
+};
+
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
   PsOrdersViewSlice,
   PsAvailableProductsViewSlice,
@@ -364,6 +400,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);
@@ -453,6 +701,25 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.expect(placeOrder.chapter).toEqual(undefined);
     });
   });
+  globalThis.describe("requiredStores", () => {
+    let withStores = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsAttachInvoiceSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+    let stores = Stdlib_Option.getOr(withStores.requiredStores, []);
+    globalThis.test("an unqualified store resolves against the declaring plugin", () => {
+      globalThis.expect(stores.includes("TestPlugin.documents")).toBe(true);
+    });
+    globalThis.test("a qualified store keeps its own plugin", () => {
+      globalThis.expect(stores.includes("branding.logos")).toBe(true);
+    });
+    globalThis.test("a store declared by several fields is collected once", () => {
+      globalThis.expect(stores.filter(s => s === "TestPlugin.documents").length).toBe(1);
+    });
+    globalThis.test("only the declared stores are collected", () => {
+      globalThis.expect(stores.length).toBe(2);
+    });
+    globalThis.test("a plugin declaring no stores collects none — not None", () => {
+      globalThis.expect(structure.requiredStores).toEqual([]);
+    });
+  });
 });
 
 export {
@@ -462,6 +729,7 @@ export {
   PsAvailableProductsViewSlice,
   PsCustomersViewSlice,
   PsAnnotatedViewSlice,
+  PsAttachInvoiceSlice,
   structure,
 }
 /* structure Not a pure module */

package/tests/plugin/StateChangeSlice/PsAttachInvoice.res

@@ -0,0 +1,39 @@
+// Test fixture spec for declared-object-store collection.
+//
+// Carries `@storageRef` on a command field, on an event field, and once in the
+// qualified `"<plugin>.<store>"` form — the three shapes Plugin_Structure has to
+// resolve into one qualified identity per store. `documents` is declared twice
+// on purpose so the deduplication is exercised by data rather than asserted in
+// the abstract.
+
+@@reventless.spec("AttachInvoice")
+
+type state = bool
+let initialState = false
+
+@schema
+type consumedEvent = OrderPlaced
+
+let evolve = (_state, _event) => true
+
+// Note the attribute position: `@storageRef(…)` precedes the field NAME. Placed
+// after the colon it attaches to the type expression instead of the field, and
+// the ppx ignores it silently — a declaration that compiles, deploys green, and
+// provisions nothing.
+@schema
+type command =
+  | AttachInvoice({
+      orderId: string,
+      @storageRef("documents") documentUrl: string,
+      // Another plugin's store — qualified, so it must NOT resolve to this
+      // plugin.
+      @storageRef("branding.logos") logoUrl: string,
+    })
+
+@schema
+type error = OrderNotFound
+
+@schema
+type event = InvoiceAttached({orderId: string, @storageRef("documents") documentUrl: string})
+
+let decide = (_state, _command): result<array<event>, error> => Ok([])