@reventlessdev/trait-address-geocoding 1.0.0-alpha.1

package/src/AddressGeocoding_Scaffold.res.mjs

@@ -0,0 +1,452 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let configSchema = Sury.$schema(s => ({
+  entity: s.m(Sury.string),
+  entityId: s.m(Sury.string),
+  created: s.m(Sury.string),
+  subject: s.m(Sury.$option(Sury.string)),
+  createdFields: s.m(Sury.$option(Sury.array(Sury.string))),
+  createdValues: s.m(Sury.$option(Sury.array(Sury.string))),
+  slice: s.m(Sury.$option(Sury.string)),
+  externalSystem: s.m(Sury.$option(Sury.string)),
+  view: s.m(Sury.$option(Sury.string)),
+  subjectA: s.m(Sury.$option(Sury.string)),
+  subjectB: s.m(Sury.$option(Sury.string))
+}));
+
+function capitalise(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1, s.length);
+}
+
+function namesOf(c) {
+  let subject = Stdlib_Option.getOr(c.subject, "address");
+  let subjectCap = capitalise(subject);
+  return {
+    subject: subject,
+    subjectCap: subjectCap,
+    slice: Stdlib_Option.getOr(c.slice, "Geocode" + c.entity + subjectCap),
+    view: Stdlib_Option.getOr(c.view, c.entity + "s"),
+    updated: subjectCap + "Updated",
+    located: subjectCap + "Located",
+    unresolvable: subjectCap + "Unresolvable",
+    updateCmd: "Update" + subjectCap,
+    suppliedPairCmd: "Set" + subjectCap + "Location",
+    markUnresolvableCmd: "Mark" + subjectCap + "Unresolvable",
+    spreadable: subject === "address"
+  };
+}
+
+function lines(ls) {
+  return ls.join("\n");
+}
+
+function createdPayload(c, n, values) {
+  let extra = values ? Stdlib_Option.getOr(c.createdValues, []) : Stdlib_Option.getOr(c.createdFields, []);
+  let own = values ? n.subject : n.subject + ": string";
+  return extra.concat([own]).join(", ");
+}
+
+function sliceSpec(c) {
+  let n = namesOf(c);
+  return [
+    `// ` + n.slice + `: turns the ` + n.subject + ` into a point and reports back to ` + c.entity + ` —`,
+    `// \`SetLocation\` when sure, \`` + n.markUnresolvableCmd + `\` when not. Neither is`,
+    `// callable from the API.`,
+    `//`,
+    `// Emitted by the address-geocoding trait. Everything below is this host's own`,
+    `// vocabulary, so it is ordinary source from here on — edit it freely.`,
+    ``,
+    `@@reventless.spec`,
+    ``,
+    `// Only the triggers. The event that carries ` + n.subject + ` and point together is`,
+    `// deliberately absent: the slice stands down when a client geocoded for itself,`,
+    `// and the conformance suite asserts that this set is no wider than \`collect\`.`,
+    `@schema`,
+    `type consumedEvent =`,
+    `  | ` + c.created + `({` + createdPayload(c, n, false) + `})`,
+    `  | ` + n.updated + `({` + n.subject + `: string})`,
+    ``,
+    `@schema`,
+    `type outboundItem = {` + c.entityId + `: string, ` + n.subject + `: string}`,
+    ``,
+    `@schema`,
+    `type inboundCommand =`,
+    `  | SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})`,
+    `  | ` + n.markUnresolvableCmd + `({` + n.subject + `: string, reason: 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`,
+    `// read its plugin's DCB event log.`,
+    `let sourceNames = ["` + c.entity + `"]`,
+    ``,
+    `// Drawn as an external box outside this plugin in the Event Graph.`,
+    `let externalSystem = Some("` + Stdlib_Option.getOr(c.externalSystem, "Geocoder") + `")`,
+    ``,
+    `// The trait says what it reaches for; this host only names it. Spelling the`,
+    `// capability here instead would be the one part of the graft nothing checks —`,
+    `// an unprovisioned geocoder answers \`Unavailable\`, the retries run out, and`,
+    `// every ` + n.subject + ` is recorded as permanently unresolvable with no error raised.`,
+    `let capabilityNeeds = TraitAddressGeocoding.AddressGeocoding.capabilityNeeds`,
+    `// The graft's own record of itself. Nothing else survives into a deployed`,
+    `// plugin — the dependency, the spread and the conformance binding are all`,
+    `// source-side — so without this a running estate cannot say where this`,
+    `// component came from.`,
+    `let traits = [TraitAddressGeocoding.AddressGeocoding.declaration]`,
+    ``
+  ].join("\n");
+}
+
+function sliceTranslation(c) {
+  let n = namesOf(c);
+  let key = "`${sourceId}:${" + n.subject + "}`";
+  let collectArm = event => "  | " + event + "({" + n.subject + "}) => [(" + key + ", {" + c.entityId + ": sourceId, " + n.subject + "})]";
+  return [
+    `@@reventless.translation`,
+    ``,
+    `// Keyed by entity *and* ` + n.subject + `: keying by entity alone would make a later`,
+    `// ` + n.subject + ` change look like work already done. \`~sourceId\` is the entity id,`,
+    `// which an aggregate's event payload does not repeat.`,
+    `let collect = (event, ~sourceId) =>`,
+    `  switch event {`,
+    collectArm(c.created),
+    collectArm(n.updated),
+    `  }`,
+    ``,
+    `// Asking the geocoder and reading its answer are the trait's — including the`,
+    `// confidence rule, and the rule that an outage is not a verdict. The two`,
+    `// commands the answer is reported through are this host's.`,
+    `module Geocode = TraitAddressGeocoding.AddressGeocoding_Translate`,
+    ``,
+    `let translate = async (_id, item, ~capabilities: Reventless.Capabilities.t) =>`,
+    `  (`,
+    `    await Geocode.translate(`,
+    `      ~text=item.` + n.subject + `,`,
+    `      ~capabilities,`,
+    `      ~located=(~point, ~resolvedFrom) => SetLocation({location: point, resolvedFrom}),`,
+    `      // A verdict for a human, not a coordinate.`,
+    `      ~unresolvable=(~subject, ~reason) =>`,
+    `        ` + n.markUnresolvableCmd + `({` + n.subject + `: subject, reason}),`,
+    `    )`,
+    `  )->Result.map(command => Some((item.` + c.entityId + `, command)))`,
+    ``,
+    `// The budget is spent and the geocoder never answered. Recording the verdict`,
+    `// beats leaving the TODO pending forever — and it is why the capability must be`,
+    `// declared, since an unprovisioned geocoder reaches here every time.`,
+    `let onExhausted = (_id, item: outboundItem, ~lastError) =>`,
+    `  Some((`,
+    `    item.` + c.entityId + `,`,
+    `    ` + n.markUnresolvableCmd + `({`,
+    `      ` + n.subject + `: item.` + n.subject + `,`,
+    `      reason: Geocode.exhaustedReason(lastError),`,
+    `    }),`,
+    `  ))`,
+    ``
+  ].join("\n");
+}
+
+function conformanceBinding(c) {
+  let n = namesOf(c);
+  let subjectA = Stdlib_Option.getOr(c.subjectA, "Stephansplatz 1, Vienna");
+  let subjectB = Stdlib_Option.getOr(c.subjectB, "Kärntner Straße 1, Vienna");
+  let createdValue = c.created + `({` + createdPayload(c, n, true) + `})`;
+  return [
+    `// The address-geocoding trait's conformance suite, bound to \`` + c.entity + `\`. The`,
+    `// graft rules are asserted by the trait; this file only says what the host calls`,
+    `// things. Emitted whole: every name here is one the graft already declared.`,
+    ``,
+    `module Binding = {`,
+    `  type subject = string`,
+    `  let subjectText = s => s`,
+    `  let subjectA = "` + subjectA + `"`,
+    `  let subjectB = "` + subjectB + `"`,
+    `  let posture = TraitAddressGeocoding.AddressGeocoding.WritesBack`,
+    ``,
+    `  module Spec = ` + c.entity,
+    `  module Behavior = ` + c.entity + `_Behavior`,
+    ``,
+    `  let created = ` + n.subject + ` => [` + c.entity + `.` + createdValue + `]`,
+    `  let subjectChanged = ` + n.subject + ` => ` + c.entity + `.` + n.updated + `({` + n.subject + `: ` + n.subject + `})`,
+    `  let located = (~point, ~resolvedFrom) =>`,
+    `    ` + c.entity + `.LocationSet({location: point, resolvedFrom})`,
+    `  let unresolvable = (~subject, ~reason) =>`,
+    `    ` + c.entity + `.` + n.unresolvable + `({` + n.subject + `: subject, reason})`,
+    `  let setLocation = (~point, ~resolvedFrom) =>`,
+    `    ` + c.entity + `.SetLocation({location: point, resolvedFrom})`,
+    `  let markUnresolvable = (~subject, ~reason) =>`,
+    `    ` + c.entity + `.` + n.markUnresolvableCmd + `({` + n.subject + `: subject, reason})`,
+    ``,
+    `  module Slice = {`,
+    `    include ` + n.slice,
+    `    let collect = ` + n.slice + `_Translation.collect`,
+    `  }`,
+    `  let translate = ` + n.slice + `_Translation.translate`,
+    `  let item = (~entityId, ~subject) => {`,
+    `    ` + n.slice + `.` + c.entityId + `: entityId,`,
+    `    ` + n.subject + `: subject,`,
+    `  }`,
+    `  // Every event type the slice consumes appears here — the consumed set may`,
+    `  // not be wider than its triggers, and the suite checks exactly that.`,
+    `  let triggers = ` + n.subject + ` => [`,
+    `    ` + n.slice + `.` + createdValue + `,`,
+    `    ` + n.slice + `.` + n.updated + `({` + n.subject + `: ` + n.subject + `}),`,
+    `  ]`,
+    `  // The stand-down, as a real constructor rather than a type name: a`,
+    `  // misspelled name would pass the assertion for the wrong reason.`,
+    `  let standsDownOn = [`,
+    `    ` + c.entity + `.` + n.located + `({` + n.subject + `: subjectA, location: {lat: 0.0, lng: 0.0}}),`,
+    `  ]`,
+    `  let isLocation = (cmd: ` + n.slice + `.inboundCommand) =>`,
+    `    switch cmd {`,
+    `    | SetLocation(_) => true`,
+    `    | ` + n.markUnresolvableCmd + `(_) => false`,
+    `    }`,
+    `  let isVerdict = (cmd: ` + n.slice + `.inboundCommand) => !isLocation(cmd)`,
+    `}`,
+    ``,
+    `module Conformance = TraitAddressGeocoding.AddressGeocoding_Conformance.Make(Binding)`,
+    ``,
+    `Conformance.register()`,
+    ``
+  ].join("\n");
+}
+
+function transitionArms(c) {
+  let n = namesOf(c);
+  return [
+    `// The switch is exhaustive, so these four arms are not optional — the`,
+    `// compiler will name whichever you leave out.`,
+    `| SetLocation(_) | ` + n.markUnresolvableCmd + `(_) => Unrestricted`,
+    `// TODO(graft): the states this host allows an ` + n.subject + ` change in, as`,
+    `// constructors of the linked view's lifecycle enum — the compiler resolves`,
+    `// them, so a misspelling is a build error rather than a dead menu entry.`,
+    `//`,
+    `//   type lifecycleState = ` + n.view + `.<lifecycle>`,
+    `//`,
+    `//   | ` + n.updateCmd + `(_) | ` + n.suppliedPairCmd + `(_) => Guards([` + n.view + `.<State>])`
+  ];
+}
+
+function aggregatePatch(c) {
+  let n = namesOf(c);
+  let commandArms = n.spreadable ? [
+      `  // The two public ` + n.subject + ` commands, spliced from the trait. Their`,
+      `  // lifecycle guard lives in \`commandTransition\` below, not on the`,
+      `  // constructors — which is what lets the trait own them at all.`,
+      `  | ...TraitAddressGeocoding.AddressGeocoding.addressCommands`,
+      `  // The two the slice reports through, likewise spliced. Both are \`@noApi\`,`,
+      `  // and the exclusion is recorded on each member, so it survives the spread`,
+      `  // and neither is published.`,
+      `  | ...TraitAddressGeocoding.AddressGeocoding.reportCommands`
+    ] : [
+      `  // Spelled out rather than spliced: this host calls the subject`,
+      `  // "` + n.subject + `", and a spread cannot rename what it splices.`,
+      `  | ` + n.updateCmd + `({` + n.subject + `: string})`,
+      `  | ` + n.suppliedPairCmd + `({` + n.subject + `: string, location: Reventless.GeoPoint.t})`,
+      `  // Deliberately unguarded — legal in every state, \`Ok([])\` on a retired`,
+      `  // entity, so an in-flight answer never parks a TODO row forever.`,
+      `  | @noApi SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})`,
+      `  | @noApi ` + n.markUnresolvableCmd + `({` + n.subject + `: string, reason: string})`
+    ];
+  let eventArms = n.spreadable ? [
+      `  // The graft's four facts, spliced from the trait: \`` + n.updated + `\`,`,
+      `  // \`LocationSet\`, \`` + n.located + `\`, \`` + n.unresolvable + `\`. They are matched`,
+      `  // unqualified in \`evolve\` and in the projections, and sury splices the schema`,
+      `  // flat, so the wire format is what hand-written arms produced.`,
+      `  | ...TraitAddressGeocoding.AddressGeocoding.events`
+    ] : [
+      `  | ` + n.updated + `({` + n.subject + `: string})`,
+      `  // \`resolvedFrom\` is provenance, not the ` + n.subject + ` of record; it is what`,
+      `  // makes "is the pin still current?" decidable.`,
+      `  | LocationSet({location: Reventless.GeoPoint.t, resolvedFrom: string})`,
+      `  // Both halves from a client. Not \`` + n.updated + `\` + \`LocationSet\`: the slice`,
+      `  // collects the former, and this event is not in its consumed set — the`,
+      `  // stand-down.`,
+      `  | ` + n.located + `({` + n.subject + `: string, location: Reventless.GeoPoint.t})`,
+      `  // A fact, not an absence: \`location: None\` already means "not looked up yet".`,
+      `  | ` + n.unresolvable + `({` + n.subject + `: string, reason: string})`
+    ];
+  return {
+    into: `Aggregate/` + c.entity + `.res`,
+    at: n.spreadable ? `\`type command\` and \`type event\` — two spread lines and two commands` : `\`type command\` and \`type event\` — spelled out, because the subject is not \`address\``,
+    contents: [`// --- type command ------------------------------------------------------------`].concat(commandArms, [
+      ``,
+      `// --- type event --------------------------------------------------------------`
+    ], eventArms, [
+      ``,
+      `// --- commandTransition -------------------------------------------------------`
+    ], transitionArms(c)).join("\n")
+  };
+}
+
+function behaviorPatch(c) {
+  let n = namesOf(c);
+  return {
+    into: `Aggregate/` + c.entity + `_Behavior.res`,
+    at: `the state's fields, the \`evolve\` and \`decide\` switches, and two helpers`,
+    contents: [
+      `module Guards = TraitAddressGeocoding.AddressGeocoding_Guards`,
+      ``,
+      `// --- state fields ------------------------------------------------------------`,
+      `// Two fields, because there are three states and one \`option\` holds two: never`,
+      `// asked, a point found, and the ` + n.subject + ` tried and found wanting (a`,
+      `// resolved-from, no point). Host-owned rather than a trait record: an`,
+      `// aggregate's state is snapshotted, so a trait release that reshaped it would`,
+      `// be a migration. Invariant every arm preserves: \`locationResolvedFrom\` is`,
+      `// \`None\` or equal to \`` + n.subject + `\`.`,
+      `      location: option<Reventless.GeoPoint.t>,`,
+      `      locationResolvedFrom: option<string>,`,
+      ``,
+      `// --- evolve arms -------------------------------------------------------------`,
+      `  // A new ` + n.subject + ` invalidates what was known; dropping both puts the row`,
+      `  // back in front of the slice.`,
+      `  | (Active(s), ` + n.updated + `({` + n.subject + `})) =>`,
+      `    Active({...s, ` + n.subject + `, location: None, locationResolvedFrom: None})`,
+      `  | (Active(s), LocationSet({location, resolvedFrom})) =>`,
+      `    Active({...s, location: Some(location), locationResolvedFrom: Some(resolvedFrom)})`,
+      `  // The caller supplied the pair, so there is nothing left to resolve.`,
+      `  | (Active(s), ` + n.located + `({` + n.subject + `, location})) =>`,
+      `    Active({`,
+      `      ...s,`,
+      `      ` + n.subject + `,`,
+      `      location: Some(location),`,
+      `      locationResolvedFrom: Some(` + n.subject + `),`,
+      `    })`,
+      `  // Recording the ` + n.subject + ` keeps the slice from handing it back for another round.`,
+      `  | (Active(s), ` + n.unresolvable + `({` + n.subject + `})) =>`,
+      `    Active({...s, location: None, locationResolvedFrom: Some(` + n.subject + `)})`,
+      ``,
+      `// --- the trait's view, and what it decides ------------------------------------`,
+      `// Built per call, because the inline record of \`Active\` cannot escape its`,
+      `// constructor.`,
+      `let resolution = (` + n.subject + `, location, locationResolvedFrom): Guards.resolution => {`,
+      `  subject: ` + n.subject + `,`,
+      `  location,`,
+      `  resolvedFrom: locationResolvedFrom,`,
+      `}`,
+      ``,
+      `let appended = (verdict, event) =>`,
+      `  switch verdict {`,
+      `  | Guards.Append => Ok([event])`,
+      `  | Guards.Ignore => Ok([])`,
+      `  }`,
+      ``,
+      `// --- decide arms -------------------------------------------------------------`,
+      `  | (Active(s), ` + n.updateCmd + `({` + n.subject + `})) =>`,
+      `    Guards.onSubjectUpdate(`,
+      `      resolution(s.` + n.subject + `, s.location, s.locationResolvedFrom),`,
+      `      ~subject=` + n.subject + `,`,
+      `    )->appended(` + n.updated + `({` + n.subject + `: ` + n.subject + `}))`,
+      ``,
+      `  | (Active(s), ` + n.suppliedPairCmd + `({` + n.subject + `, location})) =>`,
+      `    Guards.onSuppliedPair(`,
+      `      resolution(s.` + n.subject + `, s.location, s.locationResolvedFrom),`,
+      `      ~subject=` + n.subject + `,`,
+      `      ~location,`,
+      `    )->appended(` + n.located + `({` + n.subject + `, location}))`,
+      ``,
+      `  | (Active(s), SetLocation({location, resolvedFrom})) =>`,
+      `    Guards.onLocationReport(`,
+      `      resolution(s.` + n.subject + `, s.location, s.locationResolvedFrom),`,
+      `      ~location,`,
+      `      ~resolvedFrom,`,
+      `    )->appended(LocationSet({location, resolvedFrom}))`,
+      ``,
+      `  | (Active(s), ` + n.markUnresolvableCmd + `({` + n.subject + `, reason})) =>`,
+      `    Guards.onUnresolvableReport(`,
+      `      resolution(s.` + n.subject + `, s.location, s.locationResolvedFrom),`,
+      `      ~subject=` + n.subject + `,`,
+      `    )->appended(` + n.unresolvable + `({` + n.subject + `, reason}))`,
+      ``,
+      `  // TODO(graft): the two report commands must be legal in every state this`,
+      `  // host has. On a retired entity, swallow rather than refuse — an in-flight`,
+      `  // answer landing after retirement would otherwise park a TODO row forever.`,
+      `  //`,
+      `  //   | (Retired(_), SetLocation(_)) => Ok([])`,
+      `  //   | (Retired(_), ` + n.markUnresolvableCmd + `(_)) => Ok([])`,
+      ``
+    ].join("\n")
+  };
+}
+
+function projectionPatch(c) {
+  let n = namesOf(c);
+  return {
+    into: `ReadModelStream/` + n.view + `_Projections.res`,
+    at: `the projection's \`switch\`, and one field on \`` + n.view + `\`'s state`,
+    contents: [
+      `// On the view's state, one field:`,
+      `//`,
+      `//   geolocation: Reventless.Geolocation.t,`,
+      `//`,
+      `// Three arms rather than \`option<GeoPoint.t>\`: \`Pending\` carries the ` + n.subject,
+      `// asked about, so a stale answer is detectable from the row alone.`,
+      ``,
+      `// On the creation arm's default state:`,
+      `//   geolocation: Pending({requestedFor: ` + n.subject + `})`,
+      ``,
+      `// A new ` + n.subject + ` invalidates the pin: back to Pending for the new one.`,
+      `| ` + n.updated + `({` + n.subject + `}) =>`,
+      `  Update(id, state => {`,
+      `    ...state,`,
+      `    ` + n.subject + `,`,
+      `    geolocation: Pending({requestedFor: ` + n.subject + `}),`,
+      `  })`,
+      `| LocationSet({location}) =>`,
+      `  Update(id, state => {...state, geolocation: Located({point: location})})`,
+      `// The client supplied the pair, so no geocode is owed.`,
+      `| ` + n.located + `({` + n.subject + `, location}) =>`,
+      `  Update(id, state => {...state, ` + n.subject + `, geolocation: Located({point: location})})`,
+      `| ` + n.unresolvable + `({reason: why}) =>`,
+      `  Update(id, state => {...state, geolocation: Unresolvable({reason: why})})`
+    ].join("\n")
+  };
+}
+
+function emit(config, into, tests) {
+  let n = namesOf(config);
+  return {
+    files: [
+      {
+        path: into + `/OutboundTranslationSlice/` + n.slice + `.res`,
+        contents: sliceSpec(config)
+      },
+      {
+        path: into + `/OutboundTranslationSlice/` + n.slice + `_Translation.res`,
+        contents: sliceTranslation(config)
+      },
+      {
+        path: tests + `/AddressGeocodingConformance_GWT.res`,
+        contents: conformanceBinding(config)
+      }
+    ],
+    patches: [
+      aggregatePatch(config),
+      behaviorPatch(config),
+      projectionPatch(config)
+    ]
+  };
+}
+
+export {
+  configSchema,
+  capitalise,
+  namesOf,
+  lines,
+  createdPayload,
+  sliceSpec,
+  sliceTranslation,
+  conformanceBinding,
+  transitionArms,
+  aggregatePatch,
+  behaviorPatch,
+  projectionPatch,
+  emit,
+}
+/* configSchema Not a pure module */

