@reventlessdev/reventless-core 3.0.0-alpha.199 → 3.0.0-alpha.201

package/tests/api/StorageRefFieldsTest.res

@@ -0,0 +1,148 @@
+// What the claim component ever gets to see, decided here.
+//
+// `StorageRefFields.fromEventSchema` is the deploy-time reading of the
+// `@storageRef` declarations that becomes the claimer's entire input: an event
+// variant it does not produce is an event the claimer never reads a record for,
+// and a field it does not list is a ref that never gets claimed — so the object
+// keeps its pending tag and, on a store with expiry enabled, is eventually
+// deleted while something still references it.
+//
+// Which makes the interesting assertions the negative ones: what is *absent*
+// from this output is what silently rots.
+
+open JestGlobals
+
+module Fields = StorageRefFields
+
+// An event union, shaped the way sury encodes a ReScript variant: one object per
+// variant, discriminated by a `TAG` string constant.
+let variant = (~tag: string, fields: array<(string, S.t<unknown>)>): S.t<unknown> =>
+  S.object(s => {
+    let _ = s.field("TAG", S.literal(tag)->S.castToUnknown)
+    fields->Array.forEach(((name, schema)) => {
+      let _ = s.field(name, schema)
+    })
+    ()
+  })->S.castToUnknown
+
+let ref_ = (~plugin: option<string>=?, ~store: string) =>
+  Reventless.StorageRef.forStore(~plugin?, ~store)->S.castToUnknown
+
+describe("StorageRefFields.fromEventSchema", () => {
+  testSync("finds a declared single-valued ref field and qualifies its store", () => {
+    let schema = S.union([variant(~tag="ProductImageChanged", [("imageUrl", ref_(~store="productImages"))])])->S.castToUnknown
+    expect(Fields.fromEventSchema(~plugin="Catalog", schema))->toEqual([
+      {
+        Fields.eventType: "ProductImageChanged",
+        fields: [
+          {Fields.field: "imageUrl", arity: Single, store: "Catalog.productImages"},
+        ],
+      },
+    ])
+  })
+
+  // The annotation's own qualification wins: a field pointing at another
+  // plugin's store must not be re-attributed to the plugin that wrote it, or the
+  // claimer resolves the wrong bucket and refuses the ref as out-of-store.
+  testSync("a qualified declaration keeps the store it names", () => {
+    let schema =
+      S.union([
+        variant(~tag="OrderPhotoAttached", [("photo", ref_(~plugin="Catalog", ~store="productImages"))]),
+      ])->S.castToUnknown
+    expect(
+      Fields.fromEventSchema(~plugin="Ordering", schema)
+      ->Array.flatMap(e => e.fields->Array.map(f => f.store)),
+    )->toEqual(["Catalog.productImages"])
+  })
+
+  // `@storageRef` on an `array<string>` attaches the marker to the ELEMENT, so
+  // reading the field schema directly answers None. The claimer needs the arity
+  // to know whether to read one value or iterate.
+  testSync("finds a multi-valued ref field and records its arity", () => {
+    let schema =
+      S.union([
+        variant(~tag="GalleryReplaced", [("imageUrls", S.array(ref_(~store="productImages"))->S.castToUnknown)]),
+      ])->S.castToUnknown
+    expect(
+      Fields.fromEventSchema(~plugin="Catalog", schema)->Array.flatMap(e => e.fields),
+    )->toEqual([{Fields.field: "imageUrls", arity: Multiple, store: "Catalog.productImages"}])
+  })
+
+  // Narrow input by construction: a platform whose plugins declare no store
+  // provisions no claimer at all, and an event log carrying no declaration is
+  // never subscribed to.
+  testSync("a variant with no declared field is omitted entirely", () => {
+    let schema =
+      S.union([
+        variant(~tag="ProductRenamed", [("name", S.string->S.castToUnknown)]),
+        variant(~tag="ProductImageChanged", [("imageUrl", ref_(~store="productImages"))]),
+      ])->S.castToUnknown
+    expect(Fields.fromEventSchema(~plugin="Catalog", schema)->Array.map(e => e.eventType))->toEqual([
+      "ProductImageChanged",
+    ])
+  })
+
+  testSync("an event schema with no declaration anywhere yields nothing", () => {
+    let schema = S.union([variant(~tag="ProductRenamed", [("name", S.string->S.castToUnknown)])])->S.castToUnknown
+    expect(Fields.fromEventSchema(~plugin="Catalog", schema))->toEqual([])
+  })
+
+  // A string field that merely looks like a ref is not one. Declaration
+  // outranks inference everywhere else in the framework, and this is the reading
+  // that has to agree with `Plugin_Structure`'s — the claimer can only reach a
+  // store the deploy actually provisioned.
+  testSync("an unannotated string field is not treated as a ref", () => {
+    let schema =
+      S.union([variant(~tag="ProductImported", [("imageUrl", S.string->S.castToUnknown)])])->S.castToUnknown
+    expect(Fields.fromEventSchema(~plugin="Catalog", schema))->toEqual([])
+  })
+
+  testSync("a single-variant (non-union) event schema is read the same way", () => {
+    let schema = variant(~tag="ProductImageChanged", [("imageUrl", ref_(~store="productImages"))])
+    expect(Fields.fromEventSchema(~plugin="Catalog", schema)->Array.map(e => e.eventType))->toEqual([
+      "ProductImageChanged",
+    ])
+  })
+})
+
+describe("StorageRefFields.toJson", () => {
+  // The wire form crosses into a Lambda's environment, where the handler decodes
+  // it with plain JSON reads. Both ends are pinned here because a drift is
+  // silent: an unreadable entry is indistinguishable from an absent one, and an
+  // absent one means "nothing to claim".
+  testSync("emits field, arity and store per event type", () => {
+    let entries: array<Fields.eventRefFields> = [
+      {
+        eventType: "ProductImageChanged",
+        fields: [{field: "imageUrl", arity: Single, store: "Catalog.productImages"}],
+      },
+      {
+        eventType: "GalleryReplaced",
+        fields: [{field: "imageUrls", arity: Multiple, store: "Catalog.productImages"}],
+      },
+    ]
+    expect(Fields.toJson(entries)->JSON.stringify)->toBe(
+      `{"ProductImageChanged":[{"field":"imageUrl","arity":"one","store":"Catalog.productImages"}],` ++
+      `"GalleryReplaced":[{"field":"imageUrls","arity":"many","store":"Catalog.productImages"}]}`,
+    )
+  })
+})
+
+describe("StorageRefFields.storesOf", () => {
+  testSync("collects the distinct stores an event log's declarations reach", () => {
+    let entries: array<Fields.eventRefFields> = [
+      {
+        eventType: "A",
+        fields: [{field: "a", arity: Single, store: "Catalog.productImages"}],
+      },
+      {
+        eventType: "B",
+        fields: [
+          {field: "b", arity: Single, store: "Catalog.productImages"},
+          {field: "c", arity: Multiple, store: "Ordering.receipts"},
+        ],
+      },
+    ]
+    expect(Fields.storesOf(entries))->toEqual(["Catalog.productImages", "Ordering.receipts"])
+  })
+})

