@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/plugin/ManifestVisibilityTest.res

@@ -0,0 +1,137 @@
+// Verifies that ReadModel.Spec.visibility flows through PPX injection, that the
+// filter predicate used by Plugin_Builder.makeAutoUIManifest excludes Internal
+// entries while leaving Public ones intact, and that Plugin_Structure.make
+// CARRIES Internal entries but tags them via `queryableDef.visibility` (the
+// dev-graph contract). Does NOT instantiate the full Plugin_Builder.Make functor
+// — the filter is a pure switch on a Spec field and is therefore testable in
+// isolation via stubbed ReadModel.T modules.
+
+open JestGlobals
+
+// Public ReadModel — no @@reventless.visibility attribute, PPX defaults to Public.
+module PublicSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "PublicView"
+  let moduleUrl = ""
+
+  @schema
+  type state = {id: string, name: string}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+  // PPX walk_inline_specs injects authorization = AllowAuthenticated
+  //                                visibility    = Public
+}
+
+// Internal ReadModel — manually setting visibility = Internal here mirrors what
+// @@reventless.visibility(Internal) injects in a real spec file.
+module InternalSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "InternalView"
+  let moduleUrl = ""
+
+  @schema
+  type state = {id: string, name: string}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+  let visibility: Reventless.Visibility.t = Internal
+}
+
+module PublicReadModel: ReventlessInfra.ReadModel.T
+  with type api = unit and type role = unit = {
+  module Spec = PublicSpec
+  type api = unit
+  type role = unit
+  type component
+  let sourceNames: array<string> = []
+  let make = (~api as _, ~apiRole as _, ~allEventTopics as _, ~opts as _=?): component =>
+    Obj.magic(0)
+  let outputs = (_: component): ReventlessInfra.ReadModel.outputs => Obj.magic(0)
+  let operations = (_: component): Pulumi.Output.t<ReventlessInfra.ReadModel.operations> =>
+    Obj.magic(0)
+  let finish = () => ()
+}
+
+module InternalReadModel: ReventlessInfra.ReadModel.T
+  with type api = unit and type role = unit = {
+  module Spec = InternalSpec
+  type api = unit
+  type role = unit
+  type component
+  let sourceNames: array<string> = []
+  let make = (~api as _, ~apiRole as _, ~allEventTopics as _, ~opts as _=?): component =>
+    Obj.magic(0)
+  let outputs = (_: component): ReventlessInfra.ReadModel.outputs => Obj.magic(0)
+  let operations = (_: component): Pulumi.Output.t<ReventlessInfra.ReadModel.operations> =>
+    Obj.magic(0)
+  let finish = () => ()
+}
+
+let isVisible = (
+  module(R: ReventlessInfra.ReadModel.T with type api = unit and type role = unit),
+): bool =>
+  switch R.Spec.visibility {
+  | Public => true
+  | Internal => false
+  }
+
+let readModels: array<
+  module(ReventlessInfra.ReadModel.T with type api = unit and type role = unit),
+> = [module(PublicReadModel), module(InternalReadModel)]
+
+describe("ReadModel visibility filter", () => {
+  testSync("PPX defaults visibility to Public when no attribute is present", () => {
+    expect(PublicSpec.visibility)->toEqual(Reventless.Visibility.Public)
+  })
+
+  testSync("Internal spec retains Internal value", () => {
+    expect(InternalSpec.visibility)->toEqual(Reventless.Visibility.Internal)
+  })
+
+  testSync("filter predicate excludes Internal", () => {
+    let visible = readModels->Array.filter(isVisible)
+    expect(visible->Array.length)->toBe(1)
+  })
+
+  testSync("filter predicate retains Public name", () => {
+    let visible = readModels->Array.filter(isVisible)
+    let first = visible->Array.getUnsafe(0)
+    let module(R) = first
+    expect(R.Spec.name)->toEqual("PublicView")
+  })
+
+  testSync("unfiltered list still contains both entries (no over-filtering)", () => {
+    expect(readModels->Array.length)->toBe(2)
+  })
+})
+
+describe("Plugin_Structure.make — visibility tagging", () => {
+  // pluginStructure CARRIES Internal read models (so the dev graph / dead-code
+  // tools can see them) and tags each via `queryableDef.visibility`
+  // (`None` = Public, `Some("Internal")` = Internal). The deployed AutoUI
+  // consumers re-filter on that tag — visibility does not remove entries from
+  // pluginStructure itself. See Plugin_Structure.res / Visibility.res.
+  let structure = Plugin_Structure.make(~name="VisibilityPlugin", ~readModels)
+
+  testSync("readModels carries both Public and Internal entries", () => {
+    expect(structure.readModels->Array.length)->toBe(2)
+  })
+
+  testSync("the Public entry is tagged visibility = None", () => {
+    let public = structure.readModels->Array.find(d => d.name == "PublicView")
+    expect(public->Option.map(d => d.visibility))->toEqual(Some(None))
+  })
+
+  testSync("the Internal entry is carried and tagged visibility = Some(\"Internal\")", () => {
+    let internal = structure.readModels->Array.find(d => d.name == "InternalView")
+    expect(internal->Option.map(d => d.visibility))->toEqual(Some(Some("Internal")))
+  })
+
+  testSync("aggregates / stateViewSlices stay empty when none are passed (sanity)", () => {
+    expect((
+      structure.aggregates->Array.length,
+      structure.stateViewSlices->Array.length,
+    ))->toEqual((0, 0))
+  })
+})

