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

package/tests/components/dcb/DcbRepeatTest.res.mjs

@@ -0,0 +1,420 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.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 LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../../src/adapter/SqliteDriver.res.mjs";
+import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let name = "Ordering.Orders";
+
+let commandSchema = Sury.literal("Noop");
+
+let eventSchema = Sury.$schema(s => ({
+  TAG: "ItemOrdered",
+  productId: s.m(Sury.string),
+  orderId: s.m(Sury.string)
+}));
+
+let directiveSchema = Sury.literal("NoDirective");
+
+let moduleUrl = import.meta.url;
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let Port = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let name$1 = "RecordDemandNoCheck";
+
+let moduleUrl$1 = import.meta.url;
+
+let eventSchema$1 = Sury.$schema(s => ({
+  TAG: "DemandRecorded",
+  productId: s.m(DcbTag$Reventless.partition),
+  orderId: s.m(Sury.string)
+}));
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "DemandRecorded",
+  productId: s.m(DcbTag$Reventless.string),
+  orderId: s.m(Sury.string)
+}));
+
+let commandSchema$1 = Sury.$schema(s => ({
+  TAG: "RecordDemand",
+  productId: s.m(DcbTag$Reventless.string),
+  orderId: s.m(Sury.string)
+}));
+
+let errorSchema = Sury.literal("Never");
+
+function authorizationOf$1(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition$1(param) {
+  return "Unrestricted";
+}
+
+let traits$1 = [];
+
+let DemandSlice = {
+  name: name$1,
+  Id: undefined,
+  moduleUrl: moduleUrl$1,
+  eventSchema: eventSchema$1,
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema$1,
+  errorSchema: errorSchema,
+  authorizationOf: authorizationOf$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  orders: []
+};
+
+function evolve(state, event) {
+  return {
+    orders: state.orders.concat([event.orderId])
+  };
+}
+
+function decide(_state, command) {
+  return {
+    TAG: "Ok",
+    _0: [{
+        TAG: "DemandRecorded",
+        productId: command.productId,
+        orderId: command.orderId
+      }]
+  };
+}
+
+let DemandDecision = {
+  initialState: initialState,
+  moduleUrl: moduleUrl$1,
+  evolve: evolve,
+  decide: decide
+};
+
+let DemandHandler = StateChangeSlice_Callback$ReventlessCore.Make({
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema$1,
+  commandSchema: commandSchema$1,
+  authorizationOf: authorizationOf$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl$1
+});
+
+let partitionTag = {
+  TAG: "Simple",
+  _0: {
+    key: "productId"
+  }
+};
+
+let moduleUrl$2 = import.meta.url;
+
+function mapIncomingEvent(_id, event, _meta, _pluginDef, _queryEngine) {
+  return [{
+      TAG: "PublishStateChangeSliceCommand",
+      _0: {
+        TAG: "RecordDemand",
+        productId: event.productId,
+        orderId: event.orderId
+      }
+    }];
+}
+
+let handledEvents = [];
+
+let issuedCommands = [];
+
+let DemandExtension = ExtensionMapping$ReventlessInfra.Make({
+  ExtensionPoint: {
+    name: name,
+    moduleUrl: moduleUrl,
+    commandSchema: commandSchema,
+    eventSchema: eventSchema,
+    directiveSchema: directiveSchema
+  },
+  Delegate: {
+    Id: Id$Reventless.$$String,
+    name: name$1,
+    eventSchema: eventSchema$1,
+    errorSchema: errorSchema,
+    commandSchema: commandSchema$1,
+    moduleUrl: moduleUrl$1,
+    authorizationOf: authorizationOf$1,
+    commandTransition: commandTransition$1,
+    traits: traits$1
+  },
+  moduleUrl: moduleUrl$2,
+  delegateModuleUrl: moduleUrl$1,
+  mapIncomingEvent: mapIncomingEvent,
+  mapOutgoingEvent: undefined,
+  handledEvents: handledEvents,
+  issuedCommands: issuedCommands
+});
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let pluginDefinition = {
+  id: "Catalog@1",
+  name: "Catalog",
+  version: "1",
+  extensionPoints: [],
+  extensions: [{
+      name: "Catalog",
+      extensionPointName: name
+    }],
+  eventCollector: "eventCollector",
+  extensionProtocols: [],
+  apiSchemaFragment: undefined,
+  structure: undefined,
+  kind: "Domain"
+};
+
+let published_meta = {
+  service: name,
+  time: "2024-01-01T00:00:00Z",
+  msgId: "item-ordered-msg",
+  correlationId: "place-order-cmd",
+  causationId: "order-placed-event"
+};
+
+let published_event = {
+  TAG: "ItemOrdered",
+  productId: "product-1",
+  orderId: "order-1"
+};
+
+let published = {
+  id: "order-1",
+  meta: published_meta,
+  event: published_event
+};
+
+function commandOf(event$p) {
+  let match = DemandExtension.mapIncomingEvent(event$p, pluginDefinition, queryEngine);
+  if (match.length !== 1) {
+    return Stdlib_JsError.throwWithMessage("expected one slice command");
+  }
+  let match$1 = match[0];
+  if (match$1.TAG === "AbstractPublishAggregateCommand") {
+    return match$1._1;
+  } else {
+    return Stdlib_JsError.throwWithMessage("expected one slice command");
+  }
+}
+
+async function eventLogOn(name) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(Bus);
+  let s = Storage.make(name, [], partitionTag, undefined, opts);
+  let storage = await TestRunner$ReventlessLocal.resolve(s.operations);
+  let publishJson = async (param, param$1, param$2) => {};
+  let Log = DcbEventLog_Operations$ReventlessCore.Make({
+    name: name,
+    serviceName: name,
+    storage: storage,
+    publishJson: publishJson
+  });
+  return {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream
+  };
+}
+
+async function runUnderMemory(fn) {
+  BackendState$ReventlessLocal.setMemory();
+  return await fn();
+}
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+function deliver(eventLog, cmd) {
+  return Effect.runPromise(DemandHandler.handleCommands(undefined, undefined, partitionTag, eventLog, Stream.fromIterable([{
+      command: Message$ReventlessCore.decodeCommand$p(CommandTopic_Helpers$ReventlessCore.encodeCommandJson(cmd), Id$Reventless.$$String.schema, commandSchema$1),
+      reference: cmd.meta.msgId
+    }])));
+}
+
+async function recordedDemands(eventLog) {
+  return (await eventLog.read([{
+      eventTypes: ["DemandRecorded"]
+    }], undefined)).events;
+}
+
+let counter = {
+  contents: 0
+};
+
+function fresh(prefix) {
+  counter.contents = counter.contents + 1 | 0;
+  return prefix + `-` + counter.contents.toString();
+}
+
+globalThis.beforeEach(() => DemandHandler.resetCache());
+
+let backends = [
+  [
+    "in-memory",
+    runUnderMemory
+  ],
+  [
+    "SQLite",
+    runUnderSqlite
+  ]
+];
+
+backends.forEach(param => {
+  let runUnder = param[1];
+  globalThis.describe(`a redelivered fact is recorded once (` + param[0] + ` backend)`, () => {
+    globalThis.test("the same published event delivered twice appends one event", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatOnce"));
+      let first = await deliver(log, commandOf(published));
+      let again = await deliver(log, commandOf(published));
+      globalThis.expect(first.length).toBe(1);
+      globalThis.expect(again).toEqual(first);
+      let events = await recordedDemands(log);
+      globalThis.expect(events.length).toBe(1);
+      let cmd = commandOf(published);
+      globalThis.expect(events[0].meta.causationId).toEqual(cmd.meta.msgId);
+      globalThis.expect(cmd.meta.causationId).toEqual(published_meta.msgId);
+    }));
+    globalThis.test("a different order for the same product still counts", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatOther"));
+      await deliver(log, commandOf(published));
+      let newrecord = {...published_meta};
+      let second_meta = (newrecord.msgId = "item-ordered-msg-2", newrecord);
+      let second_event = {
+        TAG: "ItemOrdered",
+        productId: "product-1",
+        orderId: "order-2"
+      };
+      let second = {
+        id: "order-2",
+        meta: second_meta,
+        event: second_event
+      };
+      await deliver(log, commandOf(second));
+      await deliver(log, commandOf(published));
+      await deliver(log, commandOf(second));
+      globalThis.expect((await recordedDemands(log)).length).toBe(2);
+    }));
+    globalThis.test("a command with a random id is decided every time", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatRandom"));
+      let cmd = commandOf(published);
+      let newrecord = {...cmd};
+      newrecord.meta = Message$ReventlessCore.deriveMeta(cmd.meta, undefined);
+      await deliver(log, newrecord);
+      await deliver(log, newrecord);
+      globalThis.expect((await recordedDemands(log)).length).toBe(2);
+    }));
+    globalThis.test("two concurrent copies append one event", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatConcurrent"));
+      let cmd = commandOf(published);
+      let match = await Promise.all([
+        deliver(log, cmd),
+        deliver(log, cmd)
+      ]);
+      let b = match[1];
+      let a = match[0];
+      globalThis.expect(a.length).toBe(1);
+      globalThis.expect(b.length).toBe(1);
+      globalThis.expect(Stdlib_Result.isOk(a[0]) && Stdlib_Result.isOk(b[0])).toBe(true);
+      globalThis.expect((await recordedDemands(log)).length).toBe(1);
+    }));
+  });
+});
+
+let Message;
+
+export {
+  opts,
+  Message,
+  Port,
+  DemandSlice,
+  DemandDecision,
+  DemandHandler,
+  partitionTag,
+  DemandExtension,
+  queryEngine,
+  pluginDefinition,
+  published,
+  commandOf,
+  eventLogOn,
+  runUnderMemory,
+  runUnderSqlite,
+  deliver,
+  recordedDemands,
+  counter,
+  fresh,
+  backends,
+}
+/*  Not a pure module */

