@reventlessdev/reventless-core 3.0.0-alpha.266 → 3.0.0-alpha.268

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -12,6 +12,7 @@ import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js
 import * as Trait$Reventless from "@reventlessdev/reventless-spec/src/types/Trait.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
 import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
@@ -444,20 +445,62 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
   };
 }
 
-function extractReferences(properties) {
-  return Object.entries(properties).flatMap(param => Reference$Reventless.collectFieldTargets(param[0], param[1]).map(param => {
-    let target = param[1];
-    return {
-      fieldName: param[0],
-      entity: target.entity,
-      plugin: target.plugin
-    };
-  }));
+function identityReference(identityViews, fieldName, fieldSchema, declared) {
+  let key = Semantic$Reventless.fieldIdentityKey(fieldSchema);
+  if (key === undefined) {
+    return declared;
+  }
+  let keyed = Stdlib_Option.getOr(identityViews.viewsByKey[key], []);
+  if (declared.length !== 0) {
+    declared.forEach(param => {
+      let target = param[1];
+      if (Stdlib_Option.isNone(target.plugin) && identityViews.viewNames.includes(target.entity) && !keyed.includes(target.entity)) {
+        return identityViews.report(fieldName + ` is a ` + key + `, and its @ref names ` + target.entity + `, which is not keyed by it.`);
+      }
+    });
+    return declared;
+  }
+  let len = keyed.length;
+  if (len !== 1) {
+    if (len !== 0) {
+      identityViews.report(fieldName + ` is a ` + key + `, and ` + keyed.join(" and ") + ` are all keyed by it. Say which it references with @ref.`);
+      return [];
+    } else {
+      identityViews.report(fieldName + ` is a ` + key + `, and no view in this plugin is keyed by it, so it references nothing. List the identity in a view, or reference another plugin's with @ref("Plugin.View").`);
+      return [];
+    }
+  }
+  let view = keyed[0];
+  return [[
+      fieldName,
+      {
+        entity: view,
+        plugin: undefined,
+        identity: key
+      }
+    ]];
 }
 
-function toEventDef(v) {
+function extractReferences(identityViews, minted, properties) {
+  return Object.entries(properties).flatMap(param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    let declared = Reference$Reventless.collectFieldTargets(fieldName, fieldSchema);
+    let targets = identityViews !== undefined && Primitive_object.notequal(minted, fieldName) ? identityReference(identityViews, fieldName, fieldSchema, declared) : declared;
+    return targets.map(param => {
+      let target = param[1];
+      return {
+        fieldName: param[0],
+        entity: target.entity,
+        plugin: target.plugin
+      };
+    });
+  });
+}
+
+function toEventDef(identityViews, v) {
   let mkDef = (variantName, properties) => {
-    let references = extractReferences(properties);
+    let references = extractReferences(identityViews, undefined, properties);
     return {
       name: variantName,
       schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, v)),
@@ -488,16 +531,16 @@ function toEventDef(v) {
   }
 }
 
-function extractEventDefs(eventSchema) {
+function extractEventDefs(identityViews, eventSchema) {
   if (eventSchema.type === "anyOf") {
-    return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
+    return Stdlib_Array.filterMap(eventSchema.anyOf, v => toEventDef(identityViews, v));
   } else {
-    return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
+    return Stdlib_Option.mapOr(toEventDef(identityViews, eventSchema), [], def => [def]);
   }
 }
 
 function extractErrorDefs(errorSchema) {
-  return extractEventDefs(errorSchema).map(param => ({
+  return extractEventDefs(undefined, errorSchema).map(param => ({
     name: param.name,
     schema: param.schema,
     references: param.references
@@ -597,10 +640,10 @@ function annotateArgTypes(schema, argTypes) {
   return schema;
 }
 
-function toCommandDef(isAggregate, partitionKey, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, derivedEdgeFor, v) {
+function toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, derivedEdgeFor, v) {
   let mkDef = (variantName, properties) => {
     let match = commandLevelAndId(isAggregate, partitionKey, variantName, properties);
-    let references = extractReferences(properties);
+    let aggregateIdField = match[1];
     let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
         TAG: variantName
       }) : variantName;
@@ -635,6 +678,7 @@ function toCommandDef(isAggregate, partitionKey, mutationFieldFor, parentSchema,
     });
     let targetState = observed !== undefined ? observed : Transition$Reventless.targetState(declared);
     let level = Stdlib_Option.getOr(Stdlib_Option.flatMap(derived, d => d.level), match[0]);
+    let references = extractReferences(identityViews, level === "Collection" ? aggregateIdField : undefined, properties);
     let apiExposed = false;
     if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
       let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
@@ -648,7 +692,7 @@ function toCommandDef(isAggregate, partitionKey, mutationFieldFor, parentSchema,
       name: variantName,
       schema: JSON.stringify(annotatedSchema),
       level: level,
-      aggregateIdField: match[1],
+      aggregateIdField: aggregateIdField,
       mutationField: mutationField,
       references: references,
       allowedStates: match$3[0],
@@ -683,12 +727,12 @@ function toCommandDef(isAggregate, partitionKey, mutationFieldFor, parentSchema,
   }
 }
 
-function extractCommandDefs(isAggregate, partitionKey, mutationFieldFor, commandAuthorization, commandTransition, derivedEdgeForOpt, commandSchema) {
+function extractCommandDefs(identityViews, isAggregate, partitionKey, mutationFieldFor, commandAuthorization, commandTransition, derivedEdgeForOpt, commandSchema) {
   let derivedEdgeFor = derivedEdgeForOpt !== undefined ? derivedEdgeForOpt : param => {};
   if (commandSchema.type === "anyOf") {
-    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, v));
+    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, v));
   } else {
-    return Stdlib_Option.mapOr(toCommandDef(isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, commandSchema), [], def => [def]);
+    return Stdlib_Option.mapOr(toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, commandSchema), [], def => [def]);
   }
 }
 
@@ -1101,6 +1145,46 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     };
   }
   let partitionFailures = [];
+  let keyIdentityOf = (stateSchema, idField) => Stdlib_Option.map(idField, field => {
+    let tmp;
+    tmp = stateSchema.type === "object" ? Stdlib_Option.flatMap(stateSchema.properties[field], Semantic$Reventless.identityKey) : undefined;
+    return Stdlib_Option.getOr(tmp, field);
+  });
+  let viewKeys = readModels.map((R, i) => {
+    let def = readModelDefs[i];
+    let declared = Semantic$Reventless.identityKey(R.Spec.Id.schema);
+    let key = declared !== undefined ? declared : keyIdentityOf(R.Spec.stateSchema, def.idField);
+    return [
+      R.Spec.name,
+      key
+    ];
+  }).concat(stateViewSlices.map((SVS, i) => {
+    let def = stateViewDefs[i];
+    return [
+      SVS.Spec.name,
+      keyIdentityOf(SVS.Spec.stateSchema, def.idField)
+    ];
+  }));
+  let viewsByKey = {};
+  viewKeys.forEach(param => {
+    let view = param[0];
+    Stdlib_Option.forEach(param[1], k => {
+      viewsByKey[k] = Stdlib_Option.getOr(viewsByKey[k], []).concat([view]);
+    });
+  });
+  let reported = new Set();
+  let identityViews_viewNames = viewKeys.map(param => param[0]);
+  let identityViews_report = message => {
+    if (!reported.has(message)) {
+      reported.add(message);
+      return log.warn("Plugin_Structure", undefined, name + `: ` + message);
+    }
+  };
+  let identityViews = {
+    viewsByKey: viewsByKey,
+    viewNames: identityViews_viewNames,
+    report: identityViews_report
+  };
   let stateChangeDefs = stateChangeSlices.map((SCS, i) => {
     let match = scsProduced[i];
     let produced = match[1];
@@ -1108,12 +1192,12 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match$1[1];
     return {
       name: SCS.Spec.name,
-      commands: extractCommandDefs(false, partitionBySlice[SCS.Spec.name], variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
+      commands: extractCommandDefs(identityViews, false, partitionBySlice[SCS.Spec.name], variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: consumed,
       linkedViews: linkedSvsFor(produced),
       consistencyRead: consistencyReadFor(consumed),
-      events: extractEventDefs(SCS.Spec.eventSchema),
+      events: extractEventDefs(identityViews, SCS.Spec.eventSchema),
       errors: extractErrorDefs(SCS.Spec.errorSchema),
       chapter: componentChapters[SCS.Spec.name]
     };
@@ -1123,12 +1207,12 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let produced = match[1];
     return {
       name: A.Spec.name,
-      commands: extractCommandDefs(true, undefined, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
+      commands: extractCommandDefs(identityViews, true, undefined, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: [],
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
       consistencyRead: undefined,
-      events: extractEventDefs(A.Spec.eventSchema),
+      events: extractEventDefs(identityViews, A.Spec.eventSchema),
       errors: extractErrorDefs(A.Spec.errorSchema),
       chapter: componentChapters[A.Spec.name]
     };
@@ -1452,6 +1536,7 @@ export {
   checkLifecycleTopology,
   labelFieldSourceToString,
   labelFieldsFromStateSchema,
+  identityReference,
   extractReferences,
   toEventDef,
   extractEventDefs,

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -59,7 +59,6 @@ let SliceBehavior = {
 let SliceHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   name: DcbFixtures$ReventlessCore.TestCommandSpec.name,
   moduleUrl: DcbFixtures$ReventlessCore.TestCommandSpec.moduleUrl,
-  Id: Id$Reventless.$$String,
   consumedEventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.consumedEventSchema,
   errorSchema: DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema,
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,

package/tests/dcb/DcbStateChangeSliceTest.res.mjs

@@ -55,7 +55,6 @@ let TestCommandBehavior = {
 let TestHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   name: DcbFixtures$ReventlessCore.TestCommandSpec.name,
   moduleUrl: DcbFixtures$ReventlessCore.TestCommandSpec.moduleUrl,
-  Id: Id$Reventless.$$String,
   consumedEventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.consumedEventSchema,
   errorSchema: DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema,
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
@@ -155,7 +154,6 @@ let EventualSpec = {
 let StrongHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   name: name,
   moduleUrl: moduleUrl$1,
-  Id: Id$Reventless.$$String,
   consumedEventSchema: consumedEventSchema,
   errorSchema: errorSchema,
   eventSchema: eventSchema,
@@ -169,7 +167,6 @@ let StrongHandler = StateChangeSlice_Callback$ReventlessCore.Make({
 let EventualHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   name: name$1,
   moduleUrl: moduleUrl$2,
-  Id: Id$Reventless.$$String,
   consumedEventSchema: consumedEventSchema$1,
   errorSchema: errorSchema$1,
   eventSchema: eventSchema$1,

package/tests/eventmapper/EventMapperFixtures.res

@@ -5,7 +5,7 @@ open Reventless.Projection
 // ─────────────────────────────────────────────────────────────
 
 module SourceSpec = {
-  module Id = Reventless.Id.String
+  module Id = Reventless.Id.StringPure
   let name = "SourceAggregate"
 
   @schema
@@ -22,7 +22,7 @@ module SourceSpec = {
 // ─────────────────────────────────────────────────────────────
 
 module TargetSpec = {
-  module Id = Reventless.Id.String
+  module Id = Reventless.Id.StringPure
   let name = "ItemCatalog"
 
   @schema

package/tests/eventmapper/EventMapperFixtures.res.mjs

@@ -81,11 +81,23 @@ function project(msg) {
 }
 
 let ItemMapping = Projection$Reventless.Mapping.Make({
-  Id: Id$Reventless.$$String,
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
   name: name,
   eventSchema: eventSchema
 })({
-  Id: Id$Reventless.$$String,
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
   name: name$1,
   stateSchema: stateSchema,
   subIdConfig: undefined

package/tests/plugin/IdentityReferenceTest.res

@@ -0,0 +1,118 @@
+// A typed id finds the view that lists it without an `@ref`, whenever exactly one
+// view is keyed by its identity. Where the type cannot decide, it says so rather
+// than guessing: which list a reference means is a product decision.
+
+open JestGlobals
+
+module ProductId = Reventless.Id.Make({
+  let key = "productId"
+})
+module CustomerId = Reventless.Id.Make({
+  let key = "customerId"
+})
+
+let refsOf = (~viewsByKey, ~minted=?, schema: S.t<'a>) => {
+  let reports = []
+  let identityViews: Plugin_Structure.identityViews = {
+    viewsByKey: Dict.fromArray(viewsByKey),
+    viewNames: viewsByKey->Array.flatMap(((_, views)) => views),
+    report: message => reports->Array.push(message),
+  }
+  let properties = switch schema->S.castToUnknown {
+  | Object({properties}) => properties
+  | _ => Dict.make()
+  }
+  let refs =
+    Plugin_Structure.extractReferences(~identityViews, ~minted?, properties)->Array.map(r => (
+      r.fieldName,
+      r.entity,
+    ))
+  (refs, reports)
+}
+
+let order = S.schema(s =>
+  {
+    "buyer": s.matches(CustomerId.schema),
+    "productIds": s.matches(S.array(ProductId.schema)),
+    "note": s.matches(S.string),
+  }
+)
+
+describe("a reference derived from the type", () => {
+  testSync("exactly one view keyed by the identity is the reference", () => {
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers"]), ("productId", ["AvailableProducts"])],
+      order,
+    )
+    expect(refs)->toEqual([("buyer", "Customers"), ("productIds", "AvailableProducts")])
+    expect(reports)->toEqual([])
+  })
+
+  testSync("several views keyed by it ask for @ref instead of guessing", () => {
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers"]), ("productId", ["Products", "ProductDemand"])],
+      order,
+    )
+    expect(refs)->toEqual([("buyer", "Customers")])
+    expect(reports->Array.some(r => r->String.includes("Products and ProductDemand")))->toBe(true)
+  })
+
+  testSync("no view keyed by it is reported", () => {
+    let (refs, reports) = refsOf(~viewsByKey=[("productId", ["AvailableProducts"])], order)
+    expect(refs)->toEqual([("productIds", "AvailableProducts")])
+    expect(reports->Array.some(r => r->String.includes("no view in this plugin")))->toBe(true)
+  })
+
+  // A create form mints this id; a list of the rows that already exist is the
+  // wrong control for it.
+  testSync("the id a creating command mints references nothing", () => {
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers"]), ("productId", ["AvailableProducts"])],
+      ~minted="buyer",
+      order,
+    )
+    expect((refs, reports))->toEqual(([("productIds", "AvailableProducts")], []))
+  })
+
+  testSync("an untyped field is left to its name, as before", () => {
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers"])],
+      S.schema(s => {"customerId": s.matches(S.string)}),
+    )
+    expect((refs, reports))->toEqual(([], []))
+  })
+})
+
+describe("a declared @ref on a typed id", () => {
+  let referenced = S.schema(s =>
+    {"buyer": s.matches(CustomerId.schema->Reventless.Reference.mark("Products"))}
+  )
+
+  testSync("is kept, and checked against the views keyed by the identity", () => {
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers"]), ("productId", ["Products"])],
+      referenced,
+    )
+    expect(refs)->toEqual([("buyer", "Products")])
+    expect(reports->Array.some(r => r->String.includes("not keyed by it")))->toBe(true)
+  })
+
+  testSync("naming a view keyed by the identity is fine", () => {
+    let chosen = S.schema(
+      s => {"buyer": s.matches(CustomerId.schema->Reventless.Reference.mark("Customers"))},
+    )
+    let (refs, reports) = refsOf(
+      ~viewsByKey=[("customerId", ["Customers", "VipCustomers"])],
+      chosen,
+    )
+    expect((refs, reports))->toEqual(([("buyer", "Customers")], []))
+  })
+
+  testSync("stands on a minted id: only the derived one steps aside", () => {
+    let chosen = S.schema(
+      s => {"buyer": s.matches(CustomerId.schema->Reventless.Reference.mark("Customers"))},
+    )
+    let (refs, _) = refsOf(~viewsByKey=[("customerId", ["Customers"])], ~minted="buyer", chosen)
+    expect(refs)->toEqual([("buyer", "Customers")])
+  })
+})

package/tests/plugin/IdentityReferenceTest.res.mjs

@@ -0,0 +1,204 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+
+let ProductId = Id$Reventless.Make({
+  key: "productId"
+});
+
+let CustomerId = Id$Reventless.Make({
+  key: "customerId"
+});
+
+function refsOf(viewsByKey, minted, schema) {
+  let reports = [];
+  let identityViews_viewsByKey = Object.fromEntries(viewsByKey);
+  let identityViews_viewNames = viewsByKey.flatMap(param => param[1]);
+  let identityViews_report = message => {
+    reports.push(message);
+  };
+  let identityViews = {
+    viewsByKey: identityViews_viewsByKey,
+    viewNames: identityViews_viewNames,
+    report: identityViews_report
+  };
+  let properties;
+  properties = schema.type === "object" ? schema.properties : ({});
+  let refs = Plugin_Structure$ReventlessCore.extractReferences(identityViews, minted, properties).map(r => [
+    r.fieldName,
+    r.entity
+  ]);
+  return [
+    refs,
+    reports
+  ];
+}
+
+let order = Sury.$schema(s => ({
+  buyer: s.m(CustomerId.schema),
+  productIds: s.m(Sury.array(ProductId.schema)),
+  note: s.m(Sury.string)
+}));
+
+globalThis.describe("a reference derived from the type", () => {
+  globalThis.test("exactly one view keyed by the identity is the reference", () => {
+    let match = refsOf([
+      [
+        "customerId",
+        ["Customers"]
+      ],
+      [
+        "productId",
+        ["AvailableProducts"]
+      ]
+    ], undefined, order);
+    globalThis.expect(match[0]).toEqual([
+      [
+        "buyer",
+        "Customers"
+      ],
+      [
+        "productIds",
+        "AvailableProducts"
+      ]
+    ]);
+    globalThis.expect(match[1]).toEqual([]);
+  });
+  globalThis.test("several views keyed by it ask for @ref instead of guessing", () => {
+    let match = refsOf([
+      [
+        "customerId",
+        ["Customers"]
+      ],
+      [
+        "productId",
+        [
+          "Products",
+          "ProductDemand"
+        ]
+      ]
+    ], undefined, order);
+    globalThis.expect(match[0]).toEqual([[
+        "buyer",
+        "Customers"
+      ]]);
+    globalThis.expect(match[1].some(r => r.includes("Products and ProductDemand"))).toBe(true);
+  });
+  globalThis.test("no view keyed by it is reported", () => {
+    let match = refsOf([[
+        "productId",
+        ["AvailableProducts"]
+      ]], undefined, order);
+    globalThis.expect(match[0]).toEqual([[
+        "productIds",
+        "AvailableProducts"
+      ]]);
+    globalThis.expect(match[1].some(r => r.includes("no view in this plugin"))).toBe(true);
+  });
+  globalThis.test("the id a creating command mints references nothing", () => {
+    let match = refsOf([
+      [
+        "customerId",
+        ["Customers"]
+      ],
+      [
+        "productId",
+        ["AvailableProducts"]
+      ]
+    ], "buyer", order);
+    globalThis.expect([
+      match[0],
+      match[1]
+    ]).toEqual([
+      [[
+          "productIds",
+          "AvailableProducts"
+        ]],
+      []
+    ]);
+  });
+  globalThis.test("an untyped field is left to its name, as before", () => {
+    let match = refsOf([[
+        "customerId",
+        ["Customers"]
+      ]], undefined, Sury.$schema(s => ({
+      customerId: s.m(Sury.string)
+    })));
+    globalThis.expect([
+      match[0],
+      match[1]
+    ]).toEqual([
+      [],
+      []
+    ]);
+  });
+});
+
+globalThis.describe("a declared @ref on a typed id", () => {
+  let referenced = Sury.$schema(s => ({
+    buyer: s.m(Reference$Reventless.mark(CustomerId.schema, undefined, undefined, "Products"))
+  }));
+  globalThis.test("is kept, and checked against the views keyed by the identity", () => {
+    let match = refsOf([
+      [
+        "customerId",
+        ["Customers"]
+      ],
+      [
+        "productId",
+        ["Products"]
+      ]
+    ], undefined, referenced);
+    globalThis.expect(match[0]).toEqual([[
+        "buyer",
+        "Products"
+      ]]);
+    globalThis.expect(match[1].some(r => r.includes("not keyed by it"))).toBe(true);
+  });
+  globalThis.test("naming a view keyed by the identity is fine", () => {
+    let chosen = Sury.$schema(s => ({
+      buyer: s.m(Reference$Reventless.mark(CustomerId.schema, undefined, undefined, "Customers"))
+    }));
+    let match = refsOf([[
+        "customerId",
+        [
+          "Customers",
+          "VipCustomers"
+        ]
+      ]], undefined, chosen);
+    globalThis.expect([
+      match[0],
+      match[1]
+    ]).toEqual([
+      [[
+          "buyer",
+          "Customers"
+        ]],
+      []
+    ]);
+  });
+  globalThis.test("stands on a minted id: only the derived one steps aside", () => {
+    let chosen = Sury.$schema(s => ({
+      buyer: s.m(Reference$Reventless.mark(CustomerId.schema, undefined, undefined, "Customers"))
+    }));
+    let match = refsOf([[
+        "customerId",
+        ["Customers"]
+      ]], "buyer", chosen);
+    globalThis.expect(match[0]).toEqual([[
+        "buyer",
+        "Customers"
+      ]]);
+  });
+});
+
+export {
+  ProductId,
+  CustomerId,
+  refsOf,
+  order,
+}
+/* ProductId Not a pure module */

package/tests/plugin/PluginStructureAccessTest.res.mjs

@@ -22,7 +22,6 @@ function make(param, param$1, param$2, param$3, param$4, param$5, param$6) {
 let PsGatedCommandsSlice_Spec = {
   name: PsGatedCommands$ReventlessCore.name,
   moduleUrl: PsGatedCommands$ReventlessCore.moduleUrl,
-  Id: Id$Reventless.$$String,
   consumedEventSchema: PsGatedCommands$ReventlessCore.consumedEventSchema,
   errorSchema: PsGatedCommands$ReventlessCore.errorSchema,
   eventSchema: PsGatedCommands$ReventlessCore.eventSchema,
@@ -53,6 +52,13 @@ let PsGatedViewSlice_Spec = {
   name: PsGatedView$ReventlessCore.name,
   moduleUrl: PsGatedView$ReventlessCore.moduleUrl,
   stateSchema: PsGatedView$ReventlessCore.stateSchema,
+  Key: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
   consumedEventSchema: PsGatedView$ReventlessCore.consumedEventSchema,
   config: PsGatedView$ReventlessCore.config,
   subIdConfig: undefined,
@@ -79,6 +85,13 @@ let PsOrdersViewSlice_Spec = {
   name: PsOrdersView$ReventlessCore.name,
   moduleUrl: PsOrdersView$ReventlessCore.moduleUrl,
   stateSchema: PsOrdersView$ReventlessCore.stateSchema,
+  Key: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
   consumedEventSchema: PsOrdersView$ReventlessCore.consumedEventSchema,
   config: PsOrdersView$ReventlessCore.config,
   subIdConfig: undefined,