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

package/tests/api/TaggedUnionSchemaTest.res.mjs

@@ -0,0 +1,176 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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 SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
+import * as TaggedUnionFixtures$ReventlessCore from "../fixtures/TaggedUnionFixtures.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+function fragmentFor(returnTypeName, specName, stateSchema) {
+  return GraphQL_FragmentGenerator$ReventlessCore.generate([], [TaggedUnionFixtures$ReventlessCore.queryEntryFor(returnTypeName, specName, stateSchema)]);
+}
+
+function typesOf(fragment) {
+  return GraphQL_Stitcher$ReventlessCore.decode(fragment).types;
+}
+
+function typeDefFor(fragment, needle) {
+  return Stdlib_Option.getOr(GraphQL_Stitcher$ReventlessCore.decode(fragment).types.find(t => t.includes(needle)), "");
+}
+
+globalThis.describe("SchemaType classifies a named union", () => {
+  let shapeOfField = (schema, field) => {
+    let fields = SchemaType$ReventlessCore.fromSuryObject("X", schema);
+    if (fields !== undefined) {
+      return fields[field];
+    }
+  };
+  globalThis.test("arms are keyed by TAG and carry the member type's own name", () => {
+    let other = shapeOfField(TaggedUnionFixtures$ReventlessCore.CustomersSpec.stateSchema, "geolocation");
+    if (typeof other === "object" && other.TAG === "TaggedUnion") {
+      let arms = other._1;
+      globalThis.expect(other._0).toBe("Geolocation");
+      globalThis.expect(arms.map(param => param[0])).toEqual([
+        "Pending",
+        "Located",
+        "Unresolvable"
+      ]);
+      let match = arms.find(param => param[0] === "Located");
+      let exit = 0;
+      if (match !== undefined) {
+        let match$1 = match[1];
+        if (typeof match$1 !== "object") {
+          exit = 2;
+        } else {
+          if (match$1.TAG === "ObjectRef") {
+            globalThis.expect(match$1._0).toBe("GeolocationLocated");
+            globalThis.expect(Object.keys(match$1._1)).toEqual(["point"]);
+            return;
+          }
+          exit = 2;
+        }
+      } else {
+        exit = 2;
+      }
+      if (exit === 2) {
+        globalThis.expect("Located arm").toBe("an ObjectRef");
+        return;
+      }
+    }
+    globalThis.expect(Stdlib_Option.isSome(other) ? "some other shape" : "nothing").toBe("a TaggedUnion");
+  });
+  globalThis.test("an optional union keeps its arms behind Nullable", () => {
+    let match = shapeOfField(TaggedUnionFixtures$ReventlessCore.SightingsSpec.stateSchema, "lastSeen");
+    if (typeof match === "object" && match.TAG === "Nullable") {
+      let match$1 = match._0;
+      if (typeof match$1 === "object" && match$1.TAG === "TaggedUnion") {
+        globalThis.expect([
+          match$1._0,
+          match$1._1.length
+        ]).toEqual([
+          "Geolocation",
+          3
+        ]);
+        return;
+      }
+    }
+    globalThis.expect("lastSeen").toBe("Nullable(TaggedUnion(...))");
+  });
+  globalThis.test("an array of unions keeps its arms behind ArrayOf", () => {
+    let match = shapeOfField(TaggedUnionFixtures$ReventlessCore.SightingsSpec.stateSchema, "history");
+    if (typeof match === "object" && match.TAG === "ArrayOf") {
+      let match$1 = match._0;
+      if (typeof match$1 === "object" && match$1.TAG === "TaggedUnion") {
+        globalThis.expect(match$1._0).toBe("Geolocation");
+        return;
+      }
+    }
+    globalThis.expect("history").toBe("ArrayOf(TaggedUnion(...))");
+  });
+  globalThis.test("an unnamed union is reported by field and by reason", () => {
+    let found = SchemaType$ReventlessCore.unclassifiedUnions(TaggedUnionFixtures$ReventlessCore.UnnamedSpec.stateSchema);
+    if (found.length !== 1) {
+      globalThis.expect(found.length).toBe(1);
+      return;
+    }
+    let match = found[0];
+    globalThis.expect(match.path).toBe("verdict");
+    globalThis.expect(match.reason.includes("no name")).toBe(true);
+  });
+  globalThis.test("a classified union and an enum are not reported", () => {
+    globalThis.expect(SchemaType$ReventlessCore.unclassifiedUnions(TaggedUnionFixtures$ReventlessCore.CustomersSpec.stateSchema).length).toBe(0);
+  });
+});
+
+globalThis.describe("GraphQL_FragmentGenerator emits a union", () => {
+  let fragment = fragmentFor("Ordering_TuCustomer", "TaggedUnionCustomers", TaggedUnionFixtures$ReventlessCore.CustomersSpec.stateSchema);
+  globalThis.test("the field is typed as the union", () => {
+    globalThis.expect(typeDefFor(fragment, "type Ordering_TuCustomer ").includes("geolocation: Geolocation!")).toBe(true);
+  });
+  globalThis.test("the union names one member type per arm", () => {
+    globalThis.expect(typeDefFor(fragment, "union Geolocation")).toBe("union Geolocation = GeolocationPending | GeolocationLocated | GeolocationUnresolvable");
+  });
+  globalThis.test("each member type declares the arm's own fields, and no TAG", () => {
+    let located = typeDefFor(fragment, "type GeolocationLocated ");
+    globalThis.expect(located.includes("point: GeoPoint!")).toBe(true);
+    globalThis.expect(located.includes("TAG")).toBe(false);
+    globalThis.expect(typeDefFor(fragment, "type GeolocationUnresolvable ").includes("reason: String!")).toBe(true);
+  });
+  globalThis.test("a second plugin's copy of the union is byte-identical", () => {
+    let other = fragmentFor("Catalog_TuSighting", "TaggedUnionSightings", TaggedUnionFixtures$ReventlessCore.SightingsSpec.stateSchema);
+    globalThis.expect(typeDefFor(other, "union Geolocation")).toBe(typeDefFor(fragment, "union Geolocation"));
+    globalThis.expect(typeDefFor(other, "type GeolocationLocated ")).toBe(typeDefFor(fragment, "type GeolocationLocated "));
+  });
+  globalThis.test("an optional union is nullable and an array of them is a list", () => {
+    let sightings = fragmentFor("Catalog_TuSighting", "TaggedUnionSightings", TaggedUnionFixtures$ReventlessCore.SightingsSpec.stateSchema);
+    let row = typeDefFor(sightings, "type Catalog_TuSighting ");
+    globalThis.expect(row.includes("lastSeen: Geolocation\n")).toBe(true);
+    globalThis.expect(row.includes("history: [Geolocation!]!")).toBe(true);
+  });
+  globalThis.test("an unnamed union stays a String", () => {
+    let unnamed = fragmentFor("Ordering_TuCase", "TaggedUnionUnnamed", TaggedUnionFixtures$ReventlessCore.UnnamedSpec.stateSchema);
+    globalThis.expect(typeDefFor(unnamed, "type Ordering_TuCase ").includes("verdict: String!")).toBe(true);
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.decode(unnamed).types.some(t => t.startsWith("union "))).toBe(false);
+  });
+});
+
+function objAt(json, key) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[key]);
+}
+
+globalThis.describe("SuryToJsonSchema emits the arms as oneOf", () => {
+  let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(TaggedUnionFixtures$ReventlessCore.CustomersSpec.stateSchema);
+  let field = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(objAt(json, "properties"), p => Stdlib_JSON.Decode.object(p)), p => p["geolocation"]), null);
+  globalThis.test("the field names the union it is", () => {
+    globalThis.expect(Stdlib_Option.flatMap(objAt(field, "x-reventless-union"), Stdlib_JSON.Decode.string)).toEqual("Geolocation");
+  });
+  globalThis.test("one member per arm, each discriminated by its TAG const", () => {
+    let members = Stdlib_Option.getOr(Stdlib_Option.flatMap(objAt(field, "oneOf"), Stdlib_JSON.Decode.array), []);
+    globalThis.expect(members.length).toBe(3);
+    let tags = Stdlib_Array.filterMap(members, m => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(objAt(m, "properties"), Stdlib_JSON.Decode.object), p => p["TAG"]), t => objAt(t, "const")), Stdlib_JSON.Decode.string));
+    globalThis.expect(tags).toEqual([
+      "Pending",
+      "Located",
+      "Unresolvable"
+    ]);
+  });
+  globalThis.test("each member publishes the GraphQL type it is emitted as", () => {
+    let names = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(objAt(field, "oneOf"), Stdlib_JSON.Decode.array), []), m => Stdlib_Option.flatMap(objAt(m, "x-reventless-union-member"), Stdlib_JSON.Decode.string));
+    globalThis.expect(names).toEqual([
+      "GeolocationPending",
+      "GeolocationLocated",
+      "GeolocationUnresolvable"
+    ]);
+  });
+});
+
+export {
+  fragmentFor,
+  typesOf,
+  typeDefFor,
+  objAt,
+}
+/*  Not a pure module */

