@reventlessdev/reventless-core 3.0.0-alpha.265 → 3.0.0-alpha.267

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -1,6 +1,7 @@
 // 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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Money$Reventless from "@reventlessdev/reventless-spec/src/semantic/Money.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
@@ -9,6 +10,14 @@ import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/
 import * as PsInternalFieldsReadModel$ReventlessCore from "./PsInternalFieldsReadModel.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "../../src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
 
+let OrderId = Id$Reventless.Make({
+  key: "orderId"
+});
+
+let CustomerId = Id$Reventless.Make({
+  key: "customerId"
+});
+
 let commandSchema = Sury.union([
   Sury.$schema(s => ({
     TAG: "CancelOrder",
@@ -100,7 +109,7 @@ globalThis.describe("resolveKeyField — the ladder", () => {
       productId: s.m(Sury.string),
       name: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("AvailableProducts", schema)).toEqual([
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "AvailableProducts", schema)).toEqual([
       "productId",
       "sole"
     ]);
@@ -110,7 +119,7 @@ globalThis.describe("resolveKeyField — the ladder", () => {
       productId: s.m(Sury.string),
       categoryId: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Products", schema)).toEqual([
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "Products", schema)).toEqual([
       "productId",
       "convention"
     ]);
@@ -120,7 +129,7 @@ globalThis.describe("resolveKeyField — the ladder", () => {
       categoryId: s.m(Sury.string),
       ownerId: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Categories", schema)).toEqual([
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "Categories", schema)).toEqual([
       "categoryId",
       "convention"
     ]);
@@ -130,53 +139,94 @@ globalThis.describe("resolveKeyField — the ladder", () => {
       productId: s.m(Sury.string),
       categoryId: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("ProductDemand", schema)).toEqual(undefined);
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "ProductDemand", schema)).toEqual(undefined);
   });
   globalThis.test("no `*Id` field at all declines", () => {
     let schema = Sury.$schema(s => ({
       email: s.m(Sury.string),
       address: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Customers", schema)).toEqual(undefined);
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "Customers", schema)).toEqual(undefined);
   });
   globalThis.test("a word merely ending in `id` is not a key", () => {
     let schema = Sury.$schema(s => ({
       paid: s.m(Sury.string),
       valid: s.m(Sury.string)
     }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Invoices", schema)).toEqual(undefined);
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByStateField", "Invoices", schema)).toEqual(undefined);
+  });
+});
+
+globalThis.describe("resolveKeyField — a read model is keyed by its envelope", () => {
+  globalThis.test("a lone foreign `*Id` field does not name the key", () => {
+    let schema = Sury.$schema(s => ({
+      customerId: s.m(Sury.string),
+      lifecycle: s.m(Sury.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByEnvelope", "Orders", schema)).toEqual(undefined);
+  });
+  globalThis.test("the convention rung still names it", () => {
+    let schema = Sury.$schema(s => ({
+      orderId: s.m(Sury.string),
+      customerId: s.m(Sury.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByEnvelope", "Orders", schema)).toEqual([
+      "orderId",
+      "convention"
+    ]);
+  });
+  globalThis.test("a field typed as the view's identity is its key", () => {
+    let schema = Sury.$schema(s => ({
+      order: s.m(OrderId.schema),
+      customerId: s.m(CustomerId.schema)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByEnvelope", "Orders", schema)).toEqual([
+      "order",
+      "convention"
+    ]);
+  });
+  globalThis.test("a field named for the view but typed as another identity is not", () => {
+    let schema = Sury.$schema(s => ({
+      orderId: s.m(CustomerId.schema)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("RowKeyedByEnvelope", "Orders", schema)).toEqual(undefined);
+  });
+  globalThis.test("several foreign `*Id` fields are not a gap worth a warning", () => {
+    let schema = Sury.$schema(s => ({
+      productId: s.m(Sury.string),
+      categoryId: s.m(Sury.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("RowKeyedByEnvelope", "ProductDemand", schema))).toEqual(undefined);
   });
 });
 
 globalThis.describe("keyFieldGapMessage — which gap is worth a warning", () => {
+  let gapFor = (entityName, schema) => GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("RowKeyedByStateField", entityName, schema));
   globalThis.test("a second `*Id` field taking the key away is named, with both fields", () => {
     let schema = Sury.$schema(s => ({
       productId: s.m(Sury.string),
       categoryId: s.m(Sury.string)
     }));
-    let message = Stdlib_Option.getOr(GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("ProductDemand", schema)), "");
+    let message = Stdlib_Option.getOr(gapFor("ProductDemand", schema), "");
     globalThis.expect(message.includes("productId, categoryId")).toBe(true);
     globalThis.expect(message.includes("productDemandId")).toBe(true);
   });
   globalThis.test("a state with no `*Id` field at all is silent, not warned about", () => {
-    let schema = Sury.$schema(s => ({
+    globalThis.expect(gapFor("Customers", Sury.$schema(s => ({
       email: s.m(Sury.string),
       address: s.m(Sury.string)
-    }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("Customers", schema))).toEqual(undefined);
+    })))).toEqual(undefined);
   });
   globalThis.test("a resolved key says nothing", () => {
-    let schema = Sury.$schema(s => ({
+    globalThis.expect(gapFor("Orders", Sury.$schema(s => ({
       orderId: s.m(Sury.string)
-    }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("Orders", schema))).toEqual(undefined);
+    })))).toEqual(undefined);
   });
   globalThis.test("an @id-less view whose name picks one of its `*Id` fields is fine", () => {
-    let schema = Sury.$schema(s => ({
+    globalThis.expect(gapFor("Products", Sury.$schema(s => ({
       productId: s.m(Sury.string),
       categoryId: s.m(Sury.string)
-    }));
-    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.keyFieldGapMessage(GraphQL_FragmentGenerator$ReventlessCore.classifyKeyField("Products", schema))).toEqual(undefined);
+    })))).toEqual(undefined);
   });
 });
 
@@ -190,6 +240,15 @@ globalThis.describe("deriveServerCapability — inferred keys reach the SDL surf
     globalThis.expect(c.filterFields.map(f => f.name)).toEqual(["orderId"]);
     globalThis.expect(c.sortFields).toEqual(["orderId"]);
   });
+  globalThis.test("a lone foreign `*Id` field stays filterable and sortable", () => {
+    let schema = Sury.$schema(s => ({
+      customerId: s.m(Sury.string),
+      lifecycle: s.m(Sury.string)
+    }));
+    let c = GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Orders", schema);
+    globalThis.expect(c.filterFields.map(f => f.name)).toEqual(["customerId"]);
+    globalThis.expect(c.sortFields).toEqual(["customerId"]);
+  });
   globalThis.test("an unresolvable key still yields nothing — the old behaviour, now narrowed", () => {
     let schema = Sury.$schema(s => ({
       email: s.m(Sury.string)
@@ -668,6 +727,8 @@ globalThis.describe("@resolves / @resolvesMany reach the SDL", () => {
 });
 
 export {
+  OrderId,
+  CustomerId,
   OrderSliceCmd,
   mutationFor,
   GeocodeItem,
@@ -680,4 +741,4 @@ export {
   refDoorFragment,
   ResolvedFields,
 }
-/* commandSchema Not a pure module */
+/* OrderId Not a pure module */

package/tests/api/IdentitySemanticTest.res

@@ -0,0 +1,77 @@
+// An identity-typed field is an id whatever it is called: `buyer: CustomerId.t`
+// must reach the SDL as `ID!` and carry its key on the JSON Schema, or a field
+// that is neither tagged nor referenced loses its id-ness on the wire.
+
+open JestGlobals
+
+module OrderId = Reventless.Id.Make({
+  let key = "orderId"
+})
+module CustomerId = Reventless.Id.Make({
+  let key = "customerId"
+})
+
+@schema
+type order = {
+  buyer: CustomerId.t,
+  previous: option<OrderId.t>,
+  related: array<OrderId.t>,
+  note: string,
+}
+
+let property = (json: JSON.t, name: string): option<JSON.t> =>
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get("properties"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(p => p->Dict.get(name))
+
+let key = (json: option<JSON.t>, name: string): option<JSON.t> =>
+  json->Option.flatMap(JSON.Decode.object)->Option.flatMap(o => o->Dict.get(name))
+
+describe("the identity semantic on the JSON Schema", () => {
+  let json = SuryToJsonSchema.deriveObjectSchema(orderSchema->S.castToUnknown)
+
+  testSync("names the semantic and its key", () => {
+    let buyer = json->property("buyer")
+    expect(buyer->key("x-reventless-semantic"))->toEqual(Some(JSON.Encode.string("identity")))
+    expect(buyer->key("x-reventless-semantic-target"))->toEqual(
+      Some(JSON.Encode.object(Dict.fromArray([("key", JSON.Encode.string("customerId"))]))),
+    )
+  })
+
+  testSync("reaches an array's elements", () =>
+    expect(
+      json
+      ->property("related")
+      ->key("items")
+      ->key("x-reventless-semantic-target")
+      ->key("key"),
+    )->toEqual(Some(JSON.Encode.string("orderId")))
+  )
+
+  testSync("leaves a plain string alone", () =>
+    expect(json->property("note")->key("x-reventless-semantic"))->toEqual(None)
+  )
+})
+
+describe("the identity semantic in the SDL", () => {
+  let sdl =
+    GraphQL_FragmentGenerator.deriveObjectTypeWithNested(
+      ~typeName="Ordering_Order",
+      ~includeIdParam=false,
+      orderSchema->S.castToUnknown,
+    )->Array.join("\n")
+
+  testSync("an identity field not named `*Id` is an ID", () =>
+    expect(sdl->String.includes("buyer: ID!"))->toBe(true)
+  )
+
+  testSync("an optional identity keeps its optionality", () =>
+    expect(sdl->String.includes("previous: ID\n"))->toBe(true)
+  )
+
+  testSync("an array of identities is a list of IDs", () =>
+    expect(sdl->String.includes("related: [ID!]!"))->toBe(true)
+  )
+})

package/tests/api/IdentitySemanticTest.res.mjs

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+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 SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let OrderId = Id$Reventless.Make({
+  key: "orderId"
+});
+
+let CustomerId = Id$Reventless.Make({
+  key: "customerId"
+});
+
+let orderSchema = Sury.$schema(s => ({
+  buyer: s.m(CustomerId.schema),
+  previous: s.m(Sury.$option(OrderId.schema)),
+  related: s.m(Sury.array(OrderId.schema)),
+  note: s.m(Sury.string)
+}));
+
+function property(json, name) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["properties"]), Stdlib_JSON.Decode.object), p => p[name]);
+}
+
+function key(json, name) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(json, Stdlib_JSON.Decode.object), o => o[name]);
+}
+
+globalThis.describe("the identity semantic on the JSON Schema", () => {
+  let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, orderSchema);
+  globalThis.test("names the semantic and its key", () => {
+    let buyer = property(json, "buyer");
+    globalThis.expect(key(buyer, "x-reventless-semantic")).toEqual("identity");
+    globalThis.expect(key(buyer, "x-reventless-semantic-target")).toEqual(Object.fromEntries([[
+        "key",
+        "customerId"
+      ]]));
+  });
+  globalThis.test("reaches an array's elements", () => {
+    globalThis.expect(key(key(key(property(json, "related"), "items"), "x-reventless-semantic-target"), "key")).toEqual("orderId");
+  });
+  globalThis.test("leaves a plain string alone", () => {
+    globalThis.expect(key(property(json, "note"), "x-reventless-semantic")).toEqual(undefined);
+  });
+});
+
+globalThis.describe("the identity semantic in the SDL", () => {
+  let sdl = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested("Ordering_Order", undefined, false, undefined, orderSchema).join("\n");
+  globalThis.test("an identity field not named `*Id` is an ID", () => {
+    globalThis.expect(sdl.includes("buyer: ID!")).toBe(true);
+  });
+  globalThis.test("an optional identity keeps its optionality", () => {
+    globalThis.expect(sdl.includes("previous: ID\n")).toBe(true);
+  });
+  globalThis.test("an array of identities is a list of IDs", () => {
+    globalThis.expect(sdl.includes("related: [ID!]!")).toBe(true);
+  });
+});
+
+export {
+  OrderId,
+  CustomerId,
+  orderSchema,
+  property,
+  key,
+}
+/* OrderId Not a pure module */

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,99 @@
+// 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, 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, 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)
+  })
+
+  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")], []))
+  })
+})

package/tests/plugin/IdentityReferenceTest.res.mjs

@@ -0,0 +1,169 @@
+// 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, 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, 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"]
+      ]
+    ], 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"
+        ]
+      ]
+    ], 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"]
+      ]], 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("an untyped field is left to its name, as before", () => {
+    let match = refsOf([[
+        "customerId",
+        ["Customers"]
+      ]], 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"]
+      ]
+    ], 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"
+        ]
+      ]], chosen);
+    globalThis.expect([
+      match[0],
+      match[1]
+    ]).toEqual([
+      [[
+          "buyer",
+          "Customers"
+        ]],
+      []
+    ]);
+  });
+});
+
+export {
+  ProductId,
+  CustomerId,
+  refsOf,
+  order,
+}
+/* ProductId Not a pure module */