package/src/AddressGeocoding_Translate.res

@@ -0,0 +1,40 @@
+/**
+The outbound slice's body: ask the geocoder, and turn its answer into one of the
+host's two report commands. The host supplies those as callbacks, so the trait
+never names a constructor.
+
+An outage is not a verdict — it comes back `Error`, which leaves the TODO pending
+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,
+  ~capabilities: Reventless.Capabilities.t,
+  ~located: (~point: Reventless.GeoPoint.t, ~resolvedFrom: string) => 'command,
+  ~unresolvable: (~subject: string, ~reason: string) => 'command,
+): result<'command, string> => {
+  let answer = await capabilities.geocode(~text)
+  switch answer {
+  // Matched only to keep `why`; `ofSearch` refuses this case too and is the rule.
+  | Error(Reventless.Geocoding.Unavailable(why)) => Error(`geocoder unavailable: ${why}`)
+  | _ =>
+    switch Reventless.Geolocation.ofSearch(~requestedFor=text, answer) {
+    | Some(Located({point})) => Ok(located(~point, ~resolvedFrom=text))
+    | Some(Unresolvable({reason})) => Ok(unresolvable(~subject=text, ~reason))
+    | Some(Pending(_)) => Error("unreachable: ofSearch never answers Pending")
+    | None => Error("geocoder unavailable")
+    }
+  }
+}
+
+/**
+Why a spent retry budget is a verdict and not a longer wait: `Pending` means the
+geocoder has not answered *yet*, and once the retries are gone there is no yet.
+*/
+let exhaustedReason = lastError =>
+  switch lastError {
+  | Some(why) => `the geocoder never answered after repeated attempts (${why})`
+  | None => "the geocoder never answered after repeated attempts"
+  }