package/tests/fixtures/TaggedUnionFixtures.res

@@ -0,0 +1,88 @@
+// A queryable whose state carries a tagged union, which no view in the
+// repository does yet.
+//
+// The mechanism has to be provable before anything adopts it: the SDL emitter,
+// the JSON-Schema walk, the write-time `__typename` stamp and the storage
+// round-trip all assert against this fixture. Pointing those assertions at a real
+// view instead would make the mechanism own that view's breaking retype, its
+// golden refresh and its client pin — which is the coupling the mechanism was cut
+// away from.
+//
+// The union is spelled the way an adopter's would be: every arm an inline record
+// declaring at least one named field of its own, because a bare arm is a string
+// on the wire and an empty one implies a member type with no fields — neither of
+// which GraphQL admits.
+
+@schema
+type geolocation =
+  | Pending({requestedFor: string})
+  | Located({point: Reventless.GeoPoint.t})
+  | Unresolvable({reason: string})
+
+// The name the type is emitted and stamped under. Written here by hand because
+// this fixture is not a `@@reventless.spec` file; in one, the ppx writes exactly
+// this line.
+let geolocationSchema = Reventless.TaggedUnion.named(~name="Geolocation", geolocationSchema)
+
+/** A required union field, the plain case. */
+module CustomersSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TaggedUnionCustomers"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {customerId: string, geolocation: geolocation}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+/** The wrapped cases: an optional union, and an array of them. */
+module SightingsSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TaggedUnionSightings"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {
+    sightingId: string,
+    lastSeen: option<geolocation>,
+    history: array<geolocation>,
+  }
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+/** The same three arms with no name on the schema — the shape the emitter must
+    decline to emit rather than emit under a name it made up. */
+module UnnamedSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TaggedUnionUnnamed"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type verdict =
+    | Approved({by: string})
+    | Rejected({reason: string})
+
+  @schema
+  type state = {caseId: string, verdict: verdict}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+let queryEntryFor = (
+  ~returnTypeName: string,
+  ~specName: string,
+  stateSchema: S.t<'a>,
+): ReventlessInfra.Api.querySchemaEntry => {
+  singleFieldName: returnTypeName,
+  listFieldName: returnTypeName ++ "s",
+  returnTypeName,
+  specName,
+  stateSchema: stateSchema->S.castToUnknown,
+  authorization: None,
+  connectionSpec: true,
+}

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")
+    }
+  })
+})