@reventlessdev/reventless-aws 3.0.0-alpha.173 → 3.0.0-alpha.175

package/tests/AppSync_AdapterTest.res.mjs

@@ -282,14 +282,14 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — Stage E2 permission lifti
   });
 });
 
-globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", () => {
+globalThis.describe("AppSync_Adapter.injectAwsAuth — systemCallable dual-auth", () => {
   let makeFragment = (mutationFields, queryFields) => GraphQL_Stitcher$ReventlessCore.encode({
     types: [],
     mutations: mutationFields,
     queries: queryFields,
     subscriptions: []
   });
-  globalThis.test("iamCallable mutation with a group emits @aws_cognito_user_pools + @aws_iam", () => {
+  globalThis.test("systemCallable mutation with a group emits @aws_cognito_user_pools + @aws_iam", () => {
     let entry_fieldNames = ["p_Sync"];
     let entry_fieldPermissions = Object.fromEntries([[
         "p_Sync",
@@ -298,12 +298,12 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
           _0: ["Admin"]
         }
       ]]);
-    let entry_iamCallable = true;
+    let entry_systemCallable = true;
     let entry = {
       fieldNames: entry_fieldNames,
       commandSchema: S.unknown,
       fieldPermissions: entry_fieldPermissions,
-      iamCallable: entry_iamCallable
+      systemCallable: entry_systemCallable
     };
     let frag = makeFragment(["p_Sync(id: ID!): String"], []);
     let aug = AppSync_Adapter$ReventlessAws.injectAwsAuth(frag, [entry], []);
@@ -312,18 +312,18 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
     globalThis.expect(m).toContain("@aws_iam");
     globalThis.expect(m).not.toContain("@aws_auth");
   });
-  globalThis.test("iamCallable mutation without a group restriction stays open to Cognito + IAM", () => {
+  globalThis.test("systemCallable mutation without a group restriction stays open to Cognito + IAM", () => {
     let entry_fieldNames = ["p_Sync"];
     let entry_fieldPermissions = Object.fromEntries([[
         "p_Sync",
         "AllowAuthenticated"
       ]]);
-    let entry_iamCallable = true;
+    let entry_systemCallable = true;
     let entry = {
       fieldNames: entry_fieldNames,
       commandSchema: S.unknown,
       fieldPermissions: entry_fieldPermissions,
-      iamCallable: entry_iamCallable
+      systemCallable: entry_systemCallable
     };
     let frag = makeFragment(["p_Sync(id: ID!): String"], []);
     let aug = AppSync_Adapter$ReventlessAws.injectAwsAuth(frag, [entry], []);
@@ -332,7 +332,7 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
     globalThis.expect(m).not.toContain("cognito_groups");
     globalThis.expect(m).not.toContain("@aws_auth");
   });
-  globalThis.test("a non-iamCallable sibling keeps single-mode @aws_auth (no @aws_iam)", () => {
+  globalThis.test("a non-systemCallable sibling keeps single-mode @aws_auth (no @aws_iam)", () => {
     let entry_fieldNames = [
       "p_Sync",
       "p_Other"
@@ -353,12 +353,12 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
         }
       ]
     ]);
-    let entry_iamCallable = false;
+    let entry_systemCallable = false;
     let entry = {
       fieldNames: entry_fieldNames,
       commandSchema: S.unknown,
       fieldPermissions: entry_fieldPermissions,
-      iamCallable: entry_iamCallable
+      systemCallable: entry_systemCallable
     };
     let iamEntry_fieldNames = ["p_Sync"];
     let iamEntry_fieldPermissions = Object.fromEntries([[
@@ -368,12 +368,12 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
           _0: ["Admin"]
         }
       ]]);
-    let iamEntry_iamCallable = true;
+    let iamEntry_systemCallable = true;
     let iamEntry = {
       fieldNames: iamEntry_fieldNames,
       commandSchema: S.unknown,
       fieldPermissions: iamEntry_fieldPermissions,
-      iamCallable: iamEntry_iamCallable
+      systemCallable: iamEntry_systemCallable
     };
     let frag = makeFragment([
       "p_Sync(id: ID!): String",
@@ -393,12 +393,12 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
       return Stdlib_JsError.throwWithMessage("missing p_Other field");
     }
   });
-  globalThis.test("iamCallable query applies dual-auth to BOTH single and list fields", () => {
+  globalThis.test("systemCallable query applies dual-auth to BOTH single and list fields", () => {
     let entry_permission = {
       TAG: "AllowGroups",
       _0: ["Admin"]
     };
-    let entry_iamCallable = true;
+    let entry_systemCallable = true;
     let entry = {
       singleFieldName: "p_Item",
       listFieldName: "p_Items",
@@ -406,7 +406,7 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — iamCallable dual-auth", (
       stateSchema: S.unknown,
       authorization: undefined,
       permission: entry_permission,
-      iamCallable: entry_iamCallable
+      systemCallable: entry_systemCallable
     };
     let frag = makeFragment([], [
       "p_Item(id: ID!): Item",

package/tests/PgChangeFeedRelay_IntegrationTest.res

@@ -0,0 +1,148 @@
+// Live-Postgres integration suite for the change-feed relay (B2.4).
+//
+// Skipped unless PG_URL is set, so the default `pnpm test` stays dependency-free.
+// Run against a real database with e.g.:
+//   PG_URL=postgres://postgres:postgres@localhost:5432/postgres pnpm test
+//
+// Exercises the deployed propagation path end-to-end minus AWS: DCB events are
+// appended to a real `dcb_event` log, then `PgChangeFeedRelay_Runtime.relayWithPool`
+// drains the feed, transforms each event into the EventCollector `{id, meta, event}`
+// body, and hands the batch to an injected `sendBatch` (standing in for the SQS
+// SendMessage the entry point wires). Asserts the emitted bodies, the partition-tag
+// `id` derivation, and the checkpoint (a second drain sees nothing new).
+
+open JestGlobals
+open ReventlessCore
+open Reventless
+
+@val external processEnv: dict<string> = "process.env"
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let jsonObj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+let stored = (eventType, tags, data): DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data,
+  tags,
+  meta: ReventlessCore.Message.generateMeta(~service="relay-it"),
+}
+
+// Collect every JSON body handed to sendBatch across all drain pages.
+let capturingSendBatch = sink => async jsons => sink := sink.contents->Array.concat(jsons)
+
+let idOf = json =>
+  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get("id"))->Option.flatMap(JSON.Decode.string)
+
+switch processEnv->Dict.get("PG_URL") {
+| None =>
+  testSync("Postgres relay integration (skipped — set PG_URL to run)", () =>
+    expect(true)->toBe(true)
+  )
+| Some(url) =>
+  let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})
+
+  let makeLog = name =>
+    ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+      ~pool,
+      ~name,
+      ~indexes=[],
+      ~partitionTag=DcbTag.Simple({key: "orderId"}),
+      ~opts,
+    )
+
+  beforeAllAsync(async () => {
+    await ReventlessPostgres.PgSchema.ensureSchema(pool)
+    await ReventlessPostgres.PgSchema.truncateAll(pool)
+  })
+  afterAll(() => {
+    let _ = pool->ReventlessPostgres.PgDriver.endPool
+  })
+
+  describe("PgChangeFeedRelay end-to-end (append → drain → EventCollector bodies)", () => {
+    testPromise("relays each appended DCB event as an {id, meta, event} body", async () => {
+      let (_n, ops, _s) = makeLog("relay-basic")
+      let mk = i =>
+        stored("OrderPlaced", [{key: "orderId", value: "o-1"}], jsonObj([("i", JSON.Encode.int(i))]))
+      let _ = await ops.append([mk(0), mk(1), mk(2)])
+
+      let sink = ref([])
+      let processed = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-basic",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+
+      expect(processed)->toBe(3)
+      expect(sink.contents->Array.length)->toBe(3)
+
+      // Every body carries the derived id, the event type, and the producing service.
+      let first = sink.contents->Array.getUnsafe(0)
+      expect(idOf(first))->toEqual(Some("orderId:o-1"))
+      let obj = first->JSON.Decode.object->Option.getOrThrow
+      expect(obj->Dict.get("event")->Option.getOrThrow->JSON.stringify->String.includes("OrderPlaced"))->toBe(true)
+      let metaObj = obj->Dict.get("meta")->Option.flatMap(JSON.Decode.object)->Option.getOrThrow
+      expect(metaObj->Dict.get("service"))->toEqual(Some(JSON.Encode.string("relay-it")))
+    })
+
+    testPromise("checkpoints — a second drain from the same subscriber sees nothing new", async () => {
+      let (_n, ops, _s) = makeLog("relay-checkpoint")
+      let mk = i => stored("Fed", [{key: "orderId", value: "f"}], jsonObj([("i", JSON.Encode.int(i))]))
+      let _ = await ops.append([mk(0), mk(1)])
+
+      let sink = ref([])
+      let first = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-checkpoint",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      expect(first)->toBe(2)
+
+      let second = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-checkpoint",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      expect(second)->toBe(0)
+      // No extra bodies were emitted on the second pass.
+      expect(sink.contents->Array.length)->toBe(2)
+    })
+
+    testPromise("partitionTag pins the id to its tag on a multi-tag event", async () => {
+      let (_n, ops, _s) =
+        ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+          ~pool,
+          ~name="relay-pt",
+          ~indexes=[],
+          ~partitionTag=DcbTag.Simple({key: "customerId"}),
+          ~opts,
+        )
+      let ev =
+        stored(
+          "OrderPlaced",
+          [{key: "orderId", value: "o-9"}, {key: "customerId", value: "c-9"}],
+          jsonObj([("n", JSON.Encode.int(1))]),
+        )
+      let _ = await ops.append([ev])
+
+      // The relay receives the sury-encoded partition tag exactly as the builder emits it.
+      let partitionTagJson =
+        DcbTag.Simple({key: "customerId"})->S.reverseConvertToJsonOrThrow(
+          Reventless.DcbTag.derivedPartitionTagSchema,
+        )
+
+      let sink = ref([])
+      let _ = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-pt",
+        ~subscriber="relay-it",
+        ~partitionTagJson,
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      // Without the tag the id would be "orderId:o-9" (first tag); the tag pins it.
+      expect(idOf(sink.contents->Array.getUnsafe(0)))->toEqual(Some("customerId:c-9"))
+    })
+  })
+}

package/tests/PgChangeFeedRelay_IntegrationTest.res.mjs

@@ -0,0 +1,154 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as PgChangeFeedRelay_Runtime$ReventlessAws from "../src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
+
+let opts = {};
+
+function jsonObj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+function stored(eventType, tags, data) {
+  return {
+    eventType: eventType,
+    data: data,
+    tags: tags,
+    meta: Message$ReventlessCore.generateMeta("relay-it", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  };
+}
+
+function capturingSendBatch(sink) {
+  return async jsons => {
+    sink.contents = sink.contents.concat(jsons);
+  };
+}
+
+function idOf(json) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["id"]), Stdlib_JSON.Decode.string);
+}
+
+let url = process.env["PG_URL"];
+
+if (url !== undefined) {
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: url
+  });
+  let makeLog = name => DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, [], {
+    TAG: "Simple",
+    _0: {
+      key: "orderId"
+    }
+  }, undefined, opts, undefined, undefined);
+  globalThis.beforeAll(async () => {
+    await PgSchema$ReventlessPostgres.ensureSchema(pool);
+    return await PgSchema$ReventlessPostgres.truncateAll(pool);
+  });
+  globalThis.afterAll(() => {
+    PgDriver$ReventlessPostgres.endPool(pool);
+  });
+  globalThis.describe("PgChangeFeedRelay end-to-end (append → drain → EventCollector bodies)", () => {
+    globalThis.test("relays each appended DCB event as an {id, meta, event} body", async () => {
+      let match = makeLog("relay-basic");
+      let mk = i => stored("OrderPlaced", [{
+          key: "orderId",
+          value: "o-1"
+        }], Object.fromEntries([[
+          "i",
+          i
+        ]]));
+      await match[1].append([
+        mk(0),
+        mk(1),
+        mk(2)
+      ], undefined);
+      let sink = {
+        contents: []
+      };
+      let processed = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-basic", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(processed).toBe(3);
+      globalThis.expect(sink.contents.length).toBe(3);
+      let first = sink.contents[0];
+      globalThis.expect(idOf(first)).toEqual("orderId:o-1");
+      let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(first), undefined);
+      globalThis.expect(JSON.stringify(Stdlib_Option.getOrThrow(obj["event"], undefined)).includes("OrderPlaced")).toBe(true);
+      let metaObj = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(obj["meta"], Stdlib_JSON.Decode.object), undefined);
+      globalThis.expect(metaObj["service"]).toEqual("relay-it");
+    });
+    globalThis.test("checkpoints — a second drain from the same subscriber sees nothing new", async () => {
+      let match = makeLog("relay-checkpoint");
+      let mk = i => stored("Fed", [{
+          key: "orderId",
+          value: "f"
+        }], Object.fromEntries([[
+          "i",
+          i
+        ]]));
+      await match[1].append([
+        mk(0),
+        mk(1)
+      ], undefined);
+      let sink = {
+        contents: []
+      };
+      let first = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-checkpoint", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(first).toBe(2);
+      let second = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-checkpoint", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(second).toBe(0);
+      globalThis.expect(sink.contents.length).toBe(2);
+    });
+    globalThis.test("partitionTag pins the id to its tag on a multi-tag event", async () => {
+      let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "relay-pt", [], {
+        TAG: "Simple",
+        _0: {
+          key: "customerId"
+        }
+      }, undefined, opts, undefined, undefined);
+      let ev = stored("OrderPlaced", [
+        {
+          key: "orderId",
+          value: "o-9"
+        },
+        {
+          key: "customerId",
+          value: "c-9"
+        }
+      ], Object.fromEntries([[
+          "n",
+          1
+        ]]));
+      await match[1].append([ev], undefined);
+      let partitionTagJson = S.reverseConvertToJsonOrThrow({
+        TAG: "Simple",
+        _0: {
+          key: "customerId"
+        }
+      }, DcbTag$Reventless.derivedPartitionTagSchema);
+      let sink = {
+        contents: []
+      };
+      await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-pt", "relay-it", partitionTagJson, capturingSendBatch(sink));
+      globalThis.expect(idOf(sink.contents[0])).toEqual("customerId:c-9");
+    });
+  });
+} else {
+  globalThis.test("Postgres relay integration (skipped — set PG_URL to run)", () => {
+    globalThis.expect(true).toBe(true);
+  });
+}
+
+export {
+  opts,
+  jsonObj,
+  stored,
+  capturingSendBatch,
+  idOf,
+}
+/* url Not a pure module */

