@reventlessdev/reventless-local 3.0.0-alpha.113 → 3.0.0-alpha.115

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs

@@ -76,6 +76,58 @@ function Make(Bus) {
     let syncAll = () => {
       allItems.contents = flattenStore(store.contents);
     };
+    let expiries = {
+      contents: {}
+    };
+    let recordExpiry = (id, subKey, ttl) => {
+      if (ttl !== undefined) {
+        let m = expiries.contents[id];
+        let subExp;
+        if (m !== undefined) {
+          subExp = m;
+        } else {
+          let m$1 = {};
+          expiries.contents[id] = m$1;
+          subExp = m$1;
+        }
+        subExp[subKey] = ttl;
+        return;
+      }
+      let m$2 = expiries.contents[id];
+      if (m$2 !== undefined) {
+        return Stdlib_Dict.$$delete(m$2, subKey);
+      }
+    };
+    let purgeExpired = () => {
+      let now = Date.now() / 1000.0;
+      let removedAny = {
+        contents: false
+      };
+      Object.entries(expiries.contents).forEach(param => {
+        let subExp = param[1];
+        let id = param[0];
+        Object.entries(subExp).forEach(param => {
+          if (param[1] > now) {
+            return;
+          }
+          let subKey = param[0];
+          let sm = store.contents[id];
+          if (sm !== undefined) {
+            if (Stdlib_Option.isSome(sm[subKey])) {
+              Stdlib_Dict.$$delete(sm, subKey);
+              removedAny.contents = true;
+            }
+            if (Object.keys(sm).length === 0) {
+              Stdlib_Dict.$$delete(store.contents, id);
+            }
+          }
+          Stdlib_Dict.$$delete(subExp, subKey);
+        });
+      });
+      if (removedAny.contents) {
+        return syncAll();
+      }
+    };
     let getOrCreateSubMap = partitionKey => {
       let m = store.contents[partitionKey];
       if (m !== undefined) {
@@ -85,11 +137,17 @@ function Make(Bus) {
       store.contents[partitionKey] = m$1;
       return m$1;
     };
-    let load = async id => ({
-      TAG: "Ok",
-      _0: sortedItems(store.contents, id)
-    });
-    let loadStream = id => Stream.fromIterable(sortedItems(store.contents, id));
+    let load = async id => {
+      purgeExpired();
+      return {
+        TAG: "Ok",
+        _0: sortedItems(store.contents, id)
+      };
+    };
+    let loadStream = id => {
+      purgeExpired();
+      return Stream.fromIterable(sortedItems(store.contents, id));
+    };
     let entityKeyFor = (id, subKey) => {
       if (subIdField !== undefined) {
         return id + "-" + subKey;
@@ -106,10 +164,11 @@ function Make(Bus) {
       let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
       Bus.publishStateChange(name, descriptor);
     };
-    let save = async (id, state, _saveMode, _ttl) => {
+    let save = async (id, state, _saveMode, ttl) => {
       let subKey = getSubKey(state, subIdField);
       let subMap = getOrCreateSubMap(id);
       subMap[subKey] = state;
+      recordExpiry(id, subKey, ttl);
       syncAll();
       publishUpdated(id, state);
       return {
@@ -120,9 +179,11 @@ function Make(Bus) {
     let saveBatch = async batch => {
       batch.forEach(param => {
         let state = param[1];
+        let id = param[0];
         let subKey = getSubKey(state, subIdField);
-        let subMap = getOrCreateSubMap(param[0]);
+        let subMap = getOrCreateSubMap(id);
         subMap[subKey] = state;
+        recordExpiry(id, subKey, param[2]);
       });
       syncAll();
       batch.forEach(param => publishUpdated(param[0], param[1]));
@@ -131,10 +192,27 @@ function Make(Bus) {
         _0: undefined
       };
     };
-    let count = async (_id, _fieldName, inc) => ({
-      TAG: "Ok",
-      _0: inc
-    });
+    let count = async (id, fieldName, inc) => {
+      let subMap = getOrCreateSubMap(id);
+      let existing = Stdlib_Option.flatMap(subMap[""], Stdlib_JSON.Decode.object);
+      let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+      let next = current + inc | 0;
+      let obj = {};
+      if (existing !== undefined) {
+        Object.entries(existing).forEach(param => {
+          obj[param[0]] = param[1];
+        });
+      }
+      obj["id"] = id;
+      obj[fieldName] = next;
+      subMap[""] = obj;
+      syncAll();
+      publishUpdated(id, obj);
+      return {
+        TAG: "Ok",
+        _0: next
+      };
+    };
     let $$delete = async (id, subIdOpt) => {
       if (subIdOpt !== undefined) {
         let subValue = subIdOpt[1];
@@ -209,8 +287,14 @@ function Make(Bus) {
       deleteBatch: deleteBatch
     };
     Bus.registerQueryDb(name, ops);
-    Bus.registerQueryDbScan(name, () => allItems.contents);
-    Bus.registerQueryDbStream(name, () => Stream.fromIterable(allItems.contents));
+    Bus.registerQueryDbScan(name, () => {
+      purgeExpired();
+      return allItems.contents;
+    });
+    Bus.registerQueryDbStream(name, () => {
+      purgeExpired();
+      return Stream.fromIterable(allItems.contents);
+    });
     return {
       resources: [],
       dataSourceName: Pulumi.output(""),

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -260,7 +260,30 @@ let makeStorage = (
     Ok()
   }
 
-  let count: QueryDb.count<string> = async (_id, _fieldName, inc) => Ok(inc)
+  // Mirror DynamoDB's `ADD #fieldName :inc` on key {id}: read the counter field
+  // on the partition-key item (counters are single-state, sub_key=""), add `inc`,
+  // upsert, and return the NEW total. The previous `Ok(inc)` echoed the increment
+  // and never persisted, so the total was wrong and `loadStream` never saw it.
+  let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+    let existing = rowsFor(id)->Array.get(0)->Option.flatMap(JSON.Decode.object)
+    let current =
+      existing
+      ->Option.flatMap(o => o->Dict.get(fieldName))
+      ->Option.flatMap(JSON.Decode.float)
+      ->Option.mapOr(0, Float.toInt)
+    let next = current + inc
+    let obj = Dict.make()
+    switch existing {
+    | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => obj->Dict.set(k, v))
+    | None => ()
+    }
+    obj->Dict.set("id", JSON.Encode.string(id))
+    obj->Dict.set(fieldName, JSON.Encode.int(next))
+    let newItem = JSON.Encode.object(obj)
+    saveOne(id, newItem, None)
+    publishUpdated(id, newItem)
+    Ok(next)
+  }
 
   let deleteOne = (id: string, subIdOpt) =>
     switch subIdOpt {

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -209,10 +209,25 @@ function makeStorage(db, bus, name, indexes, subIdField) {
       _0: undefined
     };
   };
-  let count = async (_id, _fieldName, inc) => ({
-    TAG: "Ok",
-    _0: inc
-  });
+  let count = async (id, fieldName, inc) => {
+    let existing = Stdlib_Option.flatMap(rowsFor(id)[0], Stdlib_JSON.Decode.object);
+    let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+    let next = current + inc | 0;
+    let obj = {};
+    if (existing !== undefined) {
+      Object.entries(existing).forEach(param => {
+        obj[param[0]] = param[1];
+      });
+    }
+    obj["id"] = id;
+    obj[fieldName] = next;
+    saveOne(id, obj, undefined);
+    publishUpdated(id, obj);
+    return {
+      TAG: "Ok",
+      _0: next
+    };
+  };
   let deleteOne = (id, subIdOpt) => {
     if (subIdOpt !== undefined) {
       return SqliteDriver$ReventlessLocal.run(deleteBySubKeyStmt, [

package/src/adapter/SqliteDriver.res

@@ -46,7 +46,12 @@ let transaction = (db, fn) => {
     result
   } catch {
   | exn =>
-    exec(db, "ROLLBACK")
+    // Roll back, but never let a failing ROLLBACK replace the original error —
+    // the original is the diagnostic one; a rollback failure (e.g. no active
+    // transaction) would otherwise mask it.
+    try exec(db, "ROLLBACK") catch {
+    | _ => ()
+    }
     throw(exn)
   }
 }

package/src/adapter/SqliteDriver.res.mjs

@@ -57,7 +57,11 @@ function transaction(db, fn) {
     db.exec("COMMIT");
     return result;
   } catch (exn) {
-    db.exec("ROLLBACK");
+    try {
+      db.exec("ROLLBACK");
+    } catch (exn$1) {
+      
+    }
     throw exn;
   }
 }

package/src/components/DcbEventLog_Builder.res

@@ -3,7 +3,13 @@
 module Make = (Bus: LocalBus.T) => {
   module EventTopicPublisher = LocalEventTopicPublisher.Make(Bus)
 
-  module Inner = ReventlessCore.DcbEventLog_Builder.Make(DcbEventLogStorage_InMemory, EventTopicPublisher)
+  // Use the backend-aware storage functor (as Platform does), not the plain
+  // module: the functor consults BackendState so a standalone DCB log honours
+  // REVENTLESS_LOCAL_BACKEND=sqlite, and it registers the read with the Bus so
+  // `Bus.getDcbEventLogRead` can see it. The plain module did neither — the log
+  // silently stayed in memory under SQLite and was invisible to bus readers.
+  module Storage = DcbEventLogStorage_InMemory.Make(Bus)
+  module Inner = ReventlessCore.DcbEventLog_Builder.Make(Storage, EventTopicPublisher)
   type component = ReventlessInfra.DcbEventLog.component
   let make: (
     ~name: string,

package/src/components/DcbEventLog_Builder.res.mjs

@@ -7,11 +7,11 @@ import * as DcbEventLogStorage_InMemory$ReventlessLocal from "../adapter/DcbEven
 
 function Make(Bus) {
   let EventTopicPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(Bus);
-  let Inner = DcbEventLog_Builder$ReventlessCore.Make({
-    make: DcbEventLogStorage_InMemory$ReventlessLocal.make
-  })(EventTopicPublisher);
+  let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(Bus);
+  let Inner = DcbEventLog_Builder$ReventlessCore.Make(Storage)(EventTopicPublisher);
   return {
     EventTopicPublisher: EventTopicPublisher,
+    Storage: Storage,
     Inner: Inner,
     make: Inner.make,
     operations: Component$ReventlessInfra.operations

package/src/test/Mocks/MockEventLogStorage.res

@@ -15,7 +15,7 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
   let append: ReventlessCore.EventLog.append<string, JSON.t> = async (_seqNr, id, jsons) => {
     if failNextAppends.contents > 0 {
       failNextAppends := failNextAppends.contents - 1
-      Error("mock append failure")
+      Error(ReventlessCore.EventLog.StorageFailure("mock append failure"))
     } else {
       let existing = events.contents->Dict.get(id)->Option.getOr([])
       events.contents->Dict.set(id, existing->Array.concat(jsons))

package/src/test/Mocks/MockEventLogStorage.res.mjs

@@ -21,7 +21,10 @@ function make($staropt$star, $staropt$star$1) {
       failNextAppends.contents = failNextAppends.contents - 1 | 0;
       return {
         TAG: "Error",
-        _0: "mock append failure"
+        _0: {
+          TAG: "StorageFailure",
+          _0: "mock append failure"
+        }
       };
     }
     let existing = Stdlib_Option.getOr(events.contents[id], []);

package/tests/adapter/BackendParityTest.res

@@ -70,6 +70,70 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
+  testPromise("QueryDb: count returns a running total and loadStream reflects it under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-count", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      // First increment creates the counter item and returns the new total.
+      let r1 = await ops.count("prod-1", "orderCount", 3)
+      expect(r1)->toEqual(Ok(3))
+      // Second increment accumulates (not just echoes the increment).
+      let r2 = await ops.count("prod-1", "orderCount", 2)
+      expect(r2)->toEqual(Ok(5))
+
+      // loadStream must see the persisted counter — count is not a side channel.
+      let items =
+        await ops.loadStream("prod-1")
+        ->Stream.runCollect
+        ->Effect.catchAll(_ => Effect.succeed([]))
+        ->Effect.runPromise
+      expect(items->Array.length)->toBe(1)
+      let field =
+        items
+        ->Array.getUnsafe(0)
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("orderCount"))
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.mapOr(0, Float.toInt)
+      expect(field)->toBe(5)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("QueryDb: an expired-TTL item is filtered from loadStream under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
+      let readCount = async k =>
+        (
+          await ops.loadStream(k)
+          ->Stream.runCollect
+          ->Effect.catchAll(_ => Effect.succeed([]))
+          ->Effect.runPromise
+        )->Array.length
+
+      // A live item (no TTL) and one whose absolute expiry (epoch second 1) is
+      // long past — the expired one must not surface under either backend.
+      let _ = await ops.save("live", item("live"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("dead", item("dead"), ReventlessCore.QueryDb.Any, Some(1))
+
+      expect(await readCount("live"))->toBe(1)
+      expect(await readCount("dead"))->toBe(0)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
   testPromise("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/BackendParityTest.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.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 Effect from "effect/Effect";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
@@ -65,6 +67,49 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderMemory(scenario);
     return await runUnderSqlite(scenario);
   });
+  globalThis.test("QueryDb: count returns a running total and loadStream reflects it under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-count", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let r1 = await ops.count("prod-1", "orderCount", 3);
+      globalThis.expect(r1).toEqual({
+        TAG: "Ok",
+        _0: 3
+      });
+      let r2 = await ops.count("prod-1", "orderCount", 2);
+      globalThis.expect(r2).toEqual({
+        TAG: "Ok",
+        _0: 5
+      });
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("prod-1")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(1);
+      let field = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(items[0]), o => o["orderCount"]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+      globalThis.expect(field).toBe(5);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("QueryDb: an expired-TTL item is filtered from loadStream under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-ttl", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let item = k => Object.fromEntries([[
+          "id",
+          k
+        ]]);
+      let readCount = async k => (await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(k)), param => Effect.succeed([])))).length;
+      await ops.save("live", item("live"), "Any", undefined);
+      await ops.save("dead", item("dead"), "Any", 1);
+      globalThis.expect(await readCount("live")).toBe(1);
+      globalThis.expect(await readCount("dead")).toBe(0);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
   globalThis.test("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});

package/tests/adapter/EventLogStorageSqliteTest.res

@@ -51,10 +51,12 @@ describe("EventLogStorage_Sqlite", () => {
     let e = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("X"))]))
     let _ = await ops.append(0, "id-c", [e])
 
-    // Caller re-uses seqNr=0 — conflict.
+    // Caller re-uses seqNr=0 — a genuine conflict must be the typed Conflict
+    // sentinel (not a StorageFailure), so the core retry loop treats it as OCC.
     let result = await ops.append(0, "id-c", [e])
     switch result {
-    | Error(_) => expect(true)->toBe(true)
+    | Error(ReventlessCore.EventLog.Conflict) => expect(true)->toBe(true)
+    | Error(StorageFailure(msg)) => expect("expected Conflict, got StorageFailure")->toBe(msg)
     | Ok() => expect("expected conflict")->toBe("actual Ok")
     }
   })

package/tests/adapter/EventLogStorageSqliteTest.res.mjs

@@ -65,7 +65,12 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       globalThis.expect("expected conflict").toBe("actual Ok");
       return;
     }
-    globalThis.expect(true).toBe(true);
+    let msg = result._0;
+    if (typeof msg !== "object") {
+      globalThis.expect(true).toBe(true);
+      return;
+    }
+    globalThis.expect("expected Conflict, got StorageFailure").toBe(msg._0);
   });
   globalThis.test("replay returns empty array for unknown id", async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});

package/tests/adapter/LocalBusPubSubTest.res

@@ -78,4 +78,35 @@ describe("LocalBus PubSub (Phase F)", () => {
       expect(countB.contents)->toBe(0)
     })
   })
+
+  // A5: a throwing/rejecting subscriber must not (a) hang publishEvent (its
+  // done_ countdown never reaching zero) nor (b) kill the drain fiber so the
+  // topic stops working. If either regressed, these tests would time out.
+  describe("failing subscriber", () => {
+    testPromise("a throwing subscriber does not hang publish; healthy siblings still receive it", async () => {
+      module TestBus = LocalBus.Make()
+      let healthy = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => JsError.throwWithMessage("boom"))
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        healthy := healthy.contents + 1
+      })
+      // Must resolve — not hang — even though one subscriber threw.
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(healthy.contents)->toBe(1)
+    })
+
+    testPromise("the topic keeps working after a subscriber throws (drain fiber survives)", async () => {
+      module TestBus = LocalBus.Make()
+      let healthy = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => JsError.throwWithMessage("boom"))
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        healthy := healthy.contents + 1
+      })
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      // Second publish on the same topic must also complete and be delivered —
+      // proving the dead-fiber cascade is gone.
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(healthy.contents)->toBe(2)
+    })
+  })
 })

package/tests/adapter/LocalBusPubSubTest.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 
@@ -73,6 +74,33 @@ globalThis.describe("LocalBus PubSub (Phase F)", () => {
       globalThis.expect(countB.contents).toBe(0);
     });
   });
