@reventlessdev/reventless-core 3.0.0-alpha.242 → 3.0.0-alpha.243

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.243 (2026-08-20)
+
+### Features
+
+* **spec:** type a geocoder's answer as one Geolocation value ([157be7a](https://github.com/ReventlessDev/reventless-core/commit/157be7aca4806ae19dba1f58979af13b88dc1821))
+
+
 # 3.0.0-alpha.242 (2026-08-20)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.242",
+  "version": "3.0.0-alpha.243",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -30,15 +30,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.148",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.120",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.147",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.119"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.32"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/tests/api/GeolocationSemanticTest.res

@@ -0,0 +1,108 @@
+open JestGlobals
+open TaggedUnionFixtures
+
+// Two markers ride on one schema; a lost one emits the field as `String` with
+// nothing reporting it. Also pins a negative: the name does NOT come from
+// `semanticCompositeNames`, so an entry there would be inert.
+
+module GeoCustomersSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "SemanticGeolocationCustomers"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {customerId: string, geolocation: Reventless.Geolocation.t}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+let fragment = GraphQL_FragmentGenerator.generate(
+  ~mutationEntries=[],
+  ~queryEntries=[
+    queryEntryFor(
+      ~returnTypeName="SemanticGeoCustomer",
+      ~specName=GeoCustomersSpec.name,
+      GeoCustomersSpec.stateSchema,
+    ),
+  ],
+)
+
+let types = GraphQL_Stitcher.decode(fragment).types
+let typeDefFor = needle => types->Array.find(t => t->String.includes(needle))->Option.getOr("")
+
+describe("the Geolocation semantic reaches the IR as a named union", () => {
+  let field = switch SchemaType.fromSuryObject(
+    ~typeName="SemanticGeoCustomer",
+    GeoCustomersSpec.stateSchema->S.castToUnknown,
+  ) {
+  | Some(fields) => fields->Dict.get("geolocation")
+  | None => None
+  }
+
+  // If the walk stopped at the marker, the field would classify as `Unknown`.
+  testSync("the semantic marker does not swallow the union", () => {
+    switch field {
+    | Some(Semantic({id}, TaggedUnion(name, arms))) =>
+      expect((id, name, arms->Array.length))->toEqual((
+        Reventless.Semantic.Id.geolocation,
+        "Geolocation",
+        3,
+      ))
+    | _ => expect("geolocation")->toBe("Semantic(geolocation, TaggedUnion(Geolocation, 3 arms))")
+    }
+  })
+
+  // A path-composed name would carry the spec's name; this one must not.
+  testSync("the union is named from the schema, not from where it was found", () => {
+    switch field {
+    | Some(Semantic(_, TaggedUnion(name, _))) =>
+      expect(name->String.includes("Customer"))->toBe(false)
+      expect(name)->toBe("Geolocation")
+    | _ => expect("geolocation")->toBe("a named TaggedUnion")
+    }
+  })
+
+  // An entry there would leave this passing — it decides nothing.
+  testSync("semanticCompositeNames does not name this union", () => {
+    expect(SchemaType.canonicalName(Reventless.Semantic.Id.geolocation))->toEqual(None)
+  })
+})
+
+// The breaking half, asserted rather than assumed.
+describe("a row in the pre-union shape does not decode", () => {
+  let oldShapedRow = JSON.parseOrThrow(`{
+    "customerId": "c1",
+    "location": {"lat": 48.2082, "lng": 16.3738},
+    "locationStatus": "Located",
+    "locationNote": null
+  }`)
+
+  testSync("the three-field shape is refused against the union schema", () => {
+    let decodes = switch oldShapedRow->S.parseOrThrow(~to=GeoCustomersSpec.stateSchema) {
+    | _ => true
+    | exception _ => false
+    }
+    expect(decodes)->toBe(false)
+  })
+})
+
+describe("the Geolocation semantic emits its three member types", () => {
+  testSync("the union declaration lists all three members", () => {
+    let union = typeDefFor("union Geolocation")
+    expect(union->String.includes("GeolocationPending"))->toBe(true)
+    expect(union->String.includes("GeolocationLocated"))->toBe(true)
+    expect(union->String.includes("GeolocationUnresolvable"))->toBe(true)
+  })
+
+  // Also says a composite nested in an arm keeps its own canonical name.
+  testSync("the located member carries a GeoPoint", () => {
+    expect(typeDefFor("type GeolocationLocated")->String.includes("GeoPoint"))->toBe(true)
+  })
+
+  testSync("the field is typed as the union", () => {
+    expect(typeDefFor("type SemanticGeoCustomer")->String.includes("geolocation: Geolocation"))->toBe(
+      true,
+    )
+  })
+})