package/src/AddressGeocoding_Translate.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Geolocation$Reventless from "@reventlessdev/reventless-spec/src/semantic/Geolocation.res.mjs";
+
+async function translate(text, capabilities, located, unresolvable) {
+  let answer = await capabilities.geocode(text);
+  if (answer.TAG !== "Ok") {
+    let why = answer._0;
+    if (typeof why === "object") {
+      return {
+        TAG: "Error",
+        _0: `geocoder unavailable: ` + why._0
+      };
+    }
+  }
+  let match = Geolocation$Reventless.ofSearch(text, undefined, undefined, answer);
+  if (match === undefined) {
+    return {
+      TAG: "Error",
+      _0: "geocoder unavailable"
+    };
+  }
+  switch (match.TAG) {
+    case "Pending" :
+      return {
+        TAG: "Error",
+        _0: "unreachable: ofSearch never answers Pending"
+      };
+    case "Located" :
+      return {
+        TAG: "Ok",
+        _0: located(match.point, text)
+      };
+    case "Unresolvable" :
+      return {
+        TAG: "Ok",
+        _0: unresolvable(text, match.reason)
+      };
+  }
+}
+
+function exhaustedReason(lastError) {
+  if (lastError !== undefined) {
+    return `the geocoder never answered after repeated attempts (` + lastError + `)`;
+  } else {
+    return "the geocoder never answered after repeated attempts";
+  }
+}
+
+export {
+  translate,
+  exhaustedReason,
+}
+/* Geolocation-Reventless Not a pure module */