package/tests/api/StorageRefFieldsTest.res.mjs

@@ -0,0 +1,152 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as StorageRefFields$ReventlessCore from "../../src/components/Api/StorageRefFields.res.mjs";
+
+function variant(tag, fields) {
+  return S.object(s => {
+    s.f("TAG", S.literal(tag));
+    fields.forEach(param => {
+      s.f(param[0], param[1]);
+    });
+  });
+}
+
+let ref_ = StorageRef$Reventless.forStore;
+
+globalThis.describe("StorageRefFields.fromEventSchema", () => {
+  globalThis.test("finds a declared single-valued ref field and qualifies its store", () => {
+    let schema = S.union([variant("ProductImageChanged", [[
+          "imageUrl",
+          StorageRef$Reventless.forStore(undefined, "productImages")
+        ]])]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema)).toEqual([{
+        eventType: "ProductImageChanged",
+        fields: [{
+            field: "imageUrl",
+            arity: "Single",
+            store: "Catalog.productImages"
+          }]
+      }]);
+  });
+  globalThis.test("a qualified declaration keeps the store it names", () => {
+    let schema = S.union([variant("OrderPhotoAttached", [[
+          "photo",
+          StorageRef$Reventless.forStore("Catalog", "productImages")
+        ]])]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Ordering", schema).flatMap(e => e.fields.map(f => f.store))).toEqual(["Catalog.productImages"]);
+  });
+  globalThis.test("finds a multi-valued ref field and records its arity", () => {
+    let schema = S.union([variant("GalleryReplaced", [[
+          "imageUrls",
+          S.array(StorageRef$Reventless.forStore(undefined, "productImages"))
+        ]])]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema).flatMap(e => e.fields)).toEqual([{
+        field: "imageUrls",
+        arity: "Multiple",
+        store: "Catalog.productImages"
+      }]);
+  });
+  globalThis.test("a variant with no declared field is omitted entirely", () => {
+    let schema = S.union([
+      variant("ProductRenamed", [[
+          "name",
+          S.string
+        ]]),
+      variant("ProductImageChanged", [[
+          "imageUrl",
+          StorageRef$Reventless.forStore(undefined, "productImages")
+        ]])
+    ]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema).map(e => e.eventType)).toEqual(["ProductImageChanged"]);
+  });
+  globalThis.test("an event schema with no declaration anywhere yields nothing", () => {
+    let schema = S.union([variant("ProductRenamed", [[
+          "name",
+          S.string
+        ]])]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema)).toEqual([]);
+  });
+  globalThis.test("an unannotated string field is not treated as a ref", () => {
+    let schema = S.union([variant("ProductImported", [[
+          "imageUrl",
+          S.string
+        ]])]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema)).toEqual([]);
+  });
+  globalThis.test("a single-variant (non-union) event schema is read the same way", () => {
+    let schema = variant("ProductImageChanged", [[
+        "imageUrl",
+        StorageRef$Reventless.forStore(undefined, "productImages")
+      ]]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema).map(e => e.eventType)).toEqual(["ProductImageChanged"]);
+  });
+});
+
+globalThis.describe("StorageRefFields.toJson", () => {
+  globalThis.test("emits field, arity and store per event type", () => {
+    let entries = [
+      {
+        eventType: "ProductImageChanged",
+        fields: [{
+            field: "imageUrl",
+            arity: "Single",
+            store: "Catalog.productImages"
+          }]
+      },
+      {
+        eventType: "GalleryReplaced",
+        fields: [{
+            field: "imageUrls",
+            arity: "Multiple",
+            store: "Catalog.productImages"
+          }]
+      }
+    ];
+    globalThis.expect(JSON.stringify(StorageRefFields$ReventlessCore.toJson(entries))).toBe(`{"ProductImageChanged":[{"field":"imageUrl","arity":"one","store":"Catalog.productImages"}],"GalleryReplaced":[{"field":"imageUrls","arity":"many","store":"Catalog.productImages"}]}`);
+  });
+});
+
+globalThis.describe("StorageRefFields.storesOf", () => {
+  globalThis.test("collects the distinct stores an event log's declarations reach", () => {
+    let entries = [
+      {
+        eventType: "A",
+        fields: [{
+            field: "a",
+            arity: "Single",
+            store: "Catalog.productImages"
+          }]
+      },
+      {
+        eventType: "B",
+        fields: [
+          {
+            field: "b",
+            arity: "Single",
+            store: "Catalog.productImages"
+          },
+          {
+            field: "c",
+            arity: "Multiple",
+            store: "Ordering.receipts"
+          }
+        ]
+      }
+    ];
+    globalThis.expect(StorageRefFields$ReventlessCore.storesOf(entries)).toEqual([
+      "Catalog.productImages",
+      "Ordering.receipts"
+    ]);
+  });
+});
+
+let Fields;
+
+export {
+  Fields,
+  variant,
+  ref_,
+}
+/*  Not a pure module */

