@reventlessdev/reventless-core 3.0.0-alpha.134 → 3.0.0-alpha.136

package/src/util/CommandPublisher.res.mjs

@@ -54,7 +54,8 @@ function Make(Spec) {
         if (size <= 0) {
           return;
         }
-        let commandsToSend = buffer.toSpliced(0, size);
+        let commandsToSend = buffer.slice(0, size);
+        buffer.splice(0, size);
         let promise = Config.publishCommands(Spec.name, toJsons(commandsToSend));
         running.contents = promise;
         let exit = 0;
@@ -88,7 +89,8 @@ function Make(Spec) {
       let bufferSizeStr = buffer.length.toString();
       let chunkCountStr = chunkCount.contents.toString();
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `send: bufferSize: ` + bufferSizeStr + `, chunk: ` + chunkCountStr + `, size: ` + sizeStr));
-      let commandsToSend$1 = buffer.toSpliced(0, size$1);
+      let commandsToSend$1 = buffer.slice(0, size$1);
+      buffer.splice(0, size$1);
       let promise$1 = Config.publishCommands(Spec.name, toJsons(commandsToSend$1));
       running.contents = promise$1;
       let exit$1 = 0;
@@ -127,19 +129,13 @@ function Make(Spec) {
     };
     let clear = () => {
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "clear"));
-      buffer.splice(0, 1);
+      buffer.splice(0, buffer.length);
       flush.contents = false;
     };
     let flush$1 = async () => {
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "flush"));
       flush.contents = true;
