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

package/tests/fixtures/TaggedUnionFixtures.res.mjs

@@ -0,0 +1,117 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
+
+let geolocationSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Pending",
+    requestedFor: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Located",
+    point: s.m(GeoPoint$Reventless.schema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Unresolvable",
+    reason: s.m(Sury.string)
+  }))
+]);
+
+let geolocationSchema$1 = TaggedUnion$Reventless.named("Geolocation", geolocationSchema);
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  geolocation: s.m(geolocationSchema$1)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let CustomersSpec = {
+  Id: undefined,
+  name: "TaggedUnionCustomers",
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let moduleUrl$1 = import.meta.url;
+
+let stateSchema$1 = Sury.$schema(s => ({
+  sightingId: s.m(Sury.string),
+  lastSeen: s.m(Sury.$option(geolocationSchema$1)),
+  history: s.m(Sury.array(geolocationSchema$1))
+}));
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let SightingsSpec = {
+  Id: undefined,
+  name: "TaggedUnionSightings",
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let moduleUrl$2 = import.meta.url;
+
+let verdictSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Approved",
+    by: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Rejected",
+    reason: s.m(Sury.string)
+  }))
+]);
+
+let stateSchema$2 = Sury.$schema(s => ({
+  caseId: s.m(Sury.string),
+  verdict: s.m(verdictSchema)
+}));
+
+let config$2 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let UnnamedSpec = {
+  Id: undefined,
+  name: "TaggedUnionUnnamed",
+  moduleUrl: moduleUrl$2,
+  verdictSchema: verdictSchema,
+  stateSchema: stateSchema$2,
+  config: config$2,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function queryEntryFor(returnTypeName, specName, stateSchema) {
+  return {
+    singleFieldName: returnTypeName,
+    listFieldName: returnTypeName + "s",
+    returnTypeName: returnTypeName,
+    stateSchema: stateSchema,
+    specName: specName,
+    authorization: undefined,
+    connectionSpec: true
+  };
+}
+
+export {
+  geolocationSchema$1 as geolocationSchema,
+  CustomersSpec,
+  SightingsSpec,
+  UnnamedSpec,
+  queryEntryFor,
+}
+/* geolocationSchema Not a pure module */

package/tests/querydb/TaggedUnionStampTest.res

@@ -0,0 +1,163 @@
+open JestGlobals
+open QueryDbFixtures
+open TaggedUnionFixtures
+
+// The write-time `__typename` stamp, and the storage round trip it has to
+// survive. Both AppSync and graphql-js resolve a union member from `__typename`
+// on the value they are handed; the AppSync resolvers hand back the stored item
+// unchanged, and the live change channel carries the row as raw JSON past the
+// typed field entirely. So the stamp lands here, once, and everything downstream
+// reads a row that already says which arm it is.
+
+module Customers = QueryDb_Operations.Make(
+  CustomersSpec,
+  {
+    let jsonOps = mockJsonOps
+  },
+)
+
+module Sightings = QueryDb_Operations.Make(
+  SightingsSpec,
+  {
+    let jsonOps = mockJsonOps
+  },
+)
+
+module Items = QueryDb_Operations.Make(
+  ItemQueryDbSpec,
+  {
+    let jsonOps = mockJsonOps
+  },
+)
+
+let _ = beforeEach(() => reset())
+
+let storedRow = id =>
+  store.contents->Dict.get(id)->Option.getOr([])->Array.get(0)->Option.getOr(JSON.Encode.null)
+
+let field = (json, name) =>
+  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(name))->Option.getOr(JSON.Encode.null)
+
+let string = json => json->JSON.Decode.string
+
+describe("QueryDb_Operations stamps union members", () => {
+  testPromise("the stored value carries __typename beside TAG", async () => {
+    let state: CustomersSpec.state = {
+      customerId: "c-1",
+      geolocation: Located({point: {lat: 48.2082, lng: 16.3738}}),
+    }
+    let _ = await Customers.save("c-1", state, Init, None)
+    let geo = storedRow("c-1")->field("geolocation")
+    expect(geo->field("TAG")->string)->toEqual(Some("Located"))
+    expect(geo->field("__typename")->string)->toEqual(Some("GeolocationLocated"))
+  })
+
+  testPromise("every arm is stamped as the member type it is", async () => {
+    let _ = await Customers.save(
+      "c-2",
+      {customerId: "c-2", geolocation: Pending({requestedFor: "1 High St"})},
+      Init,
+      None,
+    )
+    let _ = await Customers.save(
+      "c-3",
+      {customerId: "c-3", geolocation: Unresolvable({reason: "ambiguous"})},
+      Init,
+      None,
+    )
+    expect(storedRow("c-2")->field("geolocation")->field("__typename")->string)->toEqual(
+      Some("GeolocationPending"),
+    )
+    expect(storedRow("c-3")->field("geolocation")->field("__typename")->string)->toEqual(
+      Some("GeolocationUnresolvable"),
+    )
+  })
+
+  testPromise("an optional union and an array of them are stamped too", async () => {
+    let state: SightingsSpec.state = {
+      sightingId: "s-1",
+      lastSeen: Some(Located({point: {lat: 1.0, lng: 2.0}})),
+      history: [Pending({requestedFor: "somewhere"}), Unresolvable({reason: "gone"})],
+    }
+    let _ = await Sightings.save("s-1", state, Init, None)
+    let row = storedRow("s-1")
+    expect(row->field("lastSeen")->field("__typename")->string)->toEqual(
+      Some("GeolocationLocated"),
+    )
+    let history = row->field("history")->JSON.Decode.array->Option.getOr([])
+    expect(history->Array.map(h => h->field("__typename")->string))->toEqual([
+      Some("GeolocationPending"),
+      Some("GeolocationUnresolvable"),
+    ])
+  })
+
+  testPromise("an absent optional union leaves nothing behind", async () => {
+    let _ = await Sightings.save(
+      "s-2",
+      {sightingId: "s-2", lastSeen: None, history: []},
+      Init,
+      None,
+    )
+    expect(storedRow("s-2")->field("lastSeen"))->toEqual(JSON.Encode.null)
+  })
+
+  // What keeps this releasable ahead of any adopter: a view with no union field
+  // is walked and written exactly as it was written before the walk existed.
+  testPromise("a view with no union field stores what it always stored", async () => {
+    let _ = await Items.save("item-1", {name: "Widget", count: 5}, Init, None)
+    expect(storedRow("item-1")->JSON.stringify)->toBe(
+      `{"name":"Widget","count":5,"id":"item-1"}`,
+    )
+  })
+
+  testPromise("saveBatch stamps every row", async () => {
+    let batch = [
+      (
+        "c-4",
+        ({customerId: "c-4", geolocation: Located({point: {lat: 0.0, lng: 0.0}})}: CustomersSpec.state),
+        None,
+      ),
+      (
+        "c-5",
+        ({customerId: "c-5", geolocation: Pending({requestedFor: "x"})}: CustomersSpec.state),
+        None,
+      ),
+    ]
+    let _ = await Customers.saveBatch(batch)
+    expect((
+      storedRow("c-4")->field("geolocation")->field("__typename")->string,
+      storedRow("c-5")->field("geolocation")->field("__typename")->string,
+    ))->toEqual((Some("GeolocationLocated"), Some("GeolocationPending")))
+  })
+})
+
+describe("a stamped row decodes back", () => {
+  testPromise("the extra key does not disturb the parse", async () => {
+    let _ = await Customers.save(
+      "c-6",
+      {customerId: "c-6", geolocation: Located({point: {lat: 48.2082, lng: 16.3738}})},
+      Init,
+      None,
+    )
+    let result = await Customers.loadStream("c-6")->Stream.runCollect->Effect.runPromise
+    switch result {
+    | [{geolocation: Located({point})}] => expect((point.lat, point.lng))->toEqual((48.2082, 16.3738))
+    | _ => expect("round trip")->toBe("Located with its point intact")
+    }
+  })
+
+  // A row written before the field existed. Replay is what a read model is for,
+  // so this is a convenience rather than a contract — but it must not throw,
+  // because a single unparseable row otherwise fails the whole page.
+  testPromise("a row written before the union field arrives as the first arm", async () => {
+    store.contents->Dict.set(
+      "c-7",
+      [JSON.Encode.object(Dict.fromArray([("customerId", JSON.Encode.string("c-7"))]))],
+    )
+    let result = await Customers.loadStream("c-7")->Stream.runCollect->Effect.runPromise
+    switch result {
+    | [{geolocation: Pending({requestedFor})}] => expect(requestedFor)->toBe("")
+    | _ => expect("healed row")->toBe("Pending")
+    }
+  })
+})