package/tests/components/readmodel/DcbReadModelTypoFailFastTest.res

@@ -1,6 +1,7 @@
-// Verifies Phase 2 of Plan 03: a ReadModel whose `Mapping.sourceName` doesn't
-// match any key in `allEventTopics` fails plugin assembly (here: ReadModel
-// construction) with a clear error, instead of silently producing zero events.
+// A ReadModel whose `Mapping.sourceName` doesn't match any key in `allEventTopics`
+// fails plugin assembly (here: ReadModel construction) with a clear error, instead
+// of silently producing zero events. A dotted name is an extension point's, and
+// the error then also says how another plugin's facts do reach a read model.
 
 open JestGlobals
 open Reventless
@@ -68,22 +69,77 @@ let allEventTopics: ReventlessInfra.EventTopic.allOutputs = Dict.fromArray([
   ("ProductCatalogDcbEventLog", {ReventlessInfra.EventTopic.resources: [topicResource]}),
 ])
 
+// A Source named like an extension point ("Ordering.Orders"): a read model
+// cannot subscribe to one, so the message must say where to go instead.
+module ExtensionPointSource = {
+  module Id = Reventless.Id.String
+  let name = "Ordering.Orders"
+
+  @schema
+  type event = ItemOrdered({productId: string, orderId: string})
+}
+
+module EpRmSpec = {
+  module Id = Reventless.Id.String
+  let name = "EpCheckReadModel"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {productId: string, orderCount: int}
+
+  let config = ReadModel.config()
+  let subIdConfig = None
+}
+
+module EpMapping = Mapping.Make(
+  ExtensionPointSource,
+  EpRmSpec,
+  {
+    let project = (msg: Message.event'<ExtensionPointSource.Id.t, ExtensionPointSource.event>) =>
+      switch msg.event {
+      | ItemOrdered({productId}) =>
+        Set(EpRmSpec.Id.makeFromString(productId), ({productId, orderCount: 1}: EpRmSpec.state))
+      }
+  },
+)
+
+module EpMappings: Mappings with module Target := EpRmSpec = {
+  module Mappings = Mappings.Make(EpRmSpec)
+  module type Mapping = Mappings.Mapping
+  let moduleUrl: string = %raw(`import.meta.url`)
+  let mappings: array<module(Mapping)> = [module(EpMapping)]
+}
+
 module ReadModelMaker = ReadModel_Builder.Make(Bus)
 module RmMaker = ReadModelMaker.Make(RmSpec, TypoMappings)
+module EpRmMaker = ReadModelMaker.Make(EpRmSpec, EpMappings)
+
+let messageOf = make => {
+  let msg = ref(None)
+  try {
+    let _ = make()
+  } catch {
+  | JsExn(err) => msg := Some(err->JsExn.message->Option.getOr(""))
+  }
+  msg.contents
+}
 
 describe("ReadModel source-name fail-fast:", () => {
   testSync("constructing a ReadModel whose Mapping.sourceName is missing throws", () => {
-    let threw = ref(false)
-    let msg = ref("")
-    try {
-      let _ = RmMaker.make(~api=(), ~apiRole=(), ~allEventTopics)
-    } catch {
-    | JsExn(err) =>
-      threw := true
-      msg := err->JsExn.message->Option.getOr("")
-    }
-    expect(threw.contents)->toBe(true)->ignore
-    expect(msg.contents->String.includes("MissingDcb"))->toBe(true)->ignore
-    expect(msg.contents->String.includes("ProductCatalogDcbEventLog"))->toBe(true)
+    let msg =
+      messageOf(() => RmMaker.make(~api=(), ~apiRole=(), ~allEventTopics))->Option.getOrThrow
+    expect(msg->String.includes("MissingDcb"))->toBe(true)
+    expect(msg->String.includes("ProductCatalogDcbEventLog"))->toBe(true)
+    // A typo keeps the plain message: no extension point is being named.
+    expect(msg->String.includes("extension point"))->toBe(false)
+  })
+
+  testSync("a dotted sourceName names the Extension → slice route instead", () => {
+    let msg =
+      messageOf(() => EpRmMaker.make(~api=(), ~apiRole=(), ~allEventTopics))->Option.getOrThrow
+    expect(msg->String.includes("Ordering.Orders"))->toBe(true)
+    expect(msg->String.includes("looks like an extension point name"))->toBe(true)
+    expect(msg->String.includes("Declare an Extension"))->toBe(true)
+    expect(msg->String.includes("Targeting a StateChangeSlice instead of an Aggregate"))->toBe(true)
   })
 })

package/tests/components/readmodel/DcbReadModelTypoFailFastTest.res.mjs

@@ -104,6 +104,84 @@ let allEventTopics = Object.fromEntries([[
     }
   ]]);
 