package/tests/plugin/ManifestVisibilityTest.res.mjs

@@ -0,0 +1,205 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+
+let name = "PublicView";
+
+let moduleUrl = "";
+
+let stateSchema = S.schema(s => ({
+  id: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let PublicSpec = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let name$1 = "InternalView";
+
+let moduleUrl$1 = "";
+
+let stateSchema$1 = S.schema(s => ({
+  id: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let InternalSpec = {
+  Id: undefined,
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  visibility: "Internal",
+  authorization: "AllowAuthenticated"
+};
+
+let sourceNames = [];
+
+function make(param, param$1, param$2, param$3) {
+  return 0;
+}
+
+function outputs(param) {
+  return 0;
+}
+
+function operations(param) {
+  return 0;
+}
+
+function finish() {
+  
+}
+
+let PublicReadModel_Spec = {
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let PublicReadModel = {
+  Spec: PublicReadModel_Spec,
+  sourceNames: sourceNames,
+  make: make,
+  outputs: outputs,
+  operations: operations,
+  finish: finish
+};
+
+let sourceNames$1 = [];
+
+function make$1(param, param$1, param$2, param$3) {
+  return 0;
+}
+
+function outputs$1(param) {
+  return 0;
+}
+
+function operations$1(param) {
+  return 0;
+}
+
+function finish$1() {
+  
+}
+
+let InternalReadModel_Spec = {
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Internal"
+};
+
+let InternalReadModel = {
+  Spec: InternalReadModel_Spec,
+  sourceNames: sourceNames$1,
+  make: make$1,
+  outputs: outputs$1,
+  operations: operations$1,
+  finish: finish$1
+};
+
+function isVisible(R) {
+  let match = R.Spec.visibility;
+  return match === "Public";
+}
+
+let readModels = [
+  PublicReadModel,
+  InternalReadModel
+];
+
+globalThis.describe("ReadModel visibility filter", () => {
+  globalThis.test("PPX defaults visibility to Public when no attribute is present", () => {
+    globalThis.expect("Public").toEqual("Public");
+  });
+  globalThis.test("Internal spec retains Internal value", () => {
+    globalThis.expect("Internal").toEqual("Internal");
+  });
+  globalThis.test("filter predicate excludes Internal", () => {
+    let visible = readModels.filter(isVisible);
+    globalThis.expect(visible.length).toBe(1);
+  });
+  globalThis.test("filter predicate retains Public name", () => {
+    let visible = readModels.filter(isVisible);
+    let first = visible[0];
+    globalThis.expect(first.Spec.name).toEqual("PublicView");
+  });
+  globalThis.test("unfiltered list still contains both entries (no over-filtering)", () => {
+    globalThis.expect(readModels.length).toBe(2);
+  });
+});
+
+globalThis.describe("Plugin_Structure.make — visibility tagging", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("VisibilityPlugin", undefined, readModels, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  globalThis.test("readModels carries both Public and Internal entries", () => {
+    globalThis.expect(structure.readModels.length).toBe(2);
+  });
+  globalThis.test("the Public entry is tagged visibility = None", () => {
+    let $$public = structure.readModels.find(d => d.name === "PublicView");
+    globalThis.expect(Stdlib_Option.map($$public, d => d.visibility)).toEqual(Primitive_option.some(undefined));
+  });
+  globalThis.test("the Internal entry is carried and tagged visibility = Some(\"Internal\")", () => {
+    let internal = structure.readModels.find(d => d.name === "InternalView");
+    globalThis.expect(Stdlib_Option.map(internal, d => d.visibility)).toEqual("Internal");
+  });
+  globalThis.test("aggregates / stateViewSlices stay empty when none are passed (sanity)", () => {
+    globalThis.expect([
+      structure.aggregates.length,
+      structure.stateViewSlices.length
+    ]).toEqual([
+      0,
+      0
+    ]);
+  });
+});
+
+export {
+  PublicSpec,
+  InternalSpec,
+  PublicReadModel,
+  InternalReadModel,
+  isVisible,
+  readModels,
+}
+/* stateSchema Not a pure module */

package/tests/plugin/PluginSpecExperiment.res

@@ -0,0 +1,13 @@
+S.enableJson()
+
+@schema
+type record = {
+  a: @s.meta({description: "aaa"}) string,
+  b: string,
+}
+
+@schema
+type variant = | @s.meta({description: "QQQ"}) Q(int) | @s.meta({description: "XXX"}) X | Y
+
+Console.log2("Record:", recordSchema->S.toJSONSchema->JSON.stringifyAny(~space=2))
+Console.log2("Variant:", variantSchema->S.toJSONSchema->JSON.stringifyAny(~space=2))

package/tests/plugin/PluginSpecExperiment.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+S.enableJson();
+
+let recordSchema = S.schema(s => ({
+  a: s.m(S.meta(S.string, {
+    description: "aaa"
+  })),
+  b: s.m(S.string)
+}));
+
+let variantSchema = S.union([
+  S.schema(s => ({
+    TAG: "Q",
+    _0: s.m(S.int)
+  })),
+  S.literal("X"),
+  S.literal("Y")
+]);
+
+console.log("Record:", JSON.stringify(S.toJSONSchema(recordSchema), undefined, 2));
+
+console.log("Variant:", JSON.stringify(S.toJSONSchema(variantSchema), undefined, 2));
+
+export {
+  recordSchema,
+  variantSchema,
+}
+/*  Not a pure module */

package/tests/plugin/PluginStructureTest.res

@@ -0,0 +1,298 @@
+// Phase 2 validation: Plugin_Structure.make populates all graph fields correctly.
+// Uses simplified test specs (PsPlaceOrder, PsShipOrder, PsOrdersView, PsAvailableProductsView)
+// and calls Plugin_Structure.make directly — no Platform needed.
+
+open JestGlobals
+
+// Stub T modules — Plugin_Structure.make only reads `Spec` fields; `make` is never called.
+type scsComponent = Component.t<
+  ReventlessInfra.StateChangeSlice.t,
+  ReventlessInfra.StateChangeSlice.outputs,
+  ReventlessInfra.StateChangeSlice.operations,
+>
+type svsComponent = Component.t<
+  ReventlessInfra.StateViewSlice.t,
+  ReventlessInfra.StateViewSlice.outputs,
+  ReventlessInfra.StateViewSlice.operations,
+>
+
+module PsPlaceOrderSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsPlaceOrder
+  module Behavior = {
+    type state = PsPlaceOrder.state
+    let initialState = PsPlaceOrder.initialState
+    let evolve = PsPlaceOrder.evolve
+    let decide = PsPlaceOrder.decide
+    let moduleUrl = PsPlaceOrder.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+module PsShipOrderSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsShipOrder
+  module Behavior = {
+    type state = PsShipOrder.state
+    let initialState = PsShipOrder.initialState
+    let evolve = PsShipOrder.evolve
+    let decide = PsShipOrder.decide
+    let moduleUrl = PsShipOrder.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+module PsOrdersViewSlice: ReventlessInfra.StateViewSlice.T = {
+  module Spec = PsOrdersView
+  module Projection = {
+    let project = PsOrdersView.project
+    let moduleUrl = PsOrdersView.moduleUrl
+  }
+  type component = svsComponent
+  let make = (~dcbEventLog as _, ~opts as _=?): component => Obj.magic(0)
+}
+module PsAvailableProductsViewSlice: ReventlessInfra.StateViewSlice.T = {
+  module Spec = PsAvailableProductsView
+  module Projection = {
+    let project = PsAvailableProductsView.project
+    let moduleUrl = PsAvailableProductsView.moduleUrl
+  }
+  type component = svsComponent
+  let make = (~dcbEventLog as _, ~opts as _=?): component => Obj.magic(0)
+}
+module PsCustomersViewSlice: ReventlessInfra.StateViewSlice.T = {
+  module Spec = PsCustomersView
+  module Projection = {
+    let project = PsCustomersView.project
+    let moduleUrl = PsCustomersView.moduleUrl
+  }
+  type component = svsComponent
+  let make = (~dcbEventLog as _, ~opts as _=?): component => Obj.magic(0)
+}
+module PsAnnotatedViewSlice: ReventlessInfra.StateViewSlice.T = {
+  module Spec = PsAnnotatedView
+  module Projection = {
+    let project = PsAnnotatedView.project
+    let moduleUrl = PsAnnotatedView.moduleUrl
+  }
+  type component = svsComponent
+  let make = (~dcbEventLog as _, ~opts as _=?): component => Obj.magic(0)
+}
+
+let structure = Plugin_Structure.make(
+  ~name="TestPlugin",
+  ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
+  ~stateViewSlices=[
+    module(PsOrdersViewSlice),
+    module(PsAvailableProductsViewSlice),
+    module(PsCustomersViewSlice),
+    module(PsAnnotatedViewSlice),
+  ],
+)
+
+describe("Plugin_Structure.make — Phase 2 graph fields", () => {
+  describe("stateChangeSlices", () => {
+    testSync("produces two SCS entries in declaration order", () => {
+      expect(structure.stateChangeSlices->Array.length)->toBe(2)
+    })
+
+    testSync("PlaceOrder: producedEventTypes contains OrderPlaced (qualified)", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.producedEventTypes)->toEqual(["TestPlugin.OrderPlaced"])
+    })
+
+    testSync("PlaceOrder: consumedEventTypes contains CatalogProductSynced qualified (payload-less variants excluded)", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.consumedEventTypes)->toEqual(["TestPlugin.CatalogProductSynced"])
+    })
+
+    testSync("PlaceOrder: linkedViews contains Orders (consumes its OrderPlaced)", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.linkedViews)->toEqual(["Orders"])
+    })
+
+    testSync("PlaceOrder: consistencyRead is AvailableProducts (only SVS consuming CatalogProductSynced)", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.consistencyRead)->toEqual(Some("AvailableProducts"))
+    })
+
+    testSync("PlaceOrder command: level Collection (creation command), aggregateIdField orderId for UUID injection", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      let cmd = placeOrder.commands->Array.getUnsafe(0)
+      expect((cmd.level, cmd.aggregateIdField))->toEqual((
+        Reventless.Plugin.Collection,
+        Some("orderId"),
+      ))
+    })
+
+    testSync("ShipOrder: producedEventTypes contains OrderShipped (qualified)", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.producedEventTypes)->toEqual(["TestPlugin.OrderShipped"])
+    })
+
+    testSync("ShipOrder: consumedEventTypes is empty (all consumed events are payload-less literals)", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.consumedEventTypes)->toEqual([])
+    })
+
+    testSync("ShipOrder: linkedViews contains Orders (consumes its OrderShipped)", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.linkedViews)->toEqual(["Orders"])
+    })
+
+    testSync("ShipOrder: consistencyRead is None (empty consumedEventTypes cannot overlap any SVS)", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.consistencyRead)->toEqual(None)
+    })
+
+    testSync("ShipOrder command: level Instance, aggregateIdField orderId", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let cmd = shipOrder.commands->Array.getUnsafe(0)
+      expect((cmd.level, cmd.aggregateIdField))->toEqual((
+        Reventless.Plugin.Instance,
+        Some("orderId"),
+      ))
+    })
+
+    testSync("ShipOrder: payload-less command CancelShipment is surfaced in commands", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.commands->Array.map(c => c.name))->toEqual(["ShipOrder", "CancelShipment"])
+    })
+
+    testSync("ShipOrder: payload-less event ShipmentVoided is surfaced in events", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.events->Array.map(e => e.name))->toEqual(["OrderShipped", "ShipmentVoided"])
+    })
+
+    testSync("ShipOrder: producedEventTypes still excludes the payload-less ShipmentVoided (DCB filter intact)", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.producedEventTypes)->toEqual(["TestPlugin.OrderShipped"])
+    })
+  })
+
+  describe("stateViewSlices", () => {
+    testSync("produces four SVS entries in declaration order", () => {
+      expect(structure.stateViewSlices->Array.length)->toBe(4)
+    })
+
+    testSync("OrdersView: consumedEventTypes contains the three order events (qualified)", () => {
+      let ordersView = structure.stateViewSlices->Array.getUnsafe(0)
+      expect(ordersView.consumedEventTypes)->toEqual([
+        "TestPlugin.OrderPlaced",
+        "TestPlugin.OrderShipped",
+        "TestPlugin.OrderCancelled",
+      ])
+    })
+
+    testSync("OrdersView: linkedWriteSide contains both SCS producing order events", () => {
+      let ordersView = structure.stateViewSlices->Array.getUnsafe(0)
+      expect(ordersView.linkedWriteSide)->toEqual(["PlaceOrder", "ShipOrder"])
+    })
+
+    testSync("AvailableProductsView: consumedEventTypes contains catalog events (qualified)", () => {
+      let apv = structure.stateViewSlices->Array.getUnsafe(1)
+      expect(apv.consumedEventTypes)->toEqual([
+        "TestPlugin.CatalogProductSynced",
+        "TestPlugin.CatalogProductPriceChanged",
+      ])
+    })
+
+    testSync("AvailableProductsView: linkedWriteSide is empty (no SCS produces these events)", () => {
+      let apv = structure.stateViewSlices->Array.getUnsafe(1)
+      expect(apv.linkedWriteSide)->toEqual([])
+    })
+  })
+
+  describe("labelField / searchableFields", () => {
+    testSync("OrdersView: no @displayName → first non-`*Id` string field wins (customerName)", () => {
+      let ordersView = structure.stateViewSlices->Array.getUnsafe(0)
+      expect((ordersView.labelField, ordersView.searchableFields))->toEqual((
+        "customerName",
+        ["customerName"],
+      ))
+    })
+
+    testSync("AvailableProductsView: no @displayName → first non-`*Id` string field wins (name)", () => {
+      let apv = structure.stateViewSlices->Array.getUnsafe(1)
+      expect((apv.labelField, apv.searchableFields))->toEqual(("name", ["name"]))
+    })
+
+    testSync("Customers: composite @displayName → labelField=displayName, searchableFields=raw source fields in declaration order", () => {
+      let customers = structure.stateViewSlices->Array.getUnsafe(2)
+      expect((customers.labelField, customers.searchableFields))->toEqual((
+        "displayName",
+        ["firstName", "lastName"],
+      ))
+    })
+  })
+
+  // 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).
+  describe("queryableDef.schema propagates x-reventless-* annotations", () => {
+    let getProperty = (json: JSON.t, key: string): option<JSON.t> =>
+      switch json->JSON.Decode.object {
+      | Some(obj) => obj->Dict.get(key)
+      | None => None
+      }
+
+    let getPropertyOf = (json: JSON.t, fieldName: string): option<JSON.t> =>
+      switch getProperty(json, "properties") {
+      | Some(props) =>
+        switch props->JSON.Decode.object {
+        | Some(obj) => obj->Dict.get(fieldName)
+        | None => None
+        }
+      | None => None
+      }
+
+    let parseSchema = (svs: Reventless.Plugin.queryableDef): JSON.t =>
+      svs.schema->JSON.parseOrThrow
+
+    let annotatedSchema = structure.stateViewSlices->Array.getUnsafe(3)->parseSchema
+
+    testSync("itemId carries x-reventless-id", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("itemId")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-id"))
+        ->Option.flatMap(JSON.Decode.bool),
+      )->toBe(Some(true))
+    })
+
+    testSync("version carries x-reventless-subId", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("version")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-subId"))
+        ->Option.flatMap(JSON.Decode.bool),
+      )->toBe(Some(true))
+    })
+
+    testSync("ownerId carries x-reventless-index = byOwner", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("ownerId")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-index"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toBe(Some("byOwner"))
+    })
+
+    testSync("unannotated field 'name' has no x-reventless-* keys", () => {
+      let nameField = annotatedSchema->getPropertyOf("name")
+      expect((
+        nameField->Option.flatMap(s => getProperty(s, "x-reventless-id")),
+        nameField->Option.flatMap(s => getProperty(s, "x-reventless-subId")),
+        nameField->Option.flatMap(s => getProperty(s, "x-reventless-index")),
+      ))->toEqual((None, None, None))
+    })
+
+    testSync("unannotated state-view slice (Orders) emits no x-reventless-* keys", () => {
+      let ordersSchema = structure.stateViewSlices->Array.getUnsafe(0)->parseSchema
+      let orderIdField = ordersSchema->getPropertyOf("orderId")
+      expect(
+        orderIdField->Option.flatMap(s => getProperty(s, "x-reventless-id")),
+      )->toBe(None)
+    })
+  })
+})