@reventlessdev/reventless-local 3.0.0-alpha.142 → 3.0.0-alpha.144

package/src/adapter/Api/LocalGraphQL_SubscriptionResolvers.res

@@ -2,8 +2,8 @@
 // In-process wiring of the local event bus into the promoted, transport-neutral
 // GraphQL subscription bridge (`ReventlessGraphqlServer.GraphQL_SubscriptionBridge`).
 //
-// The generic pieces — topic naming, the field-resolver builder, `registerAll`,
-// and the `@aws_subscribe` stripping — live in core-adjacent
+// The generic pieces — topic naming, the field-resolver builder, and
+// `registerAll` — live in core-adjacent
 // `GraphQL_SubscriptionBridge`, parameterized over a PubSub instance. This
 // module supplies the in-process `GraphqlYoga.createPubSub()` singleton and the
 // Bus→PubSub glue that is specific to the local in-process backend:
@@ -101,7 +101,7 @@ type subscriptionEntry = Bridge.subscriptionEntry = {
  *   Bridge must already be wired via bridgeSourceB before calling this.
  *
  * `sdlFields`: the `subscriptions` SDL field strings from the plugin fragment
- *   (after stripping `@aws_subscribe` directives — not valid in yoga).
+ *   (provider-neutral — registered as-is).
  */
 let registerAll = (
   ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t,

package/src/components/Aggregate_Builder.res

@@ -7,6 +7,7 @@ let noHooks: ReventlessCore.Plugin_Helpers.platformHooks = {
   schedulerRoleUrn: ref(Pulumi.Output.make("")),
   api: ref(None),
   apiRole: ref(None),
+  adminApi: ref(None),
   deployTarget: ref("Domain"),
 }
 

package/src/components/Aggregate_Builder.res.mjs

@@ -30,6 +30,10 @@ let noHooks_apiRole = {
   contents: undefined
 };
 
+let noHooks_adminApi = {
+  contents: undefined
+};
+
 let noHooks_deployTarget = {
   contents: "Domain"
 };
@@ -40,6 +44,7 @@ let noHooks = {
   schedulerRoleUrn: noHooks_schedulerRoleUrn,
   api: noHooks_api,
   apiRole: noHooks_apiRole,
+  adminApi: noHooks_adminApi,
   deployTarget: noHooks_deployTarget
 };
 

package/tests/PluginEventDecodeTest.res

@@ -49,3 +49,50 @@ describe("Platform.decodePluginEventEnvelope", () => {
     )->toEqual(None)
   })
 })
+
+// The onUIFragmentChange Source-C emission decodes UiFragmentRegistry slice
+// events from the admin DcbEventLog's published envelope — the exact shape
+// DcbEventLog_Operations produces: composeEventJson'(entityId, meta,
+// combineMessage(eventType, data)).
+describe("Platform.decodeUiFragmentRegistryEventEnvelope", () => {
+  let dcbMeta = ReventlessCore.Message.generateMeta(~service="AdminDcbEventLog")
+
+  let dcbEnvelopeOf = (event: ReventlessCore.UiFragmentRegistry.event) => {
+    let json = event->S.reverseConvertToJsonOrThrow(ReventlessCore.UiFragmentRegistry.eventSchema)
+    let (eventType, data) = json->ReventlessCore.Message.splitMessage
+    ReventlessCore.Message.composeEventJson'(
+      "Catalog",
+      dcbMeta,
+      ReventlessCore.Message.combineMessage(eventType, data),
+    )
+  }
+
+  testSync("decodes a UiFragmentRegistered event from the published envelope", () => {
+    let event = ReventlessCore.UiFragmentRegistry.UiFragmentRegistered({
+      pluginId: "Catalog",
+      manifest: Plugin_Fixtures.uiManifest,
+      at: "t0",
+    })
+    expect(Platform.decodeUiFragmentRegistryEventEnvelope(dcbEnvelopeOf(event)))->toEqual(
+      Some(event),
+    )
+  })
+
+  testSync("decodes a UiFragmentDeregistered event", () => {
+    let event = ReventlessCore.UiFragmentRegistry.UiFragmentDeregistered({pluginId: "Catalog"})
+    expect(Platform.decodeUiFragmentRegistryEventEnvelope(dcbEnvelopeOf(event)))->toEqual(
+      Some(event),
+    )
+  })
+
+  testSync("returns None for malformed input", () => {
+    expect(
+      Platform.decodeUiFragmentRegistryEventEnvelope(JSON.Encode.string("junk")),
+    )->toEqual(None)
+    expect(
+      Platform.decodeUiFragmentRegistryEventEnvelope(
+        JSON.Encode.object(Dict.fromArray([("event", JSON.Encode.object(Dict.make()))])),
+      ),
+    )->toEqual(None)
+  })
+})

