@reventlessdev/reventless-aws 3.0.0-alpha.301 → 3.0.0-alpha.303

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -113,6 +113,71 @@ describe("toEntryWith heals a structure persisted before a required list existed
   })
 })
 
+// The `statusField` → `lifecycleField` rename has the same shape of problem one
+// severity down: the SDL field is a nullable `String`, so an absent key answers
+// null rather than blackholing the query. That is worse to find, not better —
+// lists keep rendering while command-menu filtering, board columns, group
+// sections, progress trackers and state diagrams all go quiet. Asserted because
+// the shim is the one part of the rename with nothing to fail at compile time.
+describe("toEntryWith reads a pre-rename structure's lifecycle field", () => {
+  let legacyStructure = Dict.fromArray([
+    (
+      "readModels",
+      JSON.Encode.array([
+        JSON.parseOrThrow(`{"name": "Customers", "statusField": "locationStatus"}`),
+      ]),
+    ),
+    (
+      "stateViewSlices",
+      JSON.Encode.array([JSON.parseOrThrow(`{"name": "Orders", "statusField": "status"}`)]),
+    ),
+  ])->JSON.Encode.object
+
+  let fieldOf = (~collection) =>
+    entry(~filter=false, legacyStructure)
+    ->Option.map(members(_, collection))
+    ->Option.flatMap(Array.get(_, 0))
+    ->Option.flatMap(c => c->Dict.get("lifecycleField"))
+
+  testSync("a read model's legacy key answers on the new name", () =>
+    expect(fieldOf(~collection="readModels"))->toEqual(
+      Some(JSON.Encode.string("locationStatus")),
+    )
+  )
+
+  testSync("so does a state view slice's", () =>
+    expect(fieldOf(~collection="stateViewSlices"))->toEqual(Some(JSON.Encode.string("status")))
+  )
+
+  testSync("a post-rename structure is left alone", () => {
+    let current = Dict.fromArray([
+      (
+        "readModels",
+        JSON.Encode.array([
+          JSON.parseOrThrow(`{"name": "Orders", "lifecycleField": "lifecycle", "statusField": "stale"}`),
+        ]),
+      ),
+    ])->JSON.Encode.object
+    let field =
+      entry(~filter=false, current)
+      ->Option.map(members(_, "readModels"))
+      ->Option.flatMap(Array.get(_, 0))
+      ->Option.flatMap(c => c->Dict.get("lifecycleField"))
+    expect(field)->toEqual(Some(JSON.Encode.string("lifecycle")))
+  })
+
+  testSync("a structure declaring neither still answers nothing", () => {
+    let neither = Dict.fromArray([
+      ("readModels", JSON.Encode.array([JSON.parseOrThrow(`{"name": "Products"}`)])),
+    ])->JSON.Encode.object
+    let component =
+      entry(~filter=false, neither)
+      ->Option.map(members(_, "readModels"))
+      ->Option.flatMap(Array.get(_, 0))
+    expect(component->Option.flatMap(c => c->Dict.get("lifecycleField")))->toEqual(None)
+  })
+})
+
 // The persisted structure is pre-filter, so this handler is a twin of the
 // in-memory `encodePluginStructureEntry` rather than a consequence of it. A shell
 // reading `internalQueryables` against a platform that emits it on only one
@@ -241,6 +306,52 @@ describe("bakeSelection", () => {
   )
 })
 