package/tests/PgChangeFeedRelay_RuntimeTest.res

@@ -42,3 +42,34 @@ describe("PgChangeFeedRelay_Runtime.toEventCollectorJson", () => {
     expect(obj->Dict.get("id"))->toEqual(Some(JSON.Encode.string("dcb")))
   })
 })
+
+describe("PgChangeFeedRelay_Runtime partitionTag (B2.3d)", () => {
+  let multiTagEvent = {
+    ...sampleEvent,
+    tags: [{key: "orderId", value: "o-1"}, {key: "customerId", value: "c-9"}],
+  }
+
+  testSync("a Simple partitionTag selects its tag for the id, not just the first", () => {
+    let pt = Reventless.DcbTag.Simple({key: "customerId"})
+    let json =
+      PgChangeFeedRelay_Runtime.toEventCollectorJson(multiTagEvent, ~partitionTag=pt)->Option.getOrThrow
+    let obj = json->JSON.Decode.object->Option.getOrThrow
+    // Without partitionTag the id would be "orderId:o-1" (first tag); the tag
+    // pins it to "customerId:c-9".
+    expect(obj->Dict.get("id"))->toEqual(Some(JSON.Encode.string("customerId:c-9")))
+  })
+
+  testSync("derivedPartitionTag round-trips through the sury schema (relay wire-format)", () => {
+    // The relay builder serialises partitionTag with this schema into HANDLER_CONFIG
+    // and PgChangeFeedRelay_Runtime.relay parses it back the same way. Guard the
+    // round-trip so a schema change can't silently break the id derivation.
+    let simple = Reventless.DcbTag.Simple({key: "courseId"})
+    let composite =
+      Reventless.DcbTag.Composite({keys: ["studentId", "courseId"], seps: [":"]})
+    [simple, composite]->Array.forEach(pt => {
+      let wire = pt->S.reverseConvertToJsonOrThrow(Reventless.DcbTag.derivedPartitionTagSchema)
+      let back = wire->S.parseJsonOrThrow(Reventless.DcbTag.derivedPartitionTagSchema)
+      expect(back)->toEqual(pt)
+    })
+  })
+})