-      let match = running.contents;
-      if (match === undefined) {
-        return await send();
-      }
-      while (Stdlib_Option.isNone(running.contents)) {
-        await finishRunning();
-      };
+      return await send();
     };
     return {
       buffer: buffer,

package/src/util/Util_Array.res

@@ -1,2 +1,2 @@
 let containsByPredicate: (array<'a>, 'a => bool) => bool = (arr, predicate) =>
-  arr->Array.find(predicate)->Option.isNone
+  arr->Array.find(predicate)->Option.isSome

package/src/util/Util_Array.res.mjs

@@ -3,7 +3,7 @@
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function containsByPredicate(arr, predicate) {
-  return Stdlib_Option.isNone(arr.find(predicate));
+  return Stdlib_Option.isSome(arr.find(predicate));
 }
 
 export {

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -59,10 +59,11 @@ let structure: pluginStructure = {
       consumedEventTypes: ["OrderPlaced"],
       inboundCommandTypes: ["Ship"],
       targetName: None,
+      externalSystem: None,
     },
   ],
   inboundTranslationSlices: [
-    {name: "FromBilling", commandTypes: ["RecordPayment"], targetName: "Order"},
+    {name: "FromBilling", commandTypes: ["RecordPayment"], targetName: "Order", externalSystem: None},
   ],
   extensions: [
     {

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -85,13 +85,15 @@ let structure_outboundTranslationSlices = [{
     name: "ToShipper",
     consumedEventTypes: ["OrderPlaced"],
     inboundCommandTypes: ["Ship"],
-    targetName: undefined
+    targetName: undefined,
+    externalSystem: undefined
   }];
 
 let structure_inboundTranslationSlices = [{
     name: "FromBilling",
     commandTypes: ["RecordPayment"],
-    targetName: "Order"
+    targetName: "Order",
+    externalSystem: undefined
   }];
 
 let structure_extensions = [{

package/tests/aggregate/AggregateConflictTest.res

@@ -41,7 +41,7 @@ module TestBehavior = {
 }
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -61,7 +61,7 @@ let makeMockEL = (): mockEL => {
     appendCount := appendCount.contents + 1
     if failConflictRef.contents > 0 {
       failConflictRef := failConflictRef.contents - 1
-      Error("conflict")
+      Error(EventLog.Conflict)
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
       Ok(())
@@ -114,7 +114,7 @@ module TestOps = {
       type event = AggSpec.event
     }
     type operations = {
-      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: string => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -87,7 +87,7 @@ function makeMockEL() {
       failConflictRef.contents = failConflictRef.contents - 1 | 0;
       return {
         TAG: "Error",
-        _0: "conflict"
+        _0: "Conflict"
       };
     } else {
       storedRef.contents = storedRef.contents.concat(newEvents);

package/tests/aggregate/AggregateFixtures.res

@@ -60,7 +60,7 @@ module TestBehavior = {
 // ─────────────────────────────────────────────────────────────
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -75,7 +75,7 @@ let makeMockEL = (): mockEL => {
   let appendFn = async (_seqNr, _id, newEvents) =>
     if failRef.contents {
       failRef := false
-      Error("append failed")
+      Error(EventLog.StorageFailure("append failed"))
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
       Ok(())
@@ -129,7 +129,7 @@ module TestOps = {
         int,
         string,
         array<Message.event'<string, AggSpec.event>>,
-      ) => promise<result<unit, string>>,
+      ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: string => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -129,7 +129,10 @@ function makeMockEL() {
       failRef.contents = false;
       return {
         TAG: "Error",
-        _0: "append failed"
+        _0: {
+          TAG: "StorageFailure",
+          _0: "append failed"
+        }
       };
     } else {
       storedRef.contents = storedRef.contents.concat(newEvents);

package/tests/eventlog/EventLogFixtures.res

@@ -28,10 +28,10 @@ let mockStorage: EventLog_Adapter.operations = {
     appendCallCount := appendCallCount.contents + 1
     if failNextAppend.contents {
       failNextAppend := false
-      Error("mock storage failure")
+      Error(EventLog.StorageFailure("mock storage failure"))
     } else if failNextAppendsWithTransient.contents > 0 {
       failNextAppendsWithTransient := failNextAppendsWithTransient.contents - 1
-      Error("ThrottlingException: Rate exceeded")
+      Error(EventLog.StorageFailure("ThrottlingException: Rate exceeded"))
     } else {
       let existing = storedEvents.contents->Dict.get(id)->Option.getOr([])
       storedEvents.contents->Dict.set(id, existing->Array.concat(jsons))

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -47,14 +47,20 @@ async function mockStorage_append(_seqNr, id, jsons) {
     failNextAppend.contents = false;
     return {
       TAG: "Error",
-      _0: "mock storage failure"
+      _0: {
+        TAG: "StorageFailure",
+        _0: "mock storage failure"
+      }
     };
   }
   if (failNextAppendsWithTransient.contents > 0) {
     failNextAppendsWithTransient.contents = failNextAppendsWithTransient.contents - 1 | 0;
     return {
       TAG: "Error",
-      _0: "ThrottlingException: Rate exceeded"
+      _0: {
+        TAG: "StorageFailure",
+        _0: "ThrottlingException: Rate exceeded"
+      }
     };
   }
   let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);

package/tests/eventlog/EventLogRetryTest.res

@@ -16,36 +16,37 @@ let _ = beforeEach(() => reset())
 
 describe("EventLog_Operations — retry:", () => {
   describe("isTransient predicate:", () => {
+    let transient = msg => EventLog_Operations.isTransient(EventLog.StorageFailure(msg))
     testPromise("ThrottlingException is transient", async () => {
-      expect(EventLog_Operations.isTransient("ThrottlingException: Rate exceeded"))->toBe(true)
+      expect(transient("ThrottlingException: Rate exceeded"))->toBe(true)
     })
 
     testPromise("ProvisionedThroughputExceededException is transient", async () => {
-      expect(
-        EventLog_Operations.isTransient("ProvisionedThroughputExceededException"),
-      )->toBe(true)
+      expect(transient("ProvisionedThroughputExceededException"))->toBe(true)
     })
 
     testPromise("ServiceUnavailable is transient", async () => {
-      expect(EventLog_Operations.isTransient("ServiceUnavailable"))->toBe(true)
+      expect(transient("ServiceUnavailable"))->toBe(true)
     })
 
     testPromise("RequestLimitExceeded is transient", async () => {
-      expect(EventLog_Operations.isTransient("RequestLimitExceeded"))->toBe(true)
+      expect(transient("RequestLimitExceeded"))->toBe(true)
     })
 
     testPromise("InternalServerError is transient", async () => {
-      expect(EventLog_Operations.isTransient("InternalServerError: something went wrong"))->toBe(
-        true,
-      )
+      expect(transient("InternalServerError: something went wrong"))->toBe(true)
     })
 
     testPromise("ValidationException is not transient", async () => {
-      expect(EventLog_Operations.isTransient("ValidationException: invalid field"))->toBe(false)
+      expect(transient("ValidationException: invalid field"))->toBe(false)
     })
 
     testPromise("generic mock storage failure is not transient", async () => {
-      expect(EventLog_Operations.isTransient("mock storage failure"))->toBe(false)
+      expect(transient("mock storage failure"))->toBe(false)
+    })
+
+    testPromise("a Conflict is never transient (retried a layer up, not here)", async () => {
+      expect(EventLog_Operations.isTransient(EventLog.Conflict))->toBe(false)
     })
   })
 

package/tests/eventlog/EventLogRetryTest.res.mjs

@@ -74,25 +74,49 @@ globalThis.beforeEach(() => EventLogFixtures$ReventlessCore.reset());
 globalThis.describe("EventLog_Operations — retry:", () => {
   globalThis.describe("isTransient predicate:", () => {
     globalThis.test("ThrottlingException is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ThrottlingException: Rate exceeded")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ThrottlingException: Rate exceeded"
+      })).toBe(true);
     });
     globalThis.test("ProvisionedThroughputExceededException is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ProvisionedThroughputExceededException")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ProvisionedThroughputExceededException"
+      })).toBe(true);
     });
     globalThis.test("ServiceUnavailable is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ServiceUnavailable")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ServiceUnavailable"
+      })).toBe(true);
     });
     globalThis.test("RequestLimitExceeded is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("RequestLimitExceeded")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "RequestLimitExceeded"
+      })).toBe(true);
     });
     globalThis.test("InternalServerError is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("InternalServerError: something went wrong")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "InternalServerError: something went wrong"
+      })).toBe(true);
     });
     globalThis.test("ValidationException is not transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ValidationException: invalid field")).toBe(false);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ValidationException: invalid field"