package/tests/querydb/TaggedUnionStampTest.res.mjs

@@ -0,0 +1,267 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+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 Effect from "effect/Effect";
+import * as QueryDbFixtures$ReventlessCore from "./QueryDbFixtures.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "../../src/components/QueryDb/QueryDb_Operations.res.mjs";
+import * as TaggedUnionFixtures$ReventlessCore from "../fixtures/TaggedUnionFixtures.res.mjs";
+
+let Customers = QueryDb_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: TaggedUnionFixtures$ReventlessCore.CustomersSpec.name,
+  moduleUrl: TaggedUnionFixtures$ReventlessCore.CustomersSpec.moduleUrl,
+  stateSchema: TaggedUnionFixtures$ReventlessCore.CustomersSpec.stateSchema,
+  config: TaggedUnionFixtures$ReventlessCore.CustomersSpec.config,
+  subIdConfig: TaggedUnionFixtures$ReventlessCore.CustomersSpec.subIdConfig,
+  authorization: TaggedUnionFixtures$ReventlessCore.CustomersSpec.authorization,
+  visibility: TaggedUnionFixtures$ReventlessCore.CustomersSpec.visibility
+})({
+  jsonOps: QueryDbFixtures$ReventlessCore.mockJsonOps
+});
+
+let Sightings = QueryDb_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: TaggedUnionFixtures$ReventlessCore.SightingsSpec.name,
+  moduleUrl: TaggedUnionFixtures$ReventlessCore.SightingsSpec.moduleUrl,
+  stateSchema: TaggedUnionFixtures$ReventlessCore.SightingsSpec.stateSchema,
+  config: TaggedUnionFixtures$ReventlessCore.SightingsSpec.config,
+  subIdConfig: TaggedUnionFixtures$ReventlessCore.SightingsSpec.subIdConfig,
+  authorization: TaggedUnionFixtures$ReventlessCore.SightingsSpec.authorization,
+  visibility: TaggedUnionFixtures$ReventlessCore.SightingsSpec.visibility
+})({
+  jsonOps: QueryDbFixtures$ReventlessCore.mockJsonOps
+});
+
+let Items = QueryDb_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.name,
+  moduleUrl: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.moduleUrl,
+  stateSchema: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.stateSchema,
+  config: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.config,
+  subIdConfig: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.subIdConfig,
+  authorization: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.authorization,
+  visibility: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.visibility
+})({
+  jsonOps: QueryDbFixtures$ReventlessCore.mockJsonOps
+});
+
+globalThis.beforeEach(() => QueryDbFixtures$ReventlessCore.reset());
+
+function storedRow(id) {
+  return Stdlib_Option.getOr(Stdlib_Option.getOr(QueryDbFixtures$ReventlessCore.store.contents[id], [])[0], null);
+}
+
+function field(json, name) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[name]), null);
+}
+
+function string(json) {
+  return Stdlib_JSON.Decode.string(json);
+}
+
+globalThis.describe("QueryDb_Operations stamps union members", () => {
+  globalThis.test("the stored value carries __typename beside TAG", async () => {
+    await Customers.save("c-1", {
+      customerId: "c-1",
+      geolocation: {
+        TAG: "Located",
+        point: {
+          lat: 48.2082,
+          lng: 16.3738
+        }
+      }
+    }, "Init", undefined);
+    let geo = field(storedRow("c-1"), "geolocation");
+    globalThis.expect(Stdlib_JSON.Decode.string(field(geo, "TAG"))).toEqual("Located");
+    globalThis.expect(Stdlib_JSON.Decode.string(field(geo, "__typename"))).toEqual("GeolocationLocated");
+  });
+  globalThis.test("every arm is stamped as the member type it is", async () => {
+    await Customers.save("c-2", {
+      customerId: "c-2",
+      geolocation: {
+        TAG: "Pending",
+        requestedFor: "1 High St"
+      }
+    }, "Init", undefined);
+    await Customers.save("c-3", {
+      customerId: "c-3",
+      geolocation: {
+        TAG: "Unresolvable",
+        reason: "ambiguous"
+      }
+    }, "Init", undefined);
+    globalThis.expect(Stdlib_JSON.Decode.string(field(field(storedRow("c-2"), "geolocation"), "__typename"))).toEqual("GeolocationPending");
+    globalThis.expect(Stdlib_JSON.Decode.string(field(field(storedRow("c-3"), "geolocation"), "__typename"))).toEqual("GeolocationUnresolvable");
+  });
+  globalThis.test("an optional union and an array of them are stamped too", async () => {
+    let state_lastSeen = {
+      TAG: "Located",
+      point: {
+        lat: 1.0,
+        lng: 2.0
+      }
+    };
+    let state_history = [
+      {
+        TAG: "Pending",
+        requestedFor: "somewhere"
+      },
+      {
+        TAG: "Unresolvable",
+        reason: "gone"
+      }
+    ];
+    let state = {
+      sightingId: "s-1",
+      lastSeen: state_lastSeen,
+      history: state_history
+    };
+    await Sightings.save("s-1", state, "Init", undefined);
+    let row = storedRow("s-1");
+    globalThis.expect(Stdlib_JSON.Decode.string(field(field(row, "lastSeen"), "__typename"))).toEqual("GeolocationLocated");
+    let history = Stdlib_Option.getOr(Stdlib_JSON.Decode.array(field(row, "history")), []);
+    globalThis.expect(history.map(h => Stdlib_JSON.Decode.string(field(h, "__typename")))).toEqual([
+      "GeolocationPending",
+      "GeolocationUnresolvable"
+    ]);
+  });
+  globalThis.test("an absent optional union leaves nothing behind", async () => {
+    await Sightings.save("s-2", {
+      sightingId: "s-2",
+      lastSeen: undefined,
+      history: []
+    }, "Init", undefined);
+    globalThis.expect(field(storedRow("s-2"), "lastSeen")).toEqual(null);
+  });
+  globalThis.test("a view with no union field stores what it always stored", async () => {
+    await Items.save("item-1", {
+      name: "Widget",
+      count: 5
+    }, "Init", undefined);
+    globalThis.expect(JSON.stringify(storedRow("item-1"))).toBe(`{"name":"Widget","count":5,"id":"item-1"}`);
+  });
+  globalThis.test("saveBatch stamps every row", async () => {
+    let batch = [
+      [
+        "c-4",
+        {
+          customerId: "c-4",
+          geolocation: {
+            TAG: "Located",
+            point: {
+              lat: 0.0,
+              lng: 0.0
+            }
+          }
+        },
+        undefined
+      ],
+      [
+        "c-5",
+        {
+          customerId: "c-5",
+          geolocation: {
+            TAG: "Pending",
+            requestedFor: "x"
+          }
+        },
+        undefined
+      ]
+    ];
+    await Customers.saveBatch(batch);
+    globalThis.expect([
+      Stdlib_JSON.Decode.string(field(field(storedRow("c-4"), "geolocation"), "__typename")),
+      Stdlib_JSON.Decode.string(field(field(storedRow("c-5"), "geolocation"), "__typename"))
+    ]).toEqual([
+      "GeolocationLocated",
+      "GeolocationPending"
+    ]);
+  });
+});
+
+globalThis.describe("a stamped row decodes back", () => {
+  globalThis.test("the extra key does not disturb the parse", async () => {
+    await Customers.save("c-6", {
+      customerId: "c-6",
+      geolocation: {
+        TAG: "Located",
+        point: {
+          lat: 48.2082,
+          lng: 16.3738
+        }
+      }
+    }, "Init", undefined);
+    let result = await Effect.runPromise(Stream.runCollect(Customers.loadStream("c-6")));
+    if (result.length === 1) {
+      let match = result[0];
+      let match$1 = match.geolocation;
+      switch (match$1.TAG) {
+        case "Located" :
+          let point = match$1.point;
+          globalThis.expect([
+            point.lat,
+            point.lng
+          ]).toEqual([
+            48.2082,
+            16.3738
+          ]);
+          return;
+        case "Pending" :
+        case "Unresolvable" :
+          break;
+      }
+    }
+    globalThis.expect("round trip").toBe("Located with its point intact");
+  });
+  globalThis.test("a row written before the union field arrives as the first arm", async () => {
+    QueryDbFixtures$ReventlessCore.store.contents["c-7"] = [Object.fromEntries([[
+          "customerId",
+          "c-7"
+        ]])];
+    let result = await Effect.runPromise(Stream.runCollect(Customers.loadStream("c-7")));
+    if (result.length === 1) {
+      let match = result[0];
+      let match$1 = match.geolocation;
+      switch (match$1.TAG) {
+        case "Pending" :
+          globalThis.expect(match$1.requestedFor).toBe("");
+          return;
+        case "Located" :
+        case "Unresolvable" :
+          break;
+      }
+    }
+    globalThis.expect("healed row").toBe("Pending");
+  });
+});
+
+export {
+  Customers,
+  Sightings,
+  Items,
+  storedRow,
+  field,
+  string,
+}
+/* Customers Not a pure module */