package/tests/api/SuryToJsonSchemaTest.res

@@ -794,4 +794,50 @@ describe("SuryToJsonSchema:", () => {
       ))
     )
   })
+
+  // The third composite. Its emission matters more than the other two's, because
+  // the reader has been resolving this shape from a *heuristic* since before the
+  // marker existed: an object with numeric `lat`/`lng` sub-properties already
+  // resolves to the geo-point semantic by shape. So the assertions below are what
+  // separate a declaration from a lucky guess — the marker and its `type` source.
+  describe("GeoPoint is an object carrying the geoPoint marker:", () => {
+    let json = SuryToJsonSchema.deriveObjectSchema(
+      S.schema(s =>
+        {
+          "location": s.matches(Reventless.GeoPoint.schema),
+          "lat": s.matches(S.float),
+        }
+      )->S.castToUnknown,
+    )
+    let keyOf = (name, key) => getPropertyOf(json, name)->Option.flatMap(s => getProperty(s, key))
+
+    testSync("the field is an object, not a pair of numbers", () =>
+      expect(keyOf("location", "type"))->toEqual(Some(JSON.Encode.string("object")))
+    )
+
+    testSync("it carries the geoPoint id, sourced from the type", () =>
+      expect((
+        keyOf("location", "x-reventless-semantic"),
+        keyOf("location", "x-reventless-semantic-source"),
+      ))->toEqual((Some(JSON.Encode.string("geoPoint")), Some(JSON.Encode.string("type"))))
+    )
+
+    // The control, and the whole reason the composite exists: a bare `lat` float
+    // is exactly what the flattened pair looked like, and it emits nothing at
+    // all. Everything a map knew about it, it inferred from the name.
+    testSync("a bare lat float emits no semantic", () =>
+      expect((keyOf("lat", "type"), keyOf("lat", "x-reventless-semantic")))->toEqual((
+        Some(JSON.Encode.string("number")),
+        None,
+      ))
+    )
+
+    testSync("both coordinates reach the wire as numbers", () => {
+      let inner = getPropertyOf(json, "location")->Option.getOr(JSON.Encode.null)
+      expect((
+        getPropertyOf(inner, "lat")->Option.flatMap(s => getProperty(s, "type")),
+        getPropertyOf(inner, "lng")->Option.flatMap(s => getProperty(s, "type")),
+      ))->toEqual((Some(JSON.Encode.string("number")), Some(JSON.Encode.string("number"))))
+    })
+  })
 })

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -11,6 +11,7 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as Percent$Reventless from "@reventlessdev/reventless-spec/src/semantic/Percent.res.mjs";
 import * as Currency$Reventless from "@reventlessdev/reventless-spec/src/semantic/Currency.res.mjs";
 import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