package/tests/PgChangeFeedRelay_RuntimeTest.res.mjs

@@ -1,7 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as PgChangeFeedRelay_Runtime$ReventlessAws from "../src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs";
 
 let sampleEvent_data = Object.fromEntries([[
@@ -64,6 +66,69 @@ globalThis.describe("PgChangeFeedRelay_Runtime.toEventCollectorJson", () => {
   });
 });
 
+globalThis.describe("PgChangeFeedRelay_Runtime partitionTag (B2.3d)", () => {
+  let multiTagEvent_data = sampleEvent_data;
+  let multiTagEvent_tags = [
+    {
+      key: "orderId",
+      value: "o-1"
+    },
+    {
+      key: "customerId",
+      value: "c-9"
+    }
+  ];
+  let multiTagEvent_meta = {
+    service: "Orders",
+    time: "2026-07-05T10:00:00.000Z",
+    msgId: "m-1",
+    correlationId: "m-1"
+  };
+  let multiTagEvent = {
+    position: "00000000000000000042:00000000000000000007",
+    eventType: "OrderCreated",
+    data: multiTagEvent_data,
+    tags: multiTagEvent_tags,
+    meta: multiTagEvent_meta,
+    recordedAt: "2026-07-05T10:00:00.000Z"
+  };
+  globalThis.test("a Simple partitionTag selects its tag for the id, not just the first", () => {
+    let json = Stdlib_Option.getOrThrow(PgChangeFeedRelay_Runtime$ReventlessAws.toEventCollectorJson(multiTagEvent, {
+      TAG: "Simple",
+      _0: {
+        key: "customerId"
+      }
+    }), undefined);
+    let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(json), undefined);
+    globalThis.expect(obj["id"]).toEqual("customerId:c-9");
+  });
+  globalThis.test("derivedPartitionTag round-trips through the sury schema (relay wire-format)", () => {
+    let composite = {
+      TAG: "Composite",
+      _0: {
+        keys: [
+          "studentId",
+          "courseId"
+        ],
+        seps: [":"]
+      }
+    };
+    [
+      {
+        TAG: "Simple",
+        _0: {
+          key: "courseId"
+        }
+      },
+      composite
+    ].forEach(pt => {
+      let wire = S.reverseConvertToJsonOrThrow(pt, DcbTag$Reventless.derivedPartitionTagSchema);
+      let back = S.parseJsonOrThrow(wire, DcbTag$Reventless.derivedPartitionTagSchema);
+      globalThis.expect(back).toEqual(pt);
+    });
+  });
+});
+
 export {
   sampleEvent,
 }