+// A journey travels from the deploy in the function's environment, exactly as the
+// default include-list does, carrying the key the deploy resolved. Deriving the
+// key a second time here would be a file written where `config.json` does not
+// send anybody, so the handler only reads it.
+describe("bakeJourney", () => {
+  let journey = raw => Platform_ComponentDefinitions_Lambda_Ops.bakeJourney(JSON.parseOrThrow(raw))
+
+  testSync("reads the group, the key and the include-list the deploy encoded", () => {
+    let decoded = journey(`{
+      "group": "Fulfilment",
+      "key": "component-manifest-fulfilment.json",
+      "components": [{"plugin": "Ordering", "views": ["Orders"], "derived": ["lifecycles"]}]
+    }`)
+    expect(decoded->Option.map(j => (j.group, j.key, j.selections->Array.map(s => s.plugin))))->toEqual(
+      Some(("Fulfilment", "component-manifest-fulfilment.json", ["Ordering"])),
+    )
+    expect(
+      decoded->Option.flatMap(j => j.selections->Array.get(0))->Option.flatMap(s => s.derived),
+    )->toEqual(Some(["lifecycles"]))
+  })
+
+  // Absent is not empty here either: a journey whose selection names no `views`
+  // takes every public view of that plugin.
+  testSync("keeps a selection's absent lists absent", () => {
+    let decoded = journey(`{"group": "Shopper", "key": "s.json", "components": [{"plugin": "Catalog"}]}`)
+    expect(
+      decoded->Option.flatMap(j => j.selections->Array.get(0))->Option.flatMap(s => s.views),
+    )->toEqual(None)
+  })
+
+  // Both are what the write needs. A journey missing either would be baked to a
+  // key nobody granted or reported as belonging to no audience.
+  testSync("refuses an entry naming no group or no key", () => {
+    expect(journey(`{"key": "s.json", "components": []}`)->Option.isNone)->toBe(true)
+    expect(journey(`{"group": "Shopper", "components": []}`)->Option.isNone)->toBe(true)
+  })
+
+  // A journey that curates nothing is still a journey — it writes an empty file
+  // rather than falling back to the default one.
+  testSync("a journey with no components decodes to an empty include-list", () =>
+    expect(
+      journey(`{"group": "Shopper", "key": "s.json"}`)->Option.map(j => j.selections->Array.length),
+    )->toEqual(Some(0))
+  )
+})
+
 // The bake reads a read model the deploy updates asynchronously, so "is this the
 // deployment I was asked to bake" is a question it has to be able to answer. The
 // answer is an equality check against the key each plugin stack just wrote.

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -67,6 +67,42 @@ globalThis.describe("toEntryWith heals a structure persisted before a required l
   });
 });
 