+  globalThis.describe("failing subscriber", () => {
+    globalThis.test("a throwing subscriber does not hang publish; healthy siblings still receive it", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let healthy = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("boom"));
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        healthy.contents = healthy.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(healthy.contents).toBe(1);
+    });
+    globalThis.test("the topic keeps working after a subscriber throws (drain fiber survives)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let healthy = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("boom"));
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        healthy.contents = healthy.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(healthy.contents).toBe(2);
+    });
+  });
 });
 
 export {

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -140,6 +140,7 @@ describe("InboundTranslationSlice Callback", () => {
         })
 
         let targetName = "ConfirmPayment"
+        let externalSystem = None
 
         let translate = (input: externalInput) =>
           Ok(
@@ -206,6 +207,7 @@ describe("InboundTranslationSlice Callback", () => {
         })
 
         let targetName = "ConfirmPayment"
+        let externalSystem = None
 
         let translate = (_input: externalInput) => Ok([])
 

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res.mjs

@@ -22,6 +22,7 @@ let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema,
   commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
   commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization
 })(PaymentWebhookTranslation);
 
@@ -153,6 +154,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         externalInputSchema: externalInputSchema,
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
+        externalSystem: undefined,
         commandAuthorization: commandAuthorization
       })(MultiTranslation);
       let publishedCommands = {
@@ -210,6 +212,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         externalInputSchema: externalInputSchema,
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
+        externalSystem: undefined,
         commandAuthorization: commandAuthorization
       })(EmptyTranslation);
       let publishedCommands = {

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res

@@ -26,6 +26,7 @@ module PaymentWebhookSpec = {
   type command = ConfirmPayment({orderId: @s.matches(Reventless.DcbTag.string) string, paymentId: string})
 
   let targetName = "ConfirmPayment"
+  let externalSystem = None
 
   let translate = (input: externalInput) =>
     switch input.status {

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res.mjs

@@ -62,6 +62,7 @@ let PaymentWebhookSpec = {
   externalInputSchema: externalInputSchema,
   commandSchema: commandSchema,
   targetName: "ConfirmPayment",
+  externalSystem: undefined,
   translate: translate,
   commandAuthorization: commandAuthorization
 };

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res.mjs

@@ -37,7 +37,8 @@ let FireForgetCallback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
   inboundCommandSchema: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.inboundCommandSchema,
   maxRetries: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.maxRetries,
   heartbeatInterval: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.heartbeatInterval,
-  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.targetName
+  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.targetName,
+  externalSystem: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.externalSystem
 })(SendTrackingEmailTranslation);
 
 let CommandBackCallback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
@@ -48,7 +49,8 @@ let CommandBackCallback = OutboundTranslationSlice_Callback$ReventlessCore.Make(
   inboundCommandSchema: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.inboundCommandSchema,
   maxRetries: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries,
   heartbeatInterval: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.heartbeatInterval,
-  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.targetName
+  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.targetName,
+  externalSystem: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.externalSystem
 })(ProcessPaymentTranslation);
 
 globalThis.describe("OutboundTranslationSlice Callback", () => {

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res

@@ -40,6 +40,7 @@ module SendTrackingEmailSpec = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = None
+  let externalSystem = None
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -75,4 +76,5 @@ module ProcessPaymentSpec = {
   let maxRetries = 2
   let heartbeatInterval = 30
   let targetName = Some("ConfirmPayment")
+  let externalSystem = None
 }

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res.mjs

@@ -64,7 +64,8 @@ let SendTrackingEmailSpec = {
   translate: translate,
   maxRetries: 3,
   heartbeatInterval: 60,
-  targetName: undefined
+  targetName: undefined,
+  externalSystem: undefined
 };
 
 let moduleUrl$2 = import.meta.url;
@@ -126,7 +127,8 @@ let ProcessPaymentSpec = {
   translate: translate$1,
   maxRetries: 2,
   heartbeatInterval: 30,
-  targetName: ProcessPaymentSpec_targetName
+  targetName: ProcessPaymentSpec_targetName,
+  externalSystem: undefined
 };
 
 export {