package/tests/PluginEventDecodeTest.res.mjs

@@ -6,6 +6,7 @@ import * as Platform$ReventlessLocal from "../src/Platform.res.mjs";
 import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
 import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
 import * as Plugin_Fixtures$ReventlessLocal from "./plugin/Plugin_Fixtures.res.mjs";
+import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
 
@@ -56,6 +57,38 @@ globalThis.describe("Platform.decodePluginEventEnvelope", () => {
   });
 });
 
+globalThis.describe("Platform.decodeUiFragmentRegistryEventEnvelope", () => {
+  let dcbMeta = Message$ReventlessCore.generateMeta("AdminDcbEventLog", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let dcbEnvelopeOf = event => {
+    let json = S.reverseConvertToJsonOrThrow(event, UiFragmentRegistry$ReventlessCore.eventSchema);
+    let match = Message$ReventlessCore.splitMessage(json);
+    return Message$ReventlessCore.composeEventJson$p("Catalog", dcbMeta, Message$ReventlessCore.combineMessage(match[0], match[1]));
+  };
+  globalThis.test("decodes a UiFragmentRegistered event from the published envelope", () => {
+    let event = {
+      TAG: "UiFragmentRegistered",
+      pluginId: "Catalog",
+      manifest: Plugin_Fixtures$ReventlessLocal.uiManifest,
+      at: "t0"
+    };
+    globalThis.expect(Platform$ReventlessLocal.decodeUiFragmentRegistryEventEnvelope(dcbEnvelopeOf(event))).toEqual(event);
+  });
+  globalThis.test("decodes a UiFragmentDeregistered event", () => {
+    let event = {
+      TAG: "UiFragmentDeregistered",
+      pluginId: "Catalog"
+    };
+    globalThis.expect(Platform$ReventlessLocal.decodeUiFragmentRegistryEventEnvelope(dcbEnvelopeOf(event))).toEqual(event);
+  });
+  globalThis.test("returns None for malformed input", () => {
+    globalThis.expect(Platform$ReventlessLocal.decodeUiFragmentRegistryEventEnvelope("junk")).toEqual(undefined);
+    globalThis.expect(Platform$ReventlessLocal.decodeUiFragmentRegistryEventEnvelope(Object.fromEntries([[
+        "event",
+        {}
+      ]]))).toEqual(undefined);
+  });
+});
+
 export {
   meta,
   envelopeOf,

package/tests/adapter/GraphQLSubscriptionBridgeTest.res

@@ -7,8 +7,9 @@
 // **explicitly injected** in-process PubSub (never the local singleton) to
 // prove the parameterized-PubSub seam is behavior-preserving:
 //
-//   1. registerAll builds the subscription SDL on a fresh GraphQL_ServerInstance,
-//      strips @aws_subscribe, and injects `scalar AWSJSON`.
+//   1. registerAll builds the subscription SDL on a fresh GraphQL_ServerInstance
+//      (fields register as-is — core SDL is provider-neutral) and injects
+//      `scalar AWSJSON`.
 //   2. A resolver from makeFieldResolver, subscribed on the injected PubSub,
 //      receives a payload published via Bridge.publish on that same PubSub.
 
@@ -53,12 +54,12 @@ let yieldTick = (): promise<unit> =>
   })
 
 describe("GraphQL_SubscriptionBridge — injected PubSub seam", () => {
-  testSync("registerAll builds subscription SDL, strips @aws_subscribe, injects AWSJSON", () => {
+  testSync("registerAll builds subscription SDL as-is and injects AWSJSON", () => {
     let pubSub = GraphqlYoga.createPubSub()
     let server = Server.make(~label="SeamTest")
 
-    let sdlField =
-      "onCatalogProduct_stateChanged: CatalogProduct\n    @aws_subscribe(mutations: [\"addProduct\"])"
+    // Core emits provider-neutral subscription SDL — no directives to strip.
+    let sdlField = "onCatalogProduct_stateChanged: CatalogProduct"
 
     Bridge.registerAll(
       ~server,
@@ -71,8 +72,6 @@ describe("GraphQL_SubscriptionBridge — injected PubSub seam", () => {
     let sdl = server.buildSdl()
     expect(sdl->String.includes("type Subscription"))->toBe(true)
     expect(sdl->String.includes("onCatalogProduct_stateChanged"))->toBe(true)
-    // @aws_subscribe is AppSync-only and must be stripped for yoga.
-    expect(sdl->String.includes("@aws_subscribe"))->toBe(false)
     // AWSJSON scalar injected so yoga accepts AppSync-derived event log types.
     expect(sdl->String.includes("scalar AWSJSON"))->toBe(true)
   })

package/tests/adapter/GraphQLSubscriptionBridgeTest.res.mjs

@@ -34,17 +34,16 @@ function yieldTick() {
 }
 
 globalThis.describe("GraphQL_SubscriptionBridge — injected PubSub seam", () => {
-  globalThis.test("registerAll builds subscription SDL, strips @aws_subscribe, injects AWSJSON", () => {
+  globalThis.test("registerAll builds subscription SDL as-is and injects AWSJSON", () => {
     let pubSub = GraphqlYoga.createPubSub();
     let server = GraphQL_ServerInstance$ReventlessGraphqlServer.make("SeamTest");
-    GraphQL_SubscriptionBridge$ReventlessGraphqlServer.registerAll(server, ["onCatalogProduct_stateChanged: CatalogProduct\n    @aws_subscribe(mutations: [\"addProduct\"])"], [], [{
+    GraphQL_SubscriptionBridge$ReventlessGraphqlServer.registerAll(server, ["onCatalogProduct_stateChanged: CatalogProduct"], [], [{
         fieldName: "onCatalogProduct_stateChanged",
         topic: "onCatalogProduct_stateChanged"
       }], pubSub);
     let sdl = server.buildSdl();
     globalThis.expect(sdl.includes("type Subscription")).toBe(true);
     globalThis.expect(sdl.includes("onCatalogProduct_stateChanged")).toBe(true);
-    globalThis.expect(sdl.includes("@aws_subscribe")).toBe(false);
     globalThis.expect(sdl.includes("scalar AWSJSON")).toBe(true);
   });
   globalThis.test("makeFieldResolver + publish deliver over the injected PubSub", async () => {

package/tests/plugin/ApiFragmentRegistry_GWT.res

@@ -0,0 +1,103 @@
+// StateChangeSlice GWT for the ApiFragmentRegistry write side (the platform API-schema
+// fragment registry replacing the deploy-schema:* keyspace —
+// event-sourced-fragment-registries plan).
+open ReventlessCore
+open Reventless.Plugin // Domain / Platform constructors of apiTarget
+
+module Test = ReventlessGwt.Behavior_GWT.Make(ApiFragmentRegistry, ApiFragmentRegistry_Behavior)
+open Test
+open ApiFragmentRegistry
+
+let fragment1: Reventless.Plugin.apiSchemaFragment = {
+  encoded: `{"types":["type Catalog_Product { id: ID! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+}
+
+let fragment2: Reventless.Plugin.apiSchemaFragment = {
+  encoded: `{"types":["type Catalog_Product { id: ID!\\n  name: String! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+}
+
+describe("ApiFragmentRegistry StateChangeSlice", () => {
+  test("register on empty state emits ApiFragmentRegistered", () =>
+    givenEvents([])
+    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"}))
+    ->thenEvent(ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"}))
+  )
+
+  test("re-registering an identical fragment + target is idempotent (no event)", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"})])
+    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t1"}))
+    ->thenNoEvent
+  )
+
+  test("registering a changed fragment emits ApiFragmentUpdated (version supersession)", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"})])
+    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment2, apiTarget: Domain, at: "t1"}))
+    ->thenEvent(
+      ApiFragmentUpdated({
+        pluginId: "p1",
+        previousFragment: fragment1,
+        newFragment: fragment2,
+        apiTarget: Domain,
+        at: "t1",
+      }),
+    )
+  )
+
+  test("retargeting a plugin with an identical fragment emits ApiFragmentUpdated", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"})])
+    ->whenCmd(RegisterApiFragment({pluginId: "p1", fragment: fragment1, apiTarget: Platform, at: "t1"}))
+    ->thenEvent(
+      ApiFragmentUpdated({
+        pluginId: "p1",
+        previousFragment: fragment1,
+        newFragment: fragment1,
+        apiTarget: Platform,
+        at: "t1",
+      }),
+    )
+  )
+
+  test("deregister emits ApiFragmentDeregistered", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"})])
+    ->whenCmd(DeregisterApiFragment({pluginId: "p1"}))
+    ->thenEvent(ApiFragmentDeregistered({pluginId: "p1"}))
+  )
+
+  test("deregistering an absent fragment is idempotent (no event)", () =>
+    givenEvents([])
+    ->whenCmd(DeregisterApiFragment({pluginId: "p1"}))
+    ->thenNoEvent
+  )
+
+  test("recording a push outcome emits ApiFragmentPushRecorded", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"})])
+    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
+    ->thenEvent(ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}))
+  )
+
+  test("redelivering an identical push record is idempotent (no event)", () =>
+    givenEvents([
+      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"}),
+      ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}),
+    ])
+    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
+    ->thenNoEvent
+  )
+
+  test("a later distinct push outcome is recorded again", () =>
+    givenEvents([
+      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: Domain, at: "t0"}),
+      ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}),
+    ])
+    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: false, message: "stitch failed", at: "t2"}))
+    ->thenEvent(ApiFragmentPushRecorded({pluginId: "p1", ok: false, message: "stitch failed", at: "t2"}))
+  )
+
+  test("recording a push for an unregistered plugin is dropped (no event)", () =>
+    givenEvents([])
+    ->whenCmd(RecordApiFragmentPush({pluginId: "p1", ok: true, message: "", at: "t1"}))
+    ->thenNoEvent
+  )
+})

package/tests/plugin/ApiFragmentRegistry_GWT.res.mjs

@@ -0,0 +1,196 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as ApiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs";
+import * as ApiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res.mjs";
+
+let Test = Behavior_GWT$ReventlessGwt.Make({
+  name: ApiFragmentRegistry$ReventlessCore.name,
+  consumedEventSchema: ApiFragmentRegistry$ReventlessCore.consumedEventSchema,
+  commandSchema: ApiFragmentRegistry$ReventlessCore.commandSchema,
+  errorSchema: ApiFragmentRegistry$ReventlessCore.errorSchema,
+  eventSchema: ApiFragmentRegistry$ReventlessCore.eventSchema
+})({
+  initialState: undefined,
+  evolve: ApiFragmentRegistry_Behavior$ReventlessCore.evolve,
+  decide: ApiFragmentRegistry_Behavior$ReventlessCore.decide
+});
+
+let fragment1 = {
+  encoded: `{"types":["type Catalog_Product { id: ID! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql"
+};
+
+let fragment2 = {
+  encoded: `{"types":["type Catalog_Product { id: ID!\\n  name: String! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql"
+};
+
+Test.describe("ApiFragmentRegistry StateChangeSlice", () => {
+  Test.test("register on empty state emits ApiFragmentRegistered", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([]), {
+    TAG: "RegisterApiFragment",
+    pluginId: "p1",
+    fragment: fragment1,
+    apiTarget: "Domain",
+    at: "t0"
+  }), {
+    TAG: "ApiFragmentRegistered",
+    pluginId: "p1",
+    fragment: fragment1,
+    apiTarget: "Domain",
+    at: "t0"
+  }));
+  Test.test("re-registering an identical fragment + target is idempotent (no event)", () => Test.thenNoEvent(Test.whenCmd(Test.givenEvents([{
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    }]), {
+    TAG: "RegisterApiFragment",
+    pluginId: "p1",
+    fragment: fragment1,
+    apiTarget: "Domain",
+    at: "t1"
+  })));
+  Test.test("registering a changed fragment emits ApiFragmentUpdated (version supersession)", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([{
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    }]), {
+    TAG: "RegisterApiFragment",
+    pluginId: "p1",
+    fragment: fragment2,
+    apiTarget: "Domain",
+    at: "t1"
+  }), {
+    TAG: "ApiFragmentUpdated",
+    pluginId: "p1",
+    previousFragment: fragment1,
+    newFragment: fragment2,
+    apiTarget: "Domain",
+    at: "t1"
+  }));
+  Test.test("retargeting a plugin with an identical fragment emits ApiFragmentUpdated", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([{
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    }]), {
+    TAG: "RegisterApiFragment",
+    pluginId: "p1",
+    fragment: fragment1,
+    apiTarget: "Platform",
+    at: "t1"
+  }), {
+    TAG: "ApiFragmentUpdated",
+    pluginId: "p1",
+    previousFragment: fragment1,
+    newFragment: fragment1,
+    apiTarget: "Platform",
+    at: "t1"
+  }));
+  Test.test("deregister emits ApiFragmentDeregistered", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([{
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    }]), {
+    TAG: "DeregisterApiFragment",
+    pluginId: "p1"
+  }), {
+    TAG: "ApiFragmentDeregistered",
+    pluginId: "p1"
+  }));
+  Test.test("deregistering an absent fragment is idempotent (no event)", () => Test.thenNoEvent(Test.whenCmd(Test.givenEvents([]), {
+    TAG: "DeregisterApiFragment",
+    pluginId: "p1"
+  })));
+  Test.test("recording a push outcome emits ApiFragmentPushRecorded", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([{
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    }]), {
+    TAG: "RecordApiFragmentPush",
+    pluginId: "p1",
+    ok: true,
+    message: "",
+    at: "t1"
+  }), {
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: "p1",
+    ok: true,
+    message: "",
+    at: "t1"
+  }));
+  Test.test("redelivering an identical push record is idempotent (no event)", () => Test.thenNoEvent(Test.whenCmd(Test.givenEvents([
+    {
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    },
+    {
+      TAG: "ApiFragmentPushRecorded",
+      pluginId: "p1",
+      ok: true,
+      message: "",
+      at: "t1"
+    }
+  ]), {
+    TAG: "RecordApiFragmentPush",
+    pluginId: "p1",
+    ok: true,
+    message: "",
+    at: "t1"
+  })));
+  Test.test("a later distinct push outcome is recorded again", () => Test.thenEvent(Test.whenCmd(Test.givenEvents([
+    {
+      TAG: "ApiFragmentRegistered",
+      pluginId: "p1",
+      fragment: fragment1,
+      apiTarget: "Domain",
+      at: "t0"
+    },
+    {
+      TAG: "ApiFragmentPushRecorded",
+      pluginId: "p1",
+      ok: true,
+      message: "",
+      at: "t1"
+    }
+  ]), {
+    TAG: "RecordApiFragmentPush",
+    pluginId: "p1",
+    ok: false,
+    message: "stitch failed",
+    at: "t2"
+  }), {
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: "p1",
+    ok: false,
+    message: "stitch failed",
+    at: "t2"
+  }));
+  Test.test("recording a push for an unregistered plugin is dropped (no event)", () => Test.thenNoEvent(Test.whenCmd(Test.givenEvents([]), {
+    TAG: "RecordApiFragmentPush",
+    pluginId: "p1",
+    ok: true,
+    message: "",
+    at: "t1"
+  })));
+});
+
+export {
+  Test,
+  fragment1,
+  fragment2,
+}
+/* Test Not a pure module */