+import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
 import * as DateRange$Reventless from "@reventlessdev/reventless-spec/src/semantic/DateRange.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
@@ -1074,6 +1075,44 @@ globalThis.describe("SuryToJsonSchema:", () => {
       ]);
     });
   });
+  globalThis.describe("GeoPoint is an object carrying the geoPoint marker:", () => {
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(S.schema(s => ({
+      location: s.m(GeoPoint$Reventless.schema),
+      lat: s.m(S.float)
+    })));
+    let keyOf = (name, key) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, key));
+    globalThis.test("the field is an object, not a pair of numbers", () => {
+      globalThis.expect(keyOf("location", "type")).toEqual("object");
+    });
+    globalThis.test("it carries the geoPoint id, sourced from the type", () => {
+      globalThis.expect([
+        keyOf("location", "x-reventless-semantic"),
+        keyOf("location", "x-reventless-semantic-source")
+      ]).toEqual([
+        "geoPoint",
+        "type"
+      ]);
+    });
+    globalThis.test("a bare lat float emits no semantic", () => {
+      globalThis.expect([
+        keyOf("lat", "type"),
+        keyOf("lat", "x-reventless-semantic")
+      ]).toEqual([
+        "number",
+        undefined
+      ]);
+    });
+    globalThis.test("both coordinates reach the wire as numbers", () => {
+      let inner = Stdlib_Option.getOr(getPropertyOf(json, "location"), null);
+      globalThis.expect([
+        Stdlib_Option.flatMap(getPropertyOf(inner, "lat"), s => getProperty(s, "type")),
+        Stdlib_Option.flatMap(getPropertyOf(inner, "lng"), s => getProperty(s, "type"))
+      ]).toEqual([
+        "number",
+        "number"
+      ]);
+    });
+  });
 });
 
 export {