+let name$2 = "Ordering.Orders";
+
+let eventSchema$1 = Sury.$schema(s => ({
+  TAG: "ItemOrdered",
+  productId: s.m(Sury.string),
+  orderId: s.m(Sury.string)
+}));
+
+let ExtensionPointSource = {
+  Id: undefined,
+  name: name$2,
+  eventSchema: eventSchema$1
+};
+
+let name$3 = "EpCheckReadModel";
+
+let moduleUrl$2 = import.meta.url;
+
+let stateSchema$1 = Sury.$schema(s => ({
+  productId: s.m(Sury.string),
+  orderCount: s.m(Sury.int32)
+}));
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let EpRmSpec = {
+  Id: undefined,
+  name: name$3,
+  moduleUrl: moduleUrl$2,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project$1(msg) {
+  let match = msg.event;
+  let productId = match.productId;
+  return {
+    TAG: "Set",
+    _0: Id$Reventless.$$String.makeFromString(productId),
+    _1: {
+      productId: productId,
+      orderCount: 1
+    }
+  };
+}
+
+let EpMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$2,
+  eventSchema: eventSchema$1
+})({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  stateSchema: stateSchema$1,
+  subIdConfig: undefined
+})({
+  project: project$1
+});
+
+Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  stateSchema: stateSchema$1,
+  subIdConfig: undefined
+});
+
+let moduleUrl$3 = import.meta.url;
+
+let mappings$1 = [EpMapping];
+
+let EpMappings = {
+  moduleUrl: moduleUrl$3,
+  mappings: mappings$1
+};
+
 let ReadModelMaker = ReadModel_Builder$ReventlessLocal.Make(Bus);
 
 let RmMaker = ReadModelMaker.Make({
@@ -117,24 +195,45 @@ let RmMaker = ReadModelMaker.Make({
   visibility: "Public"
 })(TypoMappings);
 
+let EpRmMaker = ReadModelMaker.Make({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  moduleUrl: moduleUrl$2,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+})(EpMappings);
+
+function messageOf(make) {
+  let msg;
+  try {
+    make();
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      msg = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "");
+    } else {
+      throw err;
+    }
+  }
+  return msg;
+}
+
 globalThis.describe("ReadModel source-name fail-fast:", () => {
   globalThis.test("constructing a ReadModel whose Mapping.sourceName is missing throws", () => {
-    let threw = false;
-    let msg = "";
-    try {
-      RmMaker.make(undefined, undefined, allEventTopics, undefined, undefined);
-    } catch (raw_err) {
-      let err = Primitive_exceptions.internalToException(raw_err);
-      if (err.RE_EXN_ID === "JsExn") {
-        threw = true;
-        msg = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "");
-      } else {
-        throw err;
-      }
-    }
-    globalThis.expect(threw).toBe(true);
+    let msg = Stdlib_Option.getOrThrow(messageOf(() => RmMaker.make(undefined, undefined, allEventTopics, undefined, undefined)), undefined);
     globalThis.expect(msg.includes("MissingDcb")).toBe(true);
     globalThis.expect(msg.includes("ProductCatalogDcbEventLog")).toBe(true);
+    globalThis.expect(msg.includes("extension point")).toBe(false);
+  });
+  globalThis.test("a dotted sourceName names the Extension → slice route instead", () => {
+    let msg = Stdlib_Option.getOrThrow(messageOf(() => EpRmMaker.make(undefined, undefined, allEventTopics, undefined, undefined)), undefined);
+    globalThis.expect(msg.includes("Ordering.Orders")).toBe(true);
+    globalThis.expect(msg.includes("looks like an extension point name")).toBe(true);
+    globalThis.expect(msg.includes("Declare an Extension")).toBe(true);
+    globalThis.expect(msg.includes("Targeting a StateChangeSlice instead of an Aggregate")).toBe(true);
   });
 });
 