package/tests/plugin/ApiFragments_GWT.res

@@ -0,0 +1,103 @@
+// StateViewSlice projection GWT for the ApiFragments read side — the current fragment
+// per plugin name plus push status, replacing the deploy-schema:* rows as the durable
+// stitch source (event-sourced-fragment-registries plan).
+open ReventlessCore
+module P = Reventless.Plugin // P.Domain / P.Platform — avoid opening apiSchemaFragment's labels
+
+module Test = ReventlessGwt.Projection_GWT.Make(ApiFragments, ApiFragments_Projection)
+open Test
+open ApiFragments
+
+let fragment1: Reventless.Plugin.apiSchemaFragment = {
+  encoded: `{"types":["type Catalog_Product { id: ID! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+}
+
+let fragment2: Reventless.Plugin.apiSchemaFragment = {
+  encoded: `{"types":["type Catalog_Product { id: ID!\\n  name: String! }"],"mutations":[],"queries":[],"subscriptions":[],"subscriptionSources":[]}`,
+  protocol: "graphql",
+}
+
+let registeredState: ApiFragments.state = {
+  pluginId: "p1",
+  encoded: fragment1.encoded,
+  protocol: fragment1.protocol,
+  apiTarget: P.Domain,
+  registeredAt: "t0",
+  updatedAt: "t0",
+  pushStatus: "pending",
+  pushMessage: "",
+  pushedAt: "",
+}
+
+describe("ApiFragments StateViewSlice projection", () => {
+  test("ApiFragmentRegistered creates the row pending (registeredAt = updatedAt = event time)", () =>
+    givenEvents([])
+    ->whenEvent(ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}))
+    ->thenStateWithId("p1", registeredState)
+  )
+
+  test("ApiFragmentPushRecorded(ok) marks the row ok with the push time", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
+    ->whenEvent(ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}))
+    ->thenStateWithId("p1", {...registeredState, pushStatus: "ok", pushedAt: "t1"})
+  )
+
+  test("ApiFragmentPushRecorded(error) carries the message", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
+    ->whenEvent(
+      ApiFragmentPushRecorded({pluginId: "p1", ok: false, message: "stitch failed", at: "t1"}),
+    )
+    ->thenStateWithId(
+      "p1",
+      {...registeredState, pushStatus: "error", pushMessage: "stitch failed", pushedAt: "t1"},
+    )
+  )
+
+  test("ApiFragmentUpdated replaces the fragment and resets the row to pending", () =>
+    givenEvents([
+      ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"}),
+      ApiFragmentPushRecorded({pluginId: "p1", ok: true, message: "", at: "t1"}),
+    ])
+    ->whenEvent(
+      ApiFragmentUpdated({
+        pluginId: "p1",
+        previousFragment: fragment1,
+        newFragment: fragment2,
+        apiTarget: P.Domain,
+        at: "t2",
+      }),
+    )
+    ->thenStateWithId(
+      "p1",
+      {
+        ...registeredState,
+        encoded: fragment2.encoded,
+        updatedAt: "t2",
+        pushStatus: "pending",
+        pushMessage: "",
+        pushedAt: "t1",
+      },
+    )
+  )
+
+  test("ApiFragmentUpdated carrying a new target moves the row to that API", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
+    ->whenEvent(
+      ApiFragmentUpdated({
+        pluginId: "p1",
+        previousFragment: fragment1,
+        newFragment: fragment1,
+        apiTarget: P.Platform,
+        at: "t1",
+      }),
+    )
+    ->thenStateWithId("p1", {...registeredState, apiTarget: P.Platform, updatedAt: "t1"})
+  )
+
+  test("ApiFragmentDeregistered removes the row", () =>
+    givenEvents([ApiFragmentRegistered({pluginId: "p1", fragment: fragment1, apiTarget: P.Domain, at: "t0"})])
+    ->whenEvent(ApiFragmentDeregistered({pluginId: "p1"}))
+    ->thenNoState
+  )
+})