+      })).toBe(false);
     });
     globalThis.test("generic mock storage failure is not transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("mock storage failure")).toBe(false);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "mock storage failure"
+      })).toBe(false);
+    });
+    globalThis.test("a Conflict is never transient (retried a layer up, not here)", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("Conflict")).toBe(false);
     });
   });
   globalThis.describe("permanent storage failure:", () => {

package/tests/plugin/ManifestVisibilityTest.res

@@ -45,6 +45,9 @@ module PublicReadModel: ReventlessInfra.ReadModel.T
   type role = unit
   type component
   let sourceNames: array<string> = []
+  // A read model that projects an event reaching it via a (DCB-log-sourced) mapping — the
+  // case Plugin_Structure must surface as a qualified `consumedEventTypes` entry.
+  let consumedEventNames: array<string> = ["OrderPlaced"]
   let make = (~api as _, ~apiRole as _, ~allEventTopics as _, ~opts as _=?): component =>
     Obj.magic(0)
   let outputs = (_: component): ReventlessInfra.ReadModel.outputs => Obj.magic(0)
@@ -60,6 +63,7 @@ module InternalReadModel: ReventlessInfra.ReadModel.T
   type role = unit
   type component
   let sourceNames: array<string> = []
+  let consumedEventNames: array<string> = []
   let make = (~api as _, ~apiRole as _, ~allEventTopics as _, ~opts as _=?): component =>
     Obj.magic(0)
   let outputs = (_: component): ReventlessInfra.ReadModel.outputs => Obj.magic(0)
@@ -128,6 +132,16 @@ describe("Plugin_Structure.make — visibility tagging", () => {
     expect(internal->Option.map(d => d.visibility))->toEqual(Some(Some("Internal")))
   })
 
+  testSync("a read model's mapping-consumed events surface as qualified consumedEventTypes", () => {
+    // Q6 #2: a classic read model fed via a (DCB-log-sourced) mapping now reflects the
+    // events it projects from, qualified to the plugin — so DomainGraph draws the
+    // Event→ReadModel projection edge (e.g. OrderPlaced → Customers).
+    let public = structure.readModels->Array.find(d => d.name == "PublicView")
+    expect(public->Option.map(d => d.consumedEventTypes))->toEqual(
+      Some(["VisibilityPlugin.OrderPlaced"]),
+    )
+  })
+
   testSync("aggregates / stateViewSlices stay empty when none are passed (sanity)", () => {
     expect((
       structure.aggregates->Array.length,

package/tests/plugin/ManifestVisibilityTest.res.mjs

@@ -53,6 +53,8 @@ let InternalSpec = {
 
 let sourceNames = [];
 
+let consumedEventNames = ["OrderPlaced"];
+
 function make(param, param$1, param$2, param$3) {
   return 0;
 }
@@ -89,6 +91,7 @@ let PublicReadModel_Spec = {
 let PublicReadModel = {
   Spec: PublicReadModel_Spec,
   sourceNames: sourceNames,
+  consumedEventNames: consumedEventNames,
   make: make,
   outputs: outputs,
   operations: operations,
@@ -97,6 +100,8 @@ let PublicReadModel = {
 
 let sourceNames$1 = [];
 
+let consumedEventNames$1 = [];
+
 function make$1(param, param$1, param$2, param$3) {
   return 0;
 }
@@ -133,6 +138,7 @@ let InternalReadModel_Spec = {
 let InternalReadModel = {
   Spec: InternalReadModel_Spec,
   sourceNames: sourceNames$1,
+  consumedEventNames: consumedEventNames$1,
   make: make$1,
   outputs: outputs$1,
   operations: operations$1,
@@ -183,6 +189,10 @@ globalThis.describe("Plugin_Structure.make — visibility tagging", () => {
     let internal = structure.readModels.find(d => d.name === "InternalView");
     globalThis.expect(Stdlib_Option.map(internal, d => d.visibility)).toEqual("Internal");
   });
+  globalThis.test("a read model's mapping-consumed events surface as qualified consumedEventTypes", () => {
+    let $$public = structure.readModels.find(d => d.name === "PublicView");
+    globalThis.expect(Stdlib_Option.map($$public, d => d.consumedEventTypes)).toEqual(["VisibilityPlugin.OrderPlaced"]);
+  });
   globalThis.test("aggregates / stateViewSlices stay empty when none are passed (sanity)", () => {
     globalThis.expect([
       structure.aggregates.length,

package/tests/projection/ProjectionOptimizeTest.res

@@ -0,0 +1,38 @@
+// Regression test for Projection.optimizeActions (plan A7 / D2).
+//
+// optimizeActions merges consecutive per-id actions. A non-merging pair (Delete
+// then Update) grows the accumulator to length 2; the next merge (Update+Set)
+// must fold only the last action and keep everything before it exactly once.
+// Before the `~end=count-1` fix, `previousActions` still contained the
+// just-merged action, so the earlier action was duplicated — applied twice.
+
+open JestGlobals
+open Reventless.Projection
+
+describe("Projection.optimizeActions", () => {
+  testSync("does not duplicate the pre-merge action (off-by-one regression)", () => {
+    let optimized = Projection.optimizeActions([Delete("a"), Update("a", x => x + 1), Set("a", 99)])
+    // Was 3 (with a duplicated Update("a")) before the fix.
+    expect(optimized->Array.length)->toBe(2)
+    let sets =
+      optimized->Array.filterMap(a =>
+        switch a {
+        | Set(id, s) => Some((id, s))
+        | _ => None
+        }
+      )
+    expect(sets)->toEqual([("a", 99)])
+  })
+
+  testSync("merges a same-id Create+Update chain into a single Create", () => {
+    let optimized = Projection.optimizeActions([Create("a", 0), Update("a", x => x + 1), Update("a", x => x + 10)])
+    let creates =
+      optimized->Array.filterMap(a =>
+        switch a {
+        | Create(id, s) => Some((id, s))
+        | _ => None
+        }
+      )
+    expect(creates)->toEqual([("a", 11)])
+  })
+})

package/tests/projection/ProjectionOptimizeTest.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Projection$ReventlessCore from "../../src/Projection.res.mjs";
+
+globalThis.describe("Projection.optimizeActions", () => {
+  globalThis.test("does not duplicate the pre-merge action (off-by-one regression)", () => {
+    let optimized = Projection$ReventlessCore.optimizeActions([
+      {
+        TAG: "Delete",
+        _0: "a"
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 1 | 0
+      },
+      {
+        TAG: "Set",
+        _0: "a",
+        _1: 99
+      }
+    ]);
+    globalThis.expect(optimized.length).toBe(2);
+    let sets = Stdlib_Array.filterMap(optimized, a => {
+      if (typeof a !== "object" || a.TAG !== "Set") {
+        return;
+      } else {
+        return [
+          a._0,
+          a._1
+        ];
+      }
+    });
+    globalThis.expect(sets).toEqual([[
+        "a",
+        99
+      ]]);
+  });
+  globalThis.test("merges a same-id Create+Update chain into a single Create", () => {
+    let optimized = Projection$ReventlessCore.optimizeActions([
+      {
+        TAG: "Create",
+        _0: "a",
+        _1: 0
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 1 | 0
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 10 | 0
+      }
+    ]);
+    let creates = Stdlib_Array.filterMap(optimized, a => {
+      if (typeof a !== "object" || a.TAG !== "Create") {
+        return;
+      } else {
+        return [
+          a._0,
+          a._1
+        ];
+      }
+    });
+    globalThis.expect(creates).toEqual([[
+        "a",
+        11
+      ]]);
+  });
+});
+
+/*  Not a pure module */

package/tests/util/CommandPublisherTest.res

@@ -0,0 +1,56 @@
+// Regression tests for CommandPublisher (plan A7).
+//
+// Two bugs made the buffered publisher silently lose commands:
+//   - send() used the non-mutating `toSpliced`, so the buffer never drained and
+//     the wrong slice was published.
+//   - flush()'s in-flight arm looped on a dead condition and never sent.
+//   - clear() removed only the first buffered command instead of truncating.
+//
+// These tests drive the functor with a capturing publishCommands and assert the
+// buffer flushes in order and clear() empties it.
+
+open JestGlobals
+
+S.enableJson()
+
+let published: ref<array<Reventless.Message.commandJson>> = ref([])
+
+module TestSpec = {
+  @schema let name = "TestCmd"
+  @schema type command = {value: int}
+}
+
+module TestConfig = {
+  let user = "tester"
+  let publishCommands: Task.publishCommands = (_name, cmds) => {
+    published := published.contents->Array.concat(cmds)
+    Promise.resolve()
+  }
+  let mode = CommandPublisher.SendAllInOneChunk
+}
+
+module Pub = CommandPublisher.Make(TestSpec, TestConfig)
+
+describe("CommandPublisher", () => {
+  testPromise("flush sends all buffered commands in order and drains the buffer", async () => {
+    published := []
+    Pub.publish("id1", {value: 1})
+    Pub.publish("id2", {value: 2})
+    await Pub.flush()
+    let ids = published.contents->Array.map((c: Reventless.Message.commandJson) => c.id)
+    expect(ids)->toEqual(["id1", "id2"])
+    // Buffer drained: a second flush sends nothing more.
+    published := []
+    await Pub.flush()
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("clear truncates the whole buffer so nothing is later published", async () => {
+    published := []
+    Pub.publish("id3", {value: 3})
+    Pub.publish("id4", {value: 4})
+    Pub.clear()
+    await Pub.flush()
+    expect(published.contents->Array.length)->toBe(0)
+  })
+})

package/tests/util/CommandPublisherTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as CommandPublisher$ReventlessCore from "../../src/util/CommandPublisher.res.mjs";
+
+S.enableJson();
+
+let published = {
+  contents: []
+};
+
+let commandSchema = S.schema(s => ({
+  value: s.m(S.int)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let TestSpec = {
+  name: "TestCmd",
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization
+};
+
+function publishCommands(_name, cmds) {
+  published.contents = published.contents.concat(cmds);
+  return Promise.resolve();
+}
+
+let TestConfig = {
+  user: "tester",
+  publishCommands: publishCommands,
+  mode: "SendAllInOneChunk"
+};
+
+let Pub = CommandPublisher$ReventlessCore.Make(TestSpec)(TestConfig);
+
+globalThis.describe("CommandPublisher", () => {
+  globalThis.test("flush sends all buffered commands in order and drains the buffer", async () => {
+    published.contents = [];
+    Pub.publish("id1", {
+      value: 1
+    });
+    Pub.publish("id2", {
+      value: 2
+    });
+    await Pub.flush();
+    let ids = published.contents.map(c => c.id);
+    globalThis.expect(ids).toEqual([
+      "id1",
+      "id2"
+    ]);
+    published.contents = [];
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("clear truncates the whole buffer so nothing is later published", async () => {
+    published.contents = [];
+    Pub.publish("id3", {
+      value: 3
+    });
+    Pub.publish("id4", {
+      value: 4
+    });
+    Pub.clear();
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+});
+
+export {
+  published,
+  TestSpec,
+  TestConfig,
+  Pub,
+}
+/*  Not a pure module */