@@ -146,7 +245,13 @@ export {
   TypoMappings,
   topicResource,
   allEventTopics,
+  ExtensionPointSource,
+  EpRmSpec,
+  EpMapping,
+  EpMappings,
   ReadModelMaker,
   RmMaker,
+  EpRmMaker,
+  messageOf,
 }
 /* Bus Not a pure module */

package/tests/components/stateviewslice/StateViewSliceDisplayNameFixtures.res.mjs

@@ -155,7 +155,7 @@ function encodeEvent(event) {
   let json = Util_Sury$Reventless.toJson(event, eventSchema);
   let match = Message$ReventlessCore.splitMessage(json);
   let tags = DcbTag$Reventless.extractTags(eventSchema, event);
-  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
   return {
     eventType: match[0],
     data: match[1],

package/tests/components/stateviewslice/StateViewSliceFixtures.res.mjs

@@ -158,7 +158,7 @@ function encodeEvent(event) {
   let json = Util_Sury$Reventless.toJson(event, eventSchema);
   let match = Message$ReventlessCore.splitMessage(json);
   let tags = DcbTag$Reventless.extractTags(eventSchema, event);
-  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
   return {
     eventType: match[0],
     data: match[1],

package/tests/components/stateviewslice/StateViewSliceSubIdFixtures.res.mjs

@@ -153,7 +153,7 @@ function encodeEvent(event) {
   let json = Util_Sury$Reventless.toJson(event, eventSchema);
   let match = Message$ReventlessCore.splitMessage(json);
   let tags = DcbTag$Reventless.extractTags(eventSchema, event);
-  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
   return {
     eventType: match[0],
     data: match[1],