package/tests/api/GeolocationSemanticTest.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Geolocation$Reventless from "@reventlessdev/reventless-spec/src/semantic/Geolocation.res.mjs";
+import * as SchemaType$ReventlessCore from "../../src/components/Api/SchemaType.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as TaggedUnionFixtures$ReventlessCore from "../fixtures/TaggedUnionFixtures.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let name = "SemanticGeolocationCustomers";
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  geolocation: s.m(Geolocation$Reventless.schema)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let GeoCustomersSpec = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [TaggedUnionFixtures$ReventlessCore.queryEntryFor("SemanticGeoCustomer", name, stateSchema)]);
+
+let types = GraphQL_Stitcher$ReventlessCore.decode(fragment).types;
+
+function typeDefFor(needle) {
+  return Stdlib_Option.getOr(types.find(t => t.includes(needle)), "");
+}
+
+globalThis.describe("the Geolocation semantic reaches the IR as a named union", () => {
+  let fields = SchemaType$ReventlessCore.fromSuryObject("SemanticGeoCustomer", stateSchema);
+  let field = fields !== undefined ? fields["geolocation"] : undefined;
+  globalThis.test("the semantic marker does not swallow the union", () => {
+    if (typeof field === "object" && field.TAG === "Semantic") {
+      let match = field._1;
+      if (typeof match === "object" && match.TAG === "TaggedUnion") {
+        globalThis.expect([
+          field._0.id,
+          match._0,
+          match._1.length
+        ]).toEqual([
+          Semantic$Reventless.Id.geolocation,
+          "Geolocation",
+          3
+        ]);
+        return;
+      }
+    }
+    globalThis.expect("geolocation").toBe("Semantic(geolocation, TaggedUnion(Geolocation, 3 arms))");
+  });
+  globalThis.test("the union is named from the schema, not from where it was found", () => {
+    if (typeof field === "object" && field.TAG === "Semantic") {
+      let match = field._1;
+      if (typeof match === "object" && match.TAG === "TaggedUnion") {
+        let name = match._0;
+        globalThis.expect(name.includes("Customer")).toBe(false);
+        globalThis.expect(name).toBe("Geolocation");
+        return;
+      }
+    }
+    globalThis.expect("geolocation").toBe("a named TaggedUnion");
+  });
+  globalThis.test("semanticCompositeNames does not name this union", () => {
+    globalThis.expect(SchemaType$ReventlessCore.canonicalName(Semantic$Reventless.Id.geolocation)).toEqual(undefined);
+  });
+});
+
+globalThis.describe("a row in the pre-union shape does not decode", () => {
+  let oldShapedRow = JSON.parse(`{
+    "customerId": "c1",
+    "location": {"lat": 48.2082, "lng": 16.3738},
+    "locationStatus": "Located",
+    "locationNote": null
+  }`);
+  globalThis.test("the three-field shape is refused against the union schema", () => {
+    let decodes;
+    try {
+      S.parseOrThrow(oldShapedRow, stateSchema);
+      decodes = true;
+    } catch (exn) {
+      decodes = false;
+    }
+    globalThis.expect(decodes).toBe(false);
+  });
+});
+
+globalThis.describe("the Geolocation semantic emits its three member types", () => {
+  globalThis.test("the union declaration lists all three members", () => {
+    let union = typeDefFor("union Geolocation");
+    globalThis.expect(union.includes("GeolocationPending")).toBe(true);
+    globalThis.expect(union.includes("GeolocationLocated")).toBe(true);
+    globalThis.expect(union.includes("GeolocationUnresolvable")).toBe(true);
+  });
+  globalThis.test("the located member carries a GeoPoint", () => {
+    globalThis.expect(typeDefFor("type GeolocationLocated").includes("GeoPoint")).toBe(true);
+  });
+  globalThis.test("the field is typed as the union", () => {
+    globalThis.expect(typeDefFor("type SemanticGeoCustomer").includes("geolocation: Geolocation")).toBe(true);
+  });
+});
+
+export {
+  GeoCustomersSpec,
+  fragment,
+  types,
+  typeDefFor,
+}
+/* moduleUrl Not a pure module */