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

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -1,26 +1,24 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "ConflictTestAggregate";
 
-let commandSchema = S.schema(s => ({
+let commandSchema = Sury.$schema(s => ({
   TAG: "Create",
-  name: s.m(S.string)
+  name: s.m(Sury.string)
 }));
 
-let eventSchema = S.schema(s => ({
+let eventSchema = Sury.$schema(s => ({
   TAG: "Created",
-  name: s.m(S.string)
+  name: s.m(Sury.string)
 }));
 
-let errorSchema = S.literal("AlreadyExists");
+let errorSchema = Sury.literal("AlreadyExists");
 
 let moduleUrl = import.meta.url;
 
@@ -383,4 +381,4 @@ export {
   testMeta,
   makeTopicItem,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateFixtures.res

@@ -1,4 +1,3 @@
-S.enableJson()
 
 // ─────────────────────────────────────────────────────────────
 // Aggregate spec

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -1,39 +1,37 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "TestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Create",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "Rename",
-    newName: s.m(S.string)
+    newName: s.m(Sury.string)
   }))
 ]);
 
-let eventSchema = S.union([
-  S.schema(s => ({
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Created",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "Renamed",
-    newName: s.m(S.string)
+    newName: s.m(Sury.string)
   }))
 ]);
 
-let errorSchema = S.union([
-  S.literal("AlreadyExists"),
-  S.literal("NotFound")
+let errorSchema = Sury.union([
+  Sury.literal("AlreadyExists"),
+  Sury.literal("NotFound")
 ]);
 
 let moduleUrl = import.meta.url;
@@ -52,11 +50,11 @@ let AggSpec = {
   commandAuthorization: commandAuthorization
 };
 
-let stateSchema = S.union([
-  S.literal("NotCreated"),
-  S.schema(s => ({
+let stateSchema = Sury.union([
+  Sury.literal("NotCreated"),
+  Sury.$schema(s => ({
     TAG: "Created",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   }))
 ]);
 
@@ -305,4 +303,4 @@ export {
   testMeta,
   makeTopicItem,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateSnapshotTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure
@@ -300,7 +299,7 @@ describe("Aggregate_Callback — snapshots:", () => {
     | Some(snap) =>
       expect(snap.seqNr)->toBe(20)
       // 20 items folded through the seeded state — no double-count, no gap.
-      let decoded = snap.state->S.parseJsonOrThrow(TestBehavior.stateSchema)
+      let decoded = snap.state->Reventless.Util_Sury.fromJson(TestBehavior.stateSchema)
       expect(decoded.items->Array.length)->toBe(20)
     | None => expect("expected snapshot at 20")->toBe("none")
     }

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -1,31 +1,30 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "SnapshotTestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Add",
-    item: s.m(S.string)
+    item: s.m(Sury.string)
   })),
-  S.literal("Noop")
+  Sury.literal("Noop")
 ]);
 
-let eventSchema = S.schema(s => ({
+let eventSchema = Sury.$schema(s => ({
   TAG: "Added",
-  item: s.m(S.string)
+  item: s.m(Sury.string)
 }));
 
-let errorSchema = S.literal("Never");
+let errorSchema = Sury.literal("Never");
 
 let moduleUrl = import.meta.url;
 
@@ -43,8 +42,8 @@ let AggSpec = {
   commandAuthorization: commandAuthorization
 };
 
-let stateSchema = S.schema(s => ({
-  items: s.m(S.array(S.string))
+let stateSchema = Sury.$schema(s => ({
+  items: s.m(Sury.array(Sury.string))
 }));
 
 let initialState = {
@@ -325,8 +324,8 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   eventLog: eventLog
 });
 
-let stateSchema$1 = S.schema(s => ({
-  items: s.m(S.array(S.string))
+let stateSchema$1 = Sury.$schema(s => ({
+  items: s.m(Sury.array(Sury.string))
 }));
 
 let initialState$1 = {
@@ -550,7 +549,7 @@ globalThis.describe("Aggregate_Callback — snapshots:", () => {
     let snap = mock.getSnapshot("agg-1");
     if (snap !== undefined) {
       globalThis.expect(snap.seqNr).toBe(20);
-      let decoded = S.parseJsonOrThrow(snap.state, stateSchema);
+      let decoded = Util_Sury$Reventless.fromJson(snap.state, stateSchema);
       globalThis.expect(decoded.items.length).toBe(20);
     } else {
       globalThis.expect("expected snapshot at 20").toBe("none");
@@ -642,4 +641,4 @@ export {
   run,
   tick,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/api/ApiNoApiTest.res.mjs

@@ -1,37 +1,42 @@
 // 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 Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../src/components/Api/ApiNoApiHelpers.res.mjs";
 
 globalThis.describe("ApiNoApiHelpers:", () => {
   globalThis.test("isNoApi returns false for schema without noApi metadata", () => {
-    globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(S.string)).toBe(false);
+    let schema = Sury.string;
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(schema)).toBe(false);
   });
   globalThis.test("isNoApi returns true for schema with noApi metadata set to true", () => {
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiId, true);
+    let schema = Sury.string;
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiId, true);
     globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(schema$p)).toBe(true);
   });
   globalThis.test("getExcludedVariants returns None for schema without noApiVariants metadata", () => {
-    globalThis.expect(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(S.string)).toBe(undefined);
+    let schema = Sury.string;
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(schema)).toBe(undefined);
   });
   globalThis.test("getExcludedVariants returns Some with DeleteItem when set", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let result = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(schema$p);
     globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.map(result, set => set.has("DeleteItem")), false)).toBe(true);
   });
   globalThis.test("filterNoApiVariants returns all field names when no variants are excluded", () => {
+    let schema = Sury.string;
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
       "UpdateItem"
     ];
-    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, S.string);
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, schema);
     globalThis.expect(filtered).toEqual([
       "CreateItem",
       "DeleteItem",
@@ -39,8 +44,9 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants filters out excluded variants", () => {
+    let schema = Sury.string;
     let excluded = new Set(["DeleteItem"]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
@@ -53,11 +59,12 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants filters out multiple excluded variants", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
@@ -71,12 +78,13 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants returns empty array when all variants are excluded", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "CreateItem",
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -340,3 +340,235 @@ describe("GraphQL_FragmentGenerator.mutationArgTypes", () => {
     expect((mismatched, field->String.length > 0))->toEqual(([], true))
   })
 })
+
+module RefDoorRow = {
+  @schema
+  type state = {id: string, name: string}
+}
+
+let queryFor = (fragment, needle) =>
+  GraphQL_Stitcher.decode(fragment).queries->Array.find(q => q->String.includes(needle))
+
+let refDoorFragment = (~subIdField=?) =>
+  GraphQL_FragmentGenerator.generate(
+    ~mutationEntries=[],
+    ~queryEntries=[
+      {
+        ReventlessInfra.Api.singleFieldName: "Catalog_Product",
+        listFieldName: "Catalog_Products",
+        returnTypeName: "Catalog_Product",
+        stateSchema: RefDoorRow.stateSchema->S.castToUnknown,
+        authorization: None,
+        connectionSpec: true,
+        subIdField: ?subIdField,
+      },
+    ],
+  )
+
+// What a caller holding a pointer to a withheld row may learn about it, and what
+// the two doors that could never answer for one can now be asked.
+describe("the reference door and the archive argument", () => {
+
+  // The narrowness is the type's, not a rule each backend re-implements: a caller
+  // cannot ask this door for a price, because there is no price on it.
+  testSync("projects a reference to id, label and the state that retired it", () => {
+    let sdl = GraphQL_FragmentGenerator.deriveRefTypeSdl(~returnTypeName="Catalog_Product")
+    expect((
+      sdl->String.includes("type Catalog_ProductRef"),
+      sdl->String.includes("label: String!"),
+      sdl->String.includes("retiredState: String"),
+      sdl->String.includes("price"),
+    ))->toEqual((true, true, true, false))
+  })
+
+  // Emitted for every view rather than only the annotated ones, on the reasoning
+  // `includeRetired` already states: a field that appears with an annotation makes
+  // adding or removing it a breaking schema change.
+  testSync("names the door after the list field it resolves against", () =>
+    expect(
+      GraphQL_FragmentGenerator.deriveRefsQueryField(
+        ~listFieldName="Catalog_Products",
+        ~returnTypeName="Catalog_Product",
+      ),
+    )->toEqual("  Catalog_ProductsRefs(ids: [ID!]!): [Catalog_ProductRef!]!")
+  )
+
+  // Every assertion above reads a `derive*` helper directly, which is how a door
+  // that no `generate` call emitted still passed them all: the SDL both AppSync
+  // APIs are built from comes from `generate`, while the adapter provisions a
+  // `<list>Refs` resolver per queryable on the premise that it is declared there.
+  // AppSync rejects a resolver for a field its schema does not have, so the
+  // mismatch surfaced as a failed deploy rather than a missing feature.
+  testSync("emits the door from generate, not only from the helper", () =>
+    expect((
+      queryFor(refDoorFragment(), "Catalog_ProductsRefs(ids: [ID!]!)")->Option.isSome,
+      typeDefFor(refDoorFragment(), "type Catalog_ProductRef")->Option.isSome,
+    ))->toEqual((true, true))
+  )
+
+  // The condition the resolver side uses, mirrored: a composite-key view gets no
+  // door, because the read behind it is a BatchGetItem that would need both keys.
+  // Emitting the field for one would restore the same mismatch, reversed.
+  testSync("withholds the door from a composite-key view", () =>
+    expect((
+      queryFor(refDoorFragment(~subIdField="lineNo"), "Catalog_ProductsRefs")->Option.isSome,
+      typeDefFor(refDoorFragment(~subIdField="lineNo"), "type Catalog_ProductRef")->Option.isSome,
+    ))->toEqual((false, false))
+  )
+
+  // The dead end this closes: the archive toggle put retired rows on screen and
+  // clicking one read a door that refused them to every caller alive, elevated
+  // included, because there was no way to ask.
+  testSync("lets the single-entity and by-ids doors be asked for the archive", () =>
+    expect((
+      GraphQL_FragmentGenerator.deriveObjectQueryField(
+        ~singleFieldName="Catalog_Product",
+        ~typeName="Catalog_Product",
+      )->String.includes("includeRetired: Boolean"),
+      GraphQL_FragmentGenerator.deriveByIdsQueryField(
+        ~listFieldName="Catalog_Products",
+        ~returnTypeName="Catalog_Product",
+      )->String.includes("includeRetired: Boolean"),
+    ))->toEqual((true, true))
+  )
+
+  // A sub-id read keeps its sort-key argument beside the new one; dropping it
+  // would silently turn a two-key door into a one-key one.
+  testSync("keeps the sub-id argument when the view has one", () =>
+    expect(
+      GraphQL_FragmentGenerator.deriveObjectQueryField(
+        ~singleFieldName="Ordering_OrderLine",
+        ~typeName="Ordering_OrderLine",
+        ~subIdField="lineNo",
+      ),
+    )->toEqual("  Ordering_OrderLine(id: ID!, lineNo: String!, includeRetired: Boolean): Ordering_OrderLine")
+  )
+})
+
+// The by-index door is asserted whole rather than by `String.includes`, because
+// what was wrong with it was never a missing substring: the field declared an
+// `id` its resolver did not read and omitted the key its resolver did, so every
+// part of the signature is load-bearing.
+describe("the by-index door", () => {
+  let index = (~index, ~idField=?, ~subIdField=?): Reventless.ReadModel.indexConfig => {
+    index,
+    type_: "S",
+    idField: ?idField,
+    subIdField: ?subIdField,
+    projectionType: ALL,
+  }
+
+  testSync("takes the index value it filters on, and can be asked for the archive", () =>
+    expect(
+      GraphQL_FragmentGenerator.deriveIndexQueryField(
+        ~singleFieldName="Catalog_Product",
+        ~indexConfig=index(~index="categoryId"),
+        ~connectionTypeName="Catalog_ProductConnection",
+      ),
+    )->toEqual(
+      "  Catalog_ProductByCategoryId(categoryId: String!, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Catalog_ProductConnection!",
+    )
+  )
+
+  // A named index has two different strings in play — `byOwner` names the index,
+  // `ownerId` names the column. The field is named after the first and keyed on
+  // the second, and swapping them is how the local adapter came to offer an
+  // argument the row had no field for.
+  testSync("names the field after the index and keys it on the column", () =>
+    expect(
+      GraphQL_FragmentGenerator.deriveIndexQueryField(
+        ~singleFieldName="Ordering_Order",
+        ~indexConfig=index(~index="byOwner", ~idField="ownerId"),
+        ~connectionTypeName="Ordering_OrderConnection",
+      ),
+    )->toEqual(
+      "  Ordering_OrderByOwner(ownerId: String!, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Ordering_OrderConnection!",
+    )
+  )
+
+  // Optional, unlike the partition argument: naming the index value is the point
+  // of the door, narrowing to one sort value is a refinement.
+  testSync("offers the sort key the sort template has always read", () =>
+    expect(
+      GraphQL_FragmentGenerator.deriveIndexQueryField(
+        ~singleFieldName="Ordering_Order",
+        ~indexConfig=index(~index="byCustomer", ~idField="customerId", ~subIdField="placedAt"),
+        ~connectionTypeName="Ordering_OrderConnection",
+      ),
+    )->toEqual(
+      "  Ordering_OrderByCustomer(customerId: String!, placedAt: String, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Ordering_OrderConnection!",
+    )
+  )
+
+  // One derivation, called by every backend. The local adapter used to spell the
+  // name out itself and produced `XByByOwner` where this produces `XByOwner`.
+  testSync("drops a leading `by` exactly once", () =>
+    expect((
+      GraphQL_FragmentGenerator.indexQueryFieldName(~singleFieldName="X", ~index="byOwner"),
+      GraphQL_FragmentGenerator.indexQueryFieldName(~singleFieldName="X", ~index="ownerId"),
+      GraphQL_FragmentGenerator.indexQueryFieldName(~singleFieldName="X", ~index="by"),
+    ))->toEqual(("XByOwner", "XByOwnerId", "XByBy"))
+  )
+})
+
+// ── @internal: a field that is not on the GraphQL surface ────────────────────
+//
+// A read model's `@schema type state` is otherwise simultaneously the storage
+// shape and the API shape. `@internal` separates them: the field stays in the
+// record and in storage, and every generated object type drops it.
+//
+// The declaration is read off the schema rather than passed in, which is the
+// point — the alternative is a hand-written exclude list beside the query entry,
+// kept in step with the record by whoever next edits it. That is exactly what
+// `PluginBaseFragment` maintained and what this replaces.
+//
+// The fixture is `PsInternalFieldsReadModel`, a spec file: the annotation machinery
+// runs under `@@reventless.spec`.
+
+describe("@internal keeps a field off the generated type", () => {
+  let stateSchema = PsInternalFieldsReadModel.stateSchema->S.castToUnknown
+
+  let types = (~excludeFields=?) =>
+    GraphQL_FragmentGenerator.deriveObjectTypeWithNested(
+      ~typeName="Platform_Widget",
+      ~excludeFields?,
+      stateSchema,
+    )->Array.join("\n")
+
+  testSync("the declared fields are absent", () =>
+    expect((
+      types()->String.includes("eventCollector"),
+      types()->String.includes("extensionNames"),
+    ))->toEqual((false, false))
+  )
+
+  testSync("and everything else is untouched", () =>
+    expect((types()->String.includes("name"), types()->String.includes("itemId")))->toEqual((
+      true,
+      true,
+    ))
+  )
+
+  // The caller's own exclusions still apply. The two lists answer different
+  // questions — one is a decision made where the entry is assembled, the other a
+  // declaration on the field — so the marker joins the list rather than
+  // replacing it.
+  testSync("a caller's excludeFields still applies alongside", () => {
+    let sdl = types(~excludeFields=["name"])
+    expect((sdl->String.includes("name"), sdl->String.includes("eventCollector")))->toEqual((
+      false,
+      false,
+    ))
+  })
+
+  // The published state schema and the SDL have to agree, because AutoUI builds
+  // its list query from the former and sends it against the latter. This is the
+  // pairing that used to need two hand-maintained lists to hold.
+  testSync("the published state schema drops them too", () => {
+    let json = SuryToJsonSchema.deriveObjectSchema(stateSchema)->JSON.stringify
+    expect((json->String.includes("eventCollector"), json->String.includes("name")))->toEqual((
+      false,
+      true,
+    ))
+  })
+})