+globalThis.describe("toEntryWith reads a pre-rename structure's lifecycle field", () => {
+  let legacyStructure = Object.fromEntries([
+    [
+      "readModels",
+      [JSON.parse(`{"name": "Customers", "statusField": "locationStatus"}`)]
+    ],
+    [
+      "stateViewSlices",
+      [JSON.parse(`{"name": "Orders", "statusField": "status"}`)]
+    ]
+  ]);
+  let fieldOf = collection => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, legacyStructure), __x => members(__x, collection)), __x => __x[0]), c => c["lifecycleField"]);
+  globalThis.test("a read model's legacy key answers on the new name", () => {
+    globalThis.expect(fieldOf("readModels")).toEqual("locationStatus");
+  });
+  globalThis.test("so does a state view slice's", () => {
+    globalThis.expect(fieldOf("stateViewSlices")).toEqual("status");
+  });
+  globalThis.test("a post-rename structure is left alone", () => {
+    let current = Object.fromEntries([[
+        "readModels",
+        [JSON.parse(`{"name": "Orders", "lifecycleField": "lifecycle", "statusField": "stale"}`)]
+      ]]);
+    let field = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, current), __x => members(__x, "readModels")), __x => __x[0]), c => c["lifecycleField"]);
+    globalThis.expect(field).toEqual("lifecycle");
+  });
+  globalThis.test("a structure declaring neither still answers nothing", () => {
+    let neither = Object.fromEntries([[
+        "readModels",
+        [JSON.parse(`{"name": "Products"}`)]
+      ]]);
+    let component = Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, neither), __x => members(__x, "readModels")), __x => __x[0]);
+    globalThis.expect(Stdlib_Option.flatMap(component, c => c["lifecycleField"])).toEqual(undefined);
+  });
+});
+
 globalThis.describe("toEntryWith carries Internal queryables on the filtered field", () => {
   let mixed = Object.fromEntries([
     [
@@ -154,6 +190,37 @@ globalThis.describe("bakeSelection", () => {
   });
 });
 
+globalThis.describe("bakeJourney", () => {
+  globalThis.test("reads the group, the key and the include-list the deploy encoded", () => {
+    let decoded = Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeJourney(JSON.parse(`{
+      "group": "Fulfilment",
+      "key": "component-manifest-fulfilment.json",
+      "components": [{"plugin": "Ordering", "views": ["Orders"], "derived": ["lifecycles"]}]
+    }`));
+    globalThis.expect(Stdlib_Option.map(decoded, j => [
+      j.group,
+      j.key,
+      j.selections.map(s => s.plugin)
+    ])).toEqual([
+      "Fulfilment",
+      "component-manifest-fulfilment.json",
+      ["Ordering"]
+    ]);
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(decoded, j => j.selections[0]), s => s.derived)).toEqual(["lifecycles"]);
+  });
+  globalThis.test("keeps a selection's absent lists absent", () => {
+    let decoded = Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeJourney(JSON.parse(`{"group": "Shopper", "key": "s.json", "components": [{"plugin": "Catalog"}]}`));
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(decoded, j => j.selections[0]), s => s.views)).toEqual(undefined);
+  });
+  globalThis.test("refuses an entry naming no group or no key", () => {
+    globalThis.expect(Stdlib_Option.isNone(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeJourney(JSON.parse(`{"key": "s.json", "components": []}`)))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeJourney(JSON.parse(`{"group": "Shopper", "components": []}`)))).toBe(true);
+  });
+  globalThis.test("a journey with no components decodes to an empty include-list", () => {
+    globalThis.expect(Stdlib_Option.map(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeJourney(JSON.parse(`{"group": "Shopper", "key": "s.json"}`)), j => j.selections.length)).toEqual(0);
+  });
+});
+
 globalThis.describe("pendingRegistrations", () => {
   let row = (name, key, param) => {
     let item = Object.fromEntries([[

package/tests/QueryDbResolvers_AppSyncTest.res.mjs

@@ -19,18 +19,18 @@ globalThis.describe("QueryDbResolvers_AppSync.internalRowRequiredAttr", () => {
 
 globalThis.describe("AppSync_Resolver_Retrying.Functions.listAllItemsConnection", () => {
   globalThis.test("with ~requireAttribute emits an attribute_exists filter that excludes internal rows", () => {
-    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, "name", undefined, undefined);
+    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, "name", undefined, undefined, undefined, undefined);
     globalThis.expect(code.includes("attribute_exists(#name)")).toBe(true);
     globalThis.expect(code.includes("names['#name'] = 'name'")).toBe(true);
   });
   globalThis.test("without ~requireAttribute emits no attribute_exists filter (default read models unchanged)", () => {
-    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined);
+    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
     globalThis.expect(code.includes("attribute_exists")).toBe(false);
   });
 });
 
 globalThis.describe("listAllItemsConnection — Scan cursor round-trip (paging fixes 1–3)", () => {
-  let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined);
+  let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
   globalThis.test("Fix 1: response encodes the real nextToken as the cursor", () => {
     globalThis.expect(code.includes("const next = ctx.result?.nextToken ?? null;")).toBe(true);
     globalThis.expect(code.includes("util.base64Encode(JSON.stringify({ token: next, index: i }))")).toBe(true);

package/tests/StateChangeDescriptorParityTest.res

@@ -29,7 +29,7 @@ describe("state-change descriptor parity", () => {
   testAsync("every implementation builds the same descriptor", async () => {
     let cases = await buildAll()
     // A silent zero-case run would pass while asserting nothing.
-    expect(cases->Array.length)->toBe(6)
+    expect(cases->Array.length)->toBe(11)
     cases->Array.forEach(c => {
       expect((c.name, c.relay))->toEqual((c.name, c.local))
       expect((c.name, c.postgres))->toEqual((c.name, c.local))
@@ -55,4 +55,85 @@ describe("state-change descriptor parity", () => {
     | None => expect("oversized case missing")->toBe("present")
     }
   })
+
+  // The live channel is the third place a retired row could reach a caller the
+  // resolvers refuse it to, and the only one that cannot be scoped per
+  // subscriber — the channel is keyed by view and entity, and everyone watching
+  // receives the frame. So the payload has to go, in all three implementations.
+  testAsync("a retired row publishes as metadata only, everywhere", async () => {
+    let cases = await buildAll()
+    let keyOf = (d: JSON.t, k) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(k))
+    let byName = name => cases->Array.find(c => c.name == name)
+
+    switch byName("retired row degrades to metadata only") {
+    | Some(c) =>
+      // Not just the payload: the sort value is a timestamp off a row the
+      // subscriber may not read, and this row carries one.
+      expect((keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((None, None))
+      expect((keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((None, None))
+      expect((keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((None, None))
+      // `Updated`, never `Removed`: the row is not gone. Saying so would be
+      // false for an elevated subscriber reading with `includeRetired`, and
+      // false again the moment the row is restored.
+      expect(keyOf(c.local, "changeKind"))->toEqual(Some(JSON.Encode.string("Updated")))
+    | None => expect("retired case missing")->toBe("present")
+    }
+
+    // The control that separates "drops a retired row" from "drops any row on a
+    // view that declares the flag".
+    switch byName("live row with a retirement flag carries the row") {
+    | Some(c) =>
+      expect(keyOf(c.local, "state")->Option.isSome)->toBe(true)
+      expect(keyOf(c.relay, "state")->Option.isSome)->toBe(true)
+      expect(keyOf(c.postgres, "state")->Option.isSome)->toBe(true)
+    | None => expect("live-with-flag case missing")->toBe("present")
+    }
+  })
+
+  // The state form, where the predicate is membership rather than equality. Both
+  // states are asserted, so an implementation comparing against only the first
+  // member of the set fails on the second — which is the shape of mistake a set
+  // invites and a single value could not.
+  testAsync("a row in any retired state publishes as metadata only", async () => {
+    let cases = await buildAll()
+    let keyOf = (d: JSON.t, k) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(k))
+    let byName = name => cases->Array.find(c => c.name == name)
+
+    [
+      "row in the first retired state degrades to metadata only",
+      "row in the second retired state degrades to metadata only",
+    ]->Array.forEach(name =>
+      switch byName(name) {
+      | Some(c) =>
+        expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+        expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+        expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+      | None => expect(name ++ " missing")->toBe("present")
+      }
+    )
+
+    // The control for the state form: a live state on the same lifecycle, so an
+    // implementation dropping every row of a view that declares states fails.
+    switch byName("row in a live state carries the row") {
+    | Some(c) =>
+      expect((
+        keyOf(c.local, "state")->Option.isSome,
+        keyOf(c.relay, "state")->Option.isSome,
+        keyOf(c.postgres, "state")->Option.isSome,
+      ))->toEqual((true, true, true))
+    | None => expect("live-state case missing")->toBe("present")
+    }
+  })
 })

package/tests/StateChangeDescriptorParityTest.res.mjs

@@ -11,7 +11,7 @@ function buildAll(prim) {
 globalThis.describe("state-change descriptor parity", () => {
   globalThis.test("every implementation builds the same descriptor", async () => {
     let cases = await StateChangeDescriptorParityMjs.buildAll();
-    globalThis.expect(cases.length).toBe(6);
+    globalThis.expect(cases.length).toBe(11);
     cases.forEach(c => {
       globalThis.expect([
         c.name,
@@ -52,6 +52,102 @@ globalThis.describe("state-change descriptor parity", () => {
       globalThis.expect("oversized case missing").toBe("present");
     }
   });
+  globalThis.test("a retired row publishes as metadata only, everywhere", async () => {
+    let cases = await StateChangeDescriptorParityMjs.buildAll();
+    let keyOf = (d, k) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(d), o => o[k]);
+    let byName = name => cases.find(c => c.name === name);
+    let c = byName("retired row degrades to metadata only");
+    if (c !== undefined) {
+      globalThis.expect([
+        keyOf(c.local, "state"),
+        keyOf(c.local, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect([
+        keyOf(c.relay, "state"),
+        keyOf(c.relay, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect([
+        keyOf(c.postgres, "state"),
+        keyOf(c.postgres, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect(keyOf(c.local, "changeKind")).toEqual("Updated");
+    } else {
+      globalThis.expect("retired case missing").toBe("present");
+    }
+    let c$1 = byName("live row with a retirement flag carries the row");
+    if (c$1 !== undefined) {
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.local, "state"))).toBe(true);
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.relay, "state"))).toBe(true);
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.postgres, "state"))).toBe(true);
+    } else {
+      globalThis.expect("live-with-flag case missing").toBe("present");
+    }
+  });
+  globalThis.test("a row in any retired state publishes as metadata only", async () => {
+    let cases = await StateChangeDescriptorParityMjs.buildAll();
+    let keyOf = (d, k) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(d), o => o[k]);
+    let byName = name => cases.find(c => c.name === name);
+    [
+      "row in the first retired state degrades to metadata only",
+      "row in the second retired state degrades to metadata only"
+    ].forEach(name => {
+      let c = byName(name);
+      if (c !== undefined) {
+        globalThis.expect([
+          name,
+          keyOf(c.local, "state"),
+          keyOf(c.local, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+        globalThis.expect([
+          name,
+          keyOf(c.relay, "state"),
+          keyOf(c.relay, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+        globalThis.expect([
+          name,
+          keyOf(c.postgres, "state"),
+          keyOf(c.postgres, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+      } else {
+        globalThis.expect(name + " missing").toBe("present");
+      }
+    });
+    let c = byName("row in a live state carries the row");
+    if (c !== undefined) {
+      globalThis.expect([
+        Stdlib_Option.isSome(keyOf(c.local, "state")),
+        Stdlib_Option.isSome(keyOf(c.relay, "state")),
+        Stdlib_Option.isSome(keyOf(c.postgres, "state"))
+      ]).toEqual([
+        true,
+        true,
+        true
+      ]);
+    } else {
+      globalThis.expect("live-state case missing").toBe("present");
+    }
+  });
 });
 
 export {

package/tests/Util_DynamoDbStreamTest.res

@@ -0,0 +1,43 @@
+open JestGlobals
+
+// Guards that a stream resource describes its own stream.
+//
+// `toStreamResource` used to leave `resourceInfo` at its `NoInfo` default even
+// though it was built FROM a stream ARN. The event-topic resources a DynamoDB
+// stream publisher exports are these, so every reader that asks an event topic
+// for its stream ARN — `Upload_Claim_S3` does, to grant its Lambda
+// `dynamodb:GetRecords` — took the arm that has no ARN to give and failed the
+// deploy. The failure only surfaced once a plugin's first StateChangeSlice
+// declared a `@storageRef` field, which is what registers the claimer at all.
+
+let resolve = (output: Pulumi.Output.t<'a>): promise<'a> =>
+  Promise.make((resolve, _) => {
+    let _ = output->Pulumi.Output.apply(value => resolve(value))
+  })
+
+let streamArn = "arn:aws:dynamodb:eu-west-1:123456789012:table/CatalogDcbEventLog-abc123/stream/2026-01-01T00:00:00.000"
+
+let tableResource = ReventlessInfra.Adapter.make(
+  ~name="CatalogDcbEventLog-abc123"->Pulumi.Output.make,
+  ~id="CatalogDcbEventLog-abc123"->Pulumi.Output.make,
+  ~urn="arn:aws:dynamodb:eu-west-1:123456789012:table/CatalogDcbEventLog-abc123"->Pulumi.Output.make,
+  ~service=AWS.DynamoDbStream.service->Pulumi.Output.make,
+  ~resourceInfo=ReventlessInfra.Adapter.StreamSource({sourceUrn: streamArn})->Pulumi.Output.make,
+)
+
+describe("Util_DynamoDbStream.toStreamResource", () => {
+  test("carries the source stream in resourceInfo", async () => {
+    let stream = tableResource->Util_DynamoDbStream.toStreamResource
+    let resourceInfo = await stream.resourceInfo->resolve
+    expect(resourceInfo)->toEqual(ReventlessInfra.Adapter.StreamSource({sourceUrn: streamArn}))
+  })
+
+  test("answers its own stream ARN", async () => {
+    let arn =
+      await tableResource
+      ->Util_DynamoDbStream.toStreamResource
+      ->Util_DynamoDbStream.streamArnFromDynamoDbTableResource
+      ->resolve
+    expect(arn)->toBe(streamArn)
+  })
+})

package/tests/Util_DynamoDbStreamTest.res.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as AWS$ReventlessAws from "../src/adapter/AWS.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as Util_DynamoDbStream$ReventlessAws from "../src/util/Util_DynamoDbStream.res.mjs";
+
+function resolve(output) {
+  return new Promise((resolve, param) => {
+    output.apply(value => resolve(value));
+  });
+}
+
+let streamArn = "arn:aws:dynamodb:eu-west-1:123456789012:table/CatalogDcbEventLog-abc123/stream/2026-01-01T00:00:00.000";
+
+let tableResource = Adapter$ReventlessInfra.make(Pulumi.output("CatalogDcbEventLog-abc123"), Pulumi.output("CatalogDcbEventLog-abc123"), Pulumi.output("arn:aws:dynamodb:eu-west-1:123456789012:table/CatalogDcbEventLog-abc123"), Pulumi.output(AWS$ReventlessAws.DynamoDbStream.service), Pulumi.output({
+  TAG: "StreamSource",
+  sourceUrn: streamArn
+}), undefined, undefined, undefined, undefined, undefined);
+
+globalThis.describe("Util_DynamoDbStream.toStreamResource", () => {
+  globalThis.test("carries the source stream in resourceInfo", async () => {
+    let stream = Util_DynamoDbStream$ReventlessAws.toStreamResource(tableResource);
+    let resourceInfo = await resolve(stream.resourceInfo);
+    globalThis.expect(resourceInfo).toEqual({
+      TAG: "StreamSource",
+      sourceUrn: streamArn
+    });
+  });
+  globalThis.test("answers its own stream ARN", async () => {
+    let arn = await resolve(Util_DynamoDbStream$ReventlessAws.streamArnFromDynamoDbTableResource(Util_DynamoDbStream$ReventlessAws.toStreamResource(tableResource)));
+    globalThis.expect(arn).toBe(streamArn);
+  });
+});
+
+export {
+  resolve,
+  streamArn,
+  tableResource,
+}
+/* tableResource Not a pure module */

package/tests/Util_ShellConfigTest.res

@@ -81,6 +81,113 @@ describe("Util_ShellConfig.fields — bakedManifest", () => {
   })
 })
 
+// ── Journeys ──────────────────────────────────────────────────────────────
+//
+// One curated surface per audience, beside the default one. The property under
+// test throughout is that a deployment declaring none is untouched: every
+// deployment that predates journeys has exactly one audience, and its
+// config.json must not grow a key for a feature it does not use.
+describe("Util_ShellConfig.fields — journeys", () => {
+  let withJourneys = (
+    ~journeys: array<ReventlessInfra.Platform.bakedJourney>,
+  ): ReventlessInfra.Platform.bakedManifest => {
+    components: [{plugin: "Catalog", views: ["Products"], commands: []}],
+    journeys,
+  }
+
+  let shopper: ReventlessInfra.Platform.bakedJourney = {
+    group: "Shopper",
+    components: [{plugin: "Catalog", views: ["Products"], commands: []}],
+  }
+
+  let fulfilment: ReventlessInfra.Platform.bakedJourney = {
+    group: "Fulfilment",
+    components: [{plugin: "Ordering", views: ["Orders"], commands: ["ShipOrder"]}],
+    key: "fulfilment.json",
+  }
+
+  testSync("a bake declaring no journeys writes no map", () => {
+    let out = Util_ShellConfig.fields(
+      ~computed,
+      ~bakedManifest={components: [{plugin: "Catalog", views: ["Products"], commands: []}]},
+    )
+    expect(out->Dict.get("journeyManifestUrls")->Option.isNone)->toBe(true)
+  })
+
+  testSync("an empty journeys array is the same as none", () => {
+    let out = Util_ShellConfig.fields(~computed, ~bakedManifest=withJourneys(~journeys=[]))
+    expect(out->Dict.get("journeyManifestUrls")->Option.isNone)->toBe(true)
+  })
+
+  // The default journey keeps `manifestUrl`, so a caller matching no declared
+  // group lands where every caller landed before.
+  testSync("keeps manifestUrl as the default journey", () => {
+    let out = Util_ShellConfig.fields(~computed, ~bakedManifest=withJourneys(~journeys=[shopper]))
+    expect(out->get("manifestUrl"))->toEqual(JSON.Encode.string("/component-manifest.json"))
+  })
+
+  testSync("maps each declared group to its own file", () => {
+    let out = Util_ShellConfig.fields(
+      ~computed,
+      ~bakedManifest=withJourneys(~journeys=[shopper, fulfilment]),
+    )
+    expect(out->get("journeyManifestUrls"))->toEqual(
+      JSON.Encode.object(
+        Dict.fromArray([
+          // Derived from the group, lower-cased, because a key is part of a URL.
+          ("Shopper", JSON.Encode.string("/component-manifest-shopper.json")),
+          // Named explicitly, and the declaration wins.
+          ("Fulfilment", JSON.Encode.string("/fulfilment.json")),
+        ]),
+      ),
+    )
+  })
+
+  // The URL a shell fetches and the key the bake writes are one string, derived
+  // once — a second derivation is a file written where nothing looks for it. So
+  // every key the bake writes is published, and the default one is published as
+  // `manifestUrl` rather than in the map.
+  testSync("publishes the URL of every key the bake writes, exactly once", () => {
+    let bake = withJourneys(~journeys=[shopper, fulfilment])
+    let out = Util_ShellConfig.fields(~computed, ~bakedManifest=bake)
+    let published = Array.concat(
+      out->get("manifestUrl")->JSON.Decode.string->Option.mapOr([], url => [url]),
+      out
+      ->get("journeyManifestUrls")
+      ->JSON.Decode.object
+      ->Option.getOr(Dict.make())
+      ->Dict.valuesToArray
+      ->Array.filterMap(JSON.Decode.string),
+    )
+    expect(published)->toEqual(
+      ReventlessCore.Platform_BakedManifest.files(~config=bake)->Array.map(((key, _)) =>
+        "/" ++ key
+      ),
+    )
+  })
+
+  // A passthrough cannot redirect a key the deploy computes — the same rule
+  // `manifestUrl` already carries, extended to the map beside it.
+  testSync("a shellConfig journey map fails the deploy rather than redirecting it", () => {
+    let failure = try {
+      let _ = Util_ShellConfig.fields(
+        ~computed,
+        ~bakedManifest=withJourneys(~journeys=[shopper]),
+        ~shellConfig=Dict.fromArray([
+          ("journeyManifestUrls", JSON.Encode.object(Dict.make())),
+        ]),
+      )
+      None
+    } catch {
+    | Failure(message) => Some(message)
+    }
+    switch failure {
+    | Some(message) => expect(message->String.includes("journeyManifestUrls"))->toBe(true)
+    | None => fail("a shellConfig key redirecting the computed journey map must fail the deploy")
+    }
+  })
+})
+
 describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
   testSync("shell-owned keys land verbatim, under the computed ones", () => {
     let out = Util_ShellConfig.fields(