@reventlessdev/trait-address-geocoding 1.0.0-alpha.5 → 1.0.0-alpha.51

package/README.md

@@ -19,7 +19,7 @@ Most of this graft is not emitted at all. The four facts and the two `@noApi` re
 commands are real constructors the host **splices** — `...AddressGeocoding.events` and
 `...AddressGeocoding.reportCommands` — so the compiler carries them, annotations and
 schema included. The emitter writes the outbound slice, which the host does not have
-yet, and prints the arms that belong inside the aggregate, its behavior and the
+yet, and prints the arms that belong inside the aggregate, its decision and the
 projection: those interleave with the host's own state machine, and placing an arm in
 an ordered `switch` is an AST operation a text splice gets silently wrong.
 
@@ -54,7 +54,7 @@ pnpm exec graft-trait @reventlessdev/trait-address-geocoding \
    the suite below needs no hand-written file — and prints three patches.
 
 2. Paste the three patches. The aggregate's is two spread lines plus the arms for
-   `commandTransition`; the behavior's is the state fields and the `evolve` / `decide`
+   `commandTransition`; the decision's is the state fields and the `evolve` / `decide`
    arms; the projection's is the view's `geolocation` field and its arms.
 
    Policy is yours and is not config. Which states an address may change in goes in
@@ -62,7 +62,8 @@ pnpm exec graft-trait @reventlessdev/trait-address-geocoding \
    you declare beside it — the compiler resolves the constructors, the switch is
    exhaustive so it names any spliced command you have not answered for, and every
    arm has to draw on that one lifecycle. Who may send the commands goes in
-   `commandAuthorization` the same way.
+   `@@reventless.authorize`, or in an `authorizationOf` switch on their names for a
+   rule per command.
 
    A host whose subject is not called `address`, or is not a `string`, gets the same
    graft with the constructors spelled out instead of spliced — pass `--subject`, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/trait-address-geocoding",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.51",
   "description": "Address-geocoding domain trait: rules, host contract, conformance suite and emitter for grafting geocoding onto an aggregate",
   "license": "Apache-2.0",
   "files": [
@@ -11,18 +11,18 @@
     "README.md"
   ],
   "dependencies": {
-    "sury": "11.0.0-rc.2",
-    "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.203",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.157",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.77",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.129"
+    "sury": "11.0.0",
+    "sury-ppx": "11.0.0",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.249",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.198",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.170",
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.103"
   },
   "devDependencies": {
-    "rescript": "12.3.0"
+    "rescript": "12.3.1"
   },
   "peerDependencies": {
-    "rescript": "12.3.0"
+    "rescript": "^12.3.1"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/AddressGeocoding.res

@@ -6,10 +6,9 @@ staleness, redelivery, an outage is not a verdict, the stand-down — live in
 host by `AddressGeocoding_Conformance`; the confidence rule stays core's
 (`Reventless.Geocoding`). The spec surface is written by `AddressGeocoding_Scaffold`.
 */
-
 /** Whether the graft reports back into its host. This trait does — the two `@noApi`
     commands — and the runner accepts nothing else yet; the flag is here so a
-    competency that only observes is not mis-modelled as one that writes. */
+    competency that only observes is not mis-modeled as one that writes. */
 type posture = WritesBack | Observes
 
 /**
@@ -139,8 +138,8 @@ module type Binding = {
 
   let posture: posture
 
-  module Spec: ReventlessGwt.Behavior_GWT.AggregateSpec
-  module Behavior: Reventless.Behavior.T with module Spec = Spec
+  module Spec: ReventlessGwt.Decision_GWT.AggregateSpec
+  module Decision: Reventless.Decision.T with module Spec = Spec
 
   /** History leaving the entity active at `subject` with nothing resolved. */
   let created: subject => array<Spec.event>

package/src/AddressGeocoding_Conformance.res

@@ -1,11 +1,3 @@
-/**
-The conformance suite, run by a host against its own graft. `Make(Binding).register()`
-inside a Jest test file registers one `describe` block; every assertion is written
-over the binding, never over a host's constructors.
-*/
-
-// Warning 23 flags the spread in `geocoder` as redundant today; it is there for
-// the day `Capabilities.t` grows a field.
 @@warning("-23")
 
 module Outcome = ReventlessGwt.Outcome
@@ -17,7 +9,7 @@ module Outcome = ReventlessGwt.Outcome
 let suiteName = (host: string) => `${host} conforms to the address-geocoding trait`
 
 module Make = (B: AddressGeocoding.Binding) => {
-  module A = ReventlessGwt.Behavior_GWT.MakeFromAggregate(B.Spec, B.Behavior)
+  module A = ReventlessGwt.Decision_GWT.MakeFromAggregate(B.Spec, B.Decision)
   module S = ReventlessGwt.OutboundTranslation_GWT.Make(B.Slice)
 
   let vienna: Reventless.GeoPoint.t = {lat: 48.2082, lng: 16.3738}
@@ -53,7 +45,9 @@ module Make = (B: AddressGeocoding.Binding) => {
     let triggers =
       B.triggers(B.subjectA)
       ->Array.map(e =>
-        e->Reventless.Message.encode(B.Slice.consumedEventSchema)->Reventless.Message.variantNameOfJson
+        e
+        ->Reventless.Message.encode(B.Slice.consumedEventSchema)
+        ->Reventless.Message.variantNameOfJson
       )
       ->sorted
     // Encoded through the aggregate's own schema, so a stand-down event is a
@@ -124,7 +118,10 @@ module Make = (B: AddressGeocoding.Binding) => {
 
       A.test("a redelivered verdict is a no-op", () =>
         A.givenEvents(
-          Array.concat(B.created(B.subjectA), [B.unresolvable(~subject=B.subjectA, ~reason="no match")]),
+          Array.concat(
+            B.created(B.subjectA),
+            [B.unresolvable(~subject=B.subjectA, ~reason="no match")],
+          ),
         )
         ->A.whenCmd(B.markUnresolvable(~subject=B.subjectA, ~reason="no match"))
         ->A.thenNoEvent
@@ -147,10 +144,12 @@ module Make = (B: AddressGeocoding.Binding) => {
       )
 
       B.triggers(B.subjectA)->Array.forEachWithIndex((trigger, i) =>
-        S.testSync(`trigger ${Int.toString(i + 1)} queues one TODO keyed by entity and subject`, () =>
-          S.givenEvent(trigger)
-          ->S.whenCollect(~sourceId=entityId)
-          ->S.thenTodos([(todoKey(B.subjectA), B.item(~entityId, ~subject=B.subjectA))])
+        S.testSync(
+          `trigger ${Int.toString(i + 1)} queues one TODO keyed by entity and subject`,
+          () =>
+            S.givenEvent(trigger)
+            ->S.whenCollect(~sourceId=entityId)
+            ->S.thenTodos([(todoKey(B.subjectA), B.item(~entityId, ~subject=B.subjectA))]),
         )
       )
 

package/src/AddressGeocoding_Conformance.res.mjs

@@ -6,7 +6,7 @@ import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Me
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Outcome$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Outcome.res.mjs";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
-import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as Decision_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Decision_GWT.res.mjs";
 import * as OutboundTranslation_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/OutboundTranslation_GWT.res.mjs";
 
 function suiteName(host) {
@@ -14,7 +14,7 @@ function suiteName(host) {
 }
 
 function Make(B) {
-  let A = Behavior_GWT$ReventlessGwt.MakeFromAggregate(B.Spec)(B.Behavior);
+  let A = Decision_GWT$ReventlessGwt.MakeFromAggregate(B.Spec)(B.Decision);
   let S = OutboundTranslation_GWT$ReventlessGwt.Make(B.Slice);
   let vienna = {
     lat: 48.2082,
@@ -28,7 +28,9 @@ function Make(B) {
   let todoKey = subject => entityId + `:` + B.subjectText(subject);
   let geocoder = answer => ({
     geocode: param => Promise.resolve(answer),
-    messaging: Capabilities$Reventless.none.messaging
+    messaging: Capabilities$Reventless.none.messaging,
+    identityProvider: Capabilities$Reventless.none.identityProvider,
+    secrets: Capabilities$Reventless.none.secrets
   });
   let translateWith = answer => ((id, item) => B.translate(id, item, geocoder(answer)));
   let describeCommand = cmd => JSON.stringify(Message$Reventless.encode(cmd, B.Slice.inboundCommandSchema));
@@ -110,23 +112,17 @@ function Make(B) {
           relevance: 0.995
         }]
     })), "a location", B.isLocation));
-    S.test("a no-match completes the TODO with a verdict", undefined, () => thenReports(S.whenTranslateMocked(S.givenTodo(todoKey(B.subjectA), B.item(entityId, B.subjectA)), (id, item) => B.translate(id, item, {
-      geocode: param => Promise.resolve({
-        TAG: "Error",
-        _0: "NoMatch"
-      }),
-      messaging: Capabilities$Reventless.none.messaging
-    })), "a verdict", B.isVerdict));
-    S.test("an outage leaves the TODO pending", undefined, () => S.thenTodoStatus(S.whenTranslateMocked(S.givenTodo(todoKey(B.subjectA), B.item(entityId, B.subjectA)), (id, item) => B.translate(id, item, {
-      geocode: param => Promise.resolve({
-        TAG: "Error",
-        _0: {
-          TAG: "Unavailable",
-          _0: "502"
-        }
-      }),
-      messaging: Capabilities$Reventless.none.messaging
-    })), todoKey(B.subjectA), "Pending"));
+    S.test("a no-match completes the TODO with a verdict", undefined, () => thenReports(S.whenTranslateMocked(S.givenTodo(todoKey(B.subjectA), B.item(entityId, B.subjectA)), (id, item) => B.translate(id, item, geocoder({
+      TAG: "Error",
+      _0: "NoMatch"
+    }))), "a verdict", B.isVerdict));
+    S.test("an outage leaves the TODO pending", undefined, () => S.thenTodoStatus(S.whenTranslateMocked(S.givenTodo(todoKey(B.subjectA), B.item(entityId, B.subjectA)), (id, item) => B.translate(id, item, geocoder({
+      TAG: "Error",
+      _0: {
+        TAG: "Unavailable",
+        _0: "502"
+      }
+    }))), todoKey(B.subjectA), "Pending"));
   });
   return {
     A: A,

package/src/AddressGeocoding_Guards.res

@@ -8,7 +8,6 @@ record in it would make every release that reshapes it a migration — and build
 `resolution` per call from the fields it already holds. What comes back is a
 verdict on one command, which the host names in its own event.
 */
-
 /** The three fields the rules read, as the host holds them. Its invariant, which
     every host arm must preserve: `resolvedFrom` is `None` or equal to `subject`. */
 type resolution = {

package/src/AddressGeocoding_Scaffold.res

@@ -28,7 +28,6 @@ address may be changed in, who may change it, what a host's own commands refuse
 which a trait cannot know. They are config when the host supplies them and absent
 when it does not.
 */
-
 /**
 The names a graft needs, and nothing else.
 
@@ -46,7 +45,6 @@ type config = {
       one of the slice's two triggers, because an entity created with an address
       has never been geocoded. */
   created: string,
-
   /**
   What this host calls the thing being geocoded, lowercase: `"address"`.
 
@@ -58,7 +56,6 @@ type config = {
   spelled out. The emitted patch says which of the two you are getting.
   */
   subject?: string,
-
   /**
   The creation event's payload *beyond* the subject, as declarations:
   `["email: string"]`.
@@ -72,7 +69,6 @@ type config = {
       conformance binding's histories. Omitted ⇒ omitted from the fixtures, which
       only compiles when `createdFields` is omitted too. */
   createdValues?: array<string>,
-
   /** The slice component's name. Defaults to `Geocode<Entity><Subject>`. */
   slice?: string,
   /** The external box the Event Graph draws. Defaults to `"Geocoder"`; a host on
@@ -81,7 +77,6 @@ type config = {
   /** The read model the projection patch is addressed to. Defaults to
       `<Entity>s`. */
   view?: string,
-
   /** Two subjects that differ, for the histories in which the address changes.
       Defaulted when absent — they are test data, not a decision. */
   subjectA?: string,
@@ -186,7 +181,6 @@ let sliceSpec = (c: config): string => {
     ``,
     `// Retries are for a geocoder that is down, not one that has answered.`,
     `let maxRetries = 3`,
-    `let heartbeatInterval = 60`,
     `let targetName = Some("${c.entity}")`,
     ``,
     `// The ${c.entity} aggregate by its Spec.name; an outbound slice could once only`,
@@ -227,8 +221,7 @@ let sliceTranslation = (c: config): string => {
     ", {" ++
     c.entityId ++
     ": sourceId, " ++
-    n.subject ++
-    "})]"
+    n.subject ++ "})]"
   lines([
     `@@reventless.translation`,
     ``,
@@ -297,7 +290,7 @@ let conformanceBinding = (c: config): string => {
     `  let posture = TraitAddressGeocoding.AddressGeocoding.WritesBack`,
     ``,
     `  module Spec = ${c.entity}`,
-    `  module Behavior = ${c.entity}_Behavior`,
+    `  module Decision = ${c.entity}_Decision`,
     ``,
     `  let created = ${n.subject} => [${c.entity}.${createdValue}]`,
     `  let subjectChanged = ${n.subject} => ${c.entity}.${n.updated}({${n.subject}: ${n.subject}})`,
@@ -439,12 +432,12 @@ let aggregatePatch = (c: config): patch => {
   }
 }
 
-// ── The aggregate behavior patch ─────────────────────────────────────────────
+// ── The aggregate decision patch ─────────────────────────────────────────────
 
-let behaviorPatch = (c: config): patch => {
+let decisionPatch = (c: config): patch => {
   let n = namesOf(c)
   {
-    into: `Aggregate/${c.entity}_Behavior.res`,
+    into: `Aggregate/${c.entity}_Decision.res`,
     at: `the state's fields, the \`evolve\` and \`decide\` switches, and two helpers`,
     contents: lines([
       `module Guards = TraitAddressGeocoding.AddressGeocoding_Guards`,
@@ -582,11 +575,11 @@ let emit = (~config: config, ~into: string, ~tests: string): output => {
   {
     files: [
       {
-        path: `${into}/OutboundTranslationSlice/${n.slice}.res`,
+        path: `${into}/OutboundTranslation/${n.slice}.res`,
         contents: sliceSpec(config),
       },
       {
-        path: `${into}/OutboundTranslationSlice/${n.slice}_Translation.res`,
+        path: `${into}/OutboundTranslation/${n.slice}_Translation.res`,
         contents: sliceTranslation(config),
       },
       {
@@ -594,6 +587,6 @@ let emit = (~config: config, ~into: string, ~tests: string): output => {
         contents: conformanceBinding(config),
       },
     ],
-    patches: [aggregatePatch(config), behaviorPatch(config), projectionPatch(config)],
+    patches: [aggregatePatch(config), decisionPatch(config), projectionPatch(config)],
   }
 }

package/src/AddressGeocoding_Scaffold.res.mjs

@@ -79,7 +79,6 @@ function sliceSpec(c) {
     ``,
     `// Retries are for a geocoder that is down, not one that has answered.`,
     `let maxRetries = 3`,
-    `let heartbeatInterval = 60`,
     `let targetName = Some("` + c.entity + `")`,
     ``,
     `// The ` + c.entity + ` aggregate by its Spec.name; an outbound slice could once only`,
@@ -169,7 +168,7 @@ function conformanceBinding(c) {
     `  let posture = TraitAddressGeocoding.AddressGeocoding.WritesBack`,
     ``,
     `  module Spec = ` + c.entity,
-    `  module Behavior = ` + c.entity + `_Behavior`,
+    `  module Decision = ` + c.entity + `_Decision`,
     ``,
     `  let created = ` + n.subject + ` => [` + c.entity + `.` + createdValue + `]`,
     `  let subjectChanged = ` + n.subject + ` => ` + c.entity + `.` + n.updated + `({` + n.subject + `: ` + n.subject + `})`,
@@ -285,10 +284,10 @@ function aggregatePatch(c) {
   };
 }
 
-function behaviorPatch(c) {
+function decisionPatch(c) {
   let n = namesOf(c);
   return {
-    into: `Aggregate/` + c.entity + `_Behavior.res`,
+    into: `Aggregate/` + c.entity + `_Decision.res`,
     at: `the state's fields, the \`evolve\` and \`decide\` switches, and two helpers`,
     contents: [
       `module Guards = TraitAddressGeocoding.AddressGeocoding_Guards`,
@@ -414,11 +413,11 @@ function emit(config, into, tests) {
   return {
     files: [
       {
-        path: into + `/OutboundTranslationSlice/` + n.slice + `.res`,
+        path: into + `/OutboundTranslation/` + n.slice + `.res`,
         contents: sliceSpec(config)
       },
       {
-        path: into + `/OutboundTranslationSlice/` + n.slice + `_Translation.res`,
+        path: into + `/OutboundTranslation/` + n.slice + `_Translation.res`,
         contents: sliceTranslation(config)
       },
       {
@@ -428,7 +427,7 @@ function emit(config, into, tests) {
     ],
     patches: [
       aggregatePatch(config),
-      behaviorPatch(config),
+      decisionPatch(config),
       projectionPatch(config)
     ]
   };
@@ -445,7 +444,7 @@ export {
   conformanceBinding,
   transitionArms,
   aggregatePatch,
-  behaviorPatch,
+  decisionPatch,
   projectionPatch,
   emit,
 }

package/src/AddressGeocoding_Translate.res

@@ -7,7 +7,6 @@ An outage is not a verdict — it comes back `Error`, which leaves the TODO pend
 for another attempt — and once the retries are spent `exhaustedReason` is what the
 host reports instead, by the same command a confident refusal produces.
 */
-
 /** The geocoder arrives as a capability, so the deployment decides what answers. */
 let translate = async (
   ~text: string,