@reventlessdev/reventless-core 3.0.0-alpha.261 → 3.0.0-alpha.263

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -8,6 +8,7 @@ import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
@@ -30,24 +31,6 @@ import * as OutboundTranslationSlice_Callback$ReventlessCore from "../OutboundTr
 
 let log = Logger$ReventlessCore.fromEnv();
 
-let toRelativePath = (function toRelativePath(moduleUrl) {
-  try {
-    const fs = process.getBuiltinModule('node:fs');
-    const path = process.getBuiltinModule('node:path');
-    const { fileURLToPath } = process.getBuiltinModule('node:url');
-    const builderReal = fs.realpathSync(fileURLToPath(import.meta.url));
-    const sliceReal = fs.realpathSync(fileURLToPath(moduleUrl));
-    let dir = path.dirname(builderReal);
-    while (dir !== path.dirname(dir)) {
-      if (fs.existsSync(path.join(dir, 'lerna.json'))) break;
-      dir = path.dirname(dir);
-    }
-    return path.relative(dir, sliceReal).replace(/\.mjs$/, '.res');
-  } catch(e) {
-    return moduleUrl.replace('file://', '');
-  }
-});
-
 function variantTag(variant) {
   switch (variant.type) {
     case "string" :
@@ -157,11 +140,6 @@ function Make(DcbEventLogStorage) {
         Sc.Spec.name,
         Sc.Spec.eventSchema
       ]);
-      let producedNamed = stateChangeSlices.map(Sc => [
-        Sc.Spec.name,
-        toRelativePath(Sc.Spec.moduleUrl),
-        Sc.Spec.eventSchema
-      ]);
       let consumed = stateChangeSlices.map(Sc => [
         Sc.Spec.name,
         Sc.Spec.consumedEventSchema
@@ -191,7 +169,23 @@ function Make(DcbEventLogStorage) {
         }
       }).map(tagKey => `tag_` + tagKey);
       let indexes$1 = indexes.length > 1 ? indexes.concat(["tag_composite"]) : indexes;
-      let partitionTag = DcbTag$Reventless.derivePartitionTag(producedNamed);
+      let sliceSchemas = stateChangeSlices.map(Sc => ({
+        name: Sc.Spec.name,
+        commandSchema: Sc.Spec.commandSchema,
+        consumedEventSchema: Sc.Spec.consumedEventSchema,
+        eventSchema: Sc.Spec.eventSchema,
+        moduleUrl: Sc.Spec.moduleUrl
+      }));
+      let inferenceShapes = sliceSchemas.map(DcbTag$Reventless.sliceShape);
+      let hintIssues = DcbValidation$Reventless.validatePartitionHintsVsInference(inferenceShapes);
+      hintIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB partition (` + e.sliceName + `): ` + e.message));
+      if (hintIssues.contradictions.length !== 0) {
+        let detail = hintIssues.contradictions.map(e => e.sliceName + `: ` + e.message).join(" | ");
+        log.error("Dcb_Builder", undefined, `DCB partition contradiction (` + name + `): ` + detail);
+        Stdlib_JsError.throwWithMessage(`DCB partition contradiction (` + name + `): ` + detail);
+      }
+      let boundaryPartition = DcbTag$Reventless.deriveBoundaryPartition(sliceSchemas);
+      let partitionTag = boundaryPartition.partitionTag;
       let arr$1 = producedSchemas.flatMap(DcbTag$Reventless.extractCrossPartitionTagKeys);
       let seen$1 = new Set();
       let crossPartitionTagKeys = arr$1.filter(f => {
@@ -209,7 +203,6 @@ function Make(DcbEventLogStorage) {
         Sc.Spec.commandSchema,
         Sc.Spec.consumedEventSchema
       ]), tagKeysByEventType).forEach(w => log.warn("Dcb_Builder", undefined, `DCB composite-read warning (` + w.sliceName + `): ` + w.message));
-      let inferenceShapes = stateChangeSlices.map(Sc => DcbTag$Reventless.sliceShapeFromSchemas(Sc.Spec.name, Sc.Spec.commandSchema, Sc.Spec.consumedEventSchema, Sc.Spec.eventSchema));
       let inferred = DcbScopeInference$Reventless.infer(inferenceShapes);
       if (Primitive_object.notequal(inferred.crossPartitionTagKeys, crossPartitionTagKeys)) {
         log.info("Dcb_Builder", undefined, `DCB scope-inference diff: crossPartitionTagKeys annotated=[` + crossPartitionTagKeys.join(", ") + `] inferred=[` + inferred.crossPartitionTagKeys.join(", ") + `]`);
@@ -231,12 +224,7 @@ function Make(DcbEventLogStorage) {
       let scopeIssues = DcbValidation$Reventless.validateScopeVsInference(scopeAnnotations, inferred);
       scopeIssues.contradictions.forEach(e => log.warn("Dcb_Builder", undefined, `DCB scope contradiction (` + e.sliceName + `): ` + e.message));
       scopeIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB scope (` + e.sliceName + `): ` + e.message));
-      let effective = DcbTag$Reventless.deriveEffectiveScope(stateChangeSlices.map(Sc => ({
-        name: Sc.Spec.name,
-        commandSchema: Sc.Spec.commandSchema,
-        consumedEventSchema: Sc.Spec.consumedEventSchema,
-        eventSchema: Sc.Spec.eventSchema
-      })));
+      let effective = DcbTag$Reventless.deriveEffectiveScope(sliceSchemas);
       let effectiveCrossPartitionTagKeys = effective.crossPartitionTagKeys;
       let effectiveTagKeysByEventType = effective.tagKeysByEventType;
       if (effective.droppedCrossPartitionTagKeys.length !== 0) {
@@ -276,7 +264,7 @@ function Make(DcbEventLogStorage) {
         asyncDcbCommandTopicOpt = undefined;
       }
       let stateChangeSlicesOutputs = Object.fromEntries(syncSlices.map(StateChangeSlice => {
-        let ch = StateChangeSlice.make(dcbEventLog, publishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, componentRuntime[StateChangeSlice.Spec.name], opts);
+        let ch = StateChangeSlice.make(dcbEventLog, publishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, DcbTag$Reventless.slicePartitionTag(boundaryPartition, StateChangeSlice.Spec.name), componentRuntime[StateChangeSlice.Spec.name], opts);
         return [
           StateChangeSlice.Spec.name,
           Component$ReventlessCore.outputs(ch)
@@ -286,7 +274,7 @@ function Make(DcbEventLogStorage) {
       if (asyncDcbCommandTopicOpt !== undefined) {
         let asyncPublishJsons = Component$ReventlessCore.operations(Primitive_option.valFromOption(asyncDcbCommandTopicOpt)).apply(ops => ops.publishJsons);
         asyncStateChangeSlicesOutputs = Object.fromEntries(asyncSlices.map(StateChangeSlice => {
-          let ch = StateChangeSlice.make(dcbEventLog, asyncPublishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, componentRuntime[StateChangeSlice.Spec.name], opts);
+          let ch = StateChangeSlice.make(dcbEventLog, asyncPublishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, DcbTag$Reventless.slicePartitionTag(boundaryPartition, StateChangeSlice.Spec.name), componentRuntime[StateChangeSlice.Spec.name], opts);
           return [
             StateChangeSlice.Spec.name,
             Component$ReventlessCore.outputs(ch)
@@ -318,7 +306,7 @@ function Make(DcbEventLogStorage) {
             if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
               return;
             }
-            let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false);
+            let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false, DcbTag$Reventless.slicePartitionTag(boundaryPartition, S.Spec.name));
             Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).forEach(param => bindHandler(param[0], generateCommand));
           });
         });
@@ -329,7 +317,7 @@ function Make(DcbEventLogStorage) {
               if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
                 return;
               }
-              let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(asyncOps.publishJsons, asyncOps.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false);
+              let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(asyncOps.publishJsons, asyncOps.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false, DcbTag$Reventless.slicePartitionTag(boundaryPartition, S.Spec.name));
               Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).forEach(param => bindHandler(param[0], generateCommand));
             });
           });
@@ -437,7 +425,10 @@ function Make(DcbEventLogStorage) {
             if (match !== undefined) {
               return log.error("Dcb_Builder", undefined, `Two DCB slices in "` + name + `" both declare the command "` + tag + `". ` + "Owner stamping resolves a command by that name alone, so it cannot tell them apart. Rename one of the constructors.");
             } else {
-              byTag[tag] = commandSchema;
+              byTag[tag] = [
+                commandSchema,
+                DcbTag$Reventless.slicePartitionTag(boundaryPartition, S.Spec.name)
+              ];
               return;
             }
           });
@@ -445,14 +436,15 @@ function Make(DcbEventLogStorage) {
         }
       });
       let dcbGenerateCommandOutput = Component$ReventlessCore.operations(dcbCommandTopic).apply(ops => {
-        let make = commandSchema => CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, name, commandSchema, "StateChangeSlice", false);
+        let make = (commandSchema, partitionTag) => CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, name, commandSchema, "StateChangeSlice", false, partitionTag);
         let byTag$1 = {};
         Object.entries(byTag).forEach(param => {
-          byTag$1[param[0]] = make(param[1]);
+          let match = param[1];
+          byTag$1[param[0]] = make(match[0], match[1]);
         });
         return [
           byTag$1,
-          make(Sury.json)
+          make(Sury.json, undefined)
         ];
       });
       let dcbHandler = Pulumi.all([
@@ -693,7 +685,6 @@ function Make(DcbEventLogStorage) {
 
 export {
   log,
-  toRelativePath,
   variantTag,
   mergedEventSchema,
   emptyResult,

package/src/components/StateChangeSlice/StateChangeSlice.res

@@ -33,6 +33,8 @@ module type T = {
         clause (instead of an AND-ed composite) so the decision read is a real
         secondary-tag read. */
     ~crossPartitionTagKeys: array<string>=?,
+    /** This slice's partition, as `Dcb_Builder` derives it for the whole boundary. */
+    ~partitionTag: Reventless.DcbTag.derivedPartitionTag=?,
     ~runtime: ReventlessInfra.RuntimeHints.t=?,
     ~opts: Pulumi.ComponentResource.options=?,
   ) => component

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res

@@ -13,6 +13,7 @@ module Make = (
   let makeJsonHandler = (
     ~tagKeysByEventType,
     ~crossPartitionTagKeys,
+    ~partitionTag,
     dcbEventLogOps: DcbEventLog.operations,
   ) => {
     let handler: CommandTopic.jsonCommandsHandler = stream => {
@@ -42,6 +43,7 @@ module Make = (
       Callback.handleCommands(
         ~tagKeysByEventType,
         ~crossPartitionTagKeys,
+        ~partitionTag?,
         dcbEventLogOps,
         decodedStream,
       )
@@ -54,6 +56,7 @@ module Make = (
     ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
     ~tagKeysByEventType,
     ~crossPartitionTagKeys,
+    ~partitionTag,
     self,
     _name,
   ) => {
@@ -67,6 +70,7 @@ module Make = (
         let jsonHandler = makeJsonHandler(
           ~tagKeysByEventType,
           ~crossPartitionTagKeys,
+          ~partitionTag,
           dcbEventLogOps,
         )
         CommandTopic.registerHandler(
@@ -98,6 +102,7 @@ module Make = (
     ~publishJsons,
     ~tagKeysByEventType=Dict.make(),
     ~crossPartitionTagKeys=[],
+    ~partitionTag=?,
     ~runtime as _=?,
     ~opts=?,
   ): StateChangeSlice.component =>
@@ -109,6 +114,7 @@ module Make = (
         ~publishJsons,
         ~tagKeysByEventType,
         ~crossPartitionTagKeys,
+        ~partitionTag,
         ...
       ),
       ~opts,

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs

@@ -18,7 +18,7 @@ let log = Logger$ReventlessCore.fromEnv();
 function Make(Spec) {
   return Behavior => {
     let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Behavior);
-    let makeJsonHandler = (tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps) => (stream => {
+    let makeJsonHandler = (tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLogOps) => (stream => {
       let decodedStream = Stream.flatMap(Stream.mapEffect(stream, param => {
         let reference = param.reference;
         let json = param.command;
@@ -44,16 +44,16 @@ function Make(Spec) {
           return Stream.empty;
         }
       });
-      return Callback.handleCommands(tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps, decodedStream);
+      return Callback.handleCommands(tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLogOps, decodedStream);
     });
-    let make = (dcbEventLog, publishJsons, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, param, opts) => {
+    let make = (dcbEventLog, publishJsons, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, partitionTag, param, opts) => {
       let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
       let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
       return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(StateChangeSlice$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
         let commandSchema = Spec.commandSchema;
         let commandTypeNames = CommandTopic$ReventlessCore.extractTypeNamesFromSchema(commandSchema);
         Component$ReventlessCore.operations(dcbEventLog).apply(dcbEventLogOps => {
-          let jsonHandler = makeJsonHandler(tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps);
+          let jsonHandler = makeJsonHandler(tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLogOps);
           CommandTopic$ReventlessCore.registerHandler(commandSchema, jsonHandler, commandTypeNames);
         });
         Component$ReventlessCore.setOperations(extra, publishJsons.apply(publishJsons => ({

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -4,6 +4,8 @@ module type T = {
   let handleCommands: (
     ~tagKeysByEventType: Dict.t<array<string>>=?,
     ~crossPartitionTagKeys: array<string>=?,
+    /** This slice's partition within its boundary; inferred from the slice alone when absent. */
+    ~partitionTag: Reventless.DcbTag.derivedPartitionTag=?,
     DcbEventLog.operations,
     Stream.t<
       CommandTopic.topicItem<Message.command'<Reventless.Id.String.t, Spec.command>>,
@@ -74,18 +76,32 @@ module Make = (
     {eventType, data: JSON.Object(data), tags, meta}
   }
 
-  // Computed once at functor init — used to extract entityId for publishJsonsAndWait outcomes.
-  let derivedPartitionTag = Reventless.DcbTag.derivePartitionTag([
-    (Spec.name, Behavior.moduleUrl, Spec.eventSchema->S.castToUnknown),
-  ])
+  // The partition inferred from this slice alone, for callers that do not thread
+  // the boundary's. Lazy and non-throwing: it only names ids in logs and outcomes,
+  // and a slice that needs its siblings to resolve must not fail to load for that.
+  let slicePartitionTag = Lazy.make(() =>
+    try Some(
+      Reventless.DcbTag.deriveSlicePartition({
+        name: Spec.name,
+        commandSchema: Spec.commandSchema->S.castToUnknown,
+        consumedEventSchema: Spec.consumedEventSchema->S.castToUnknown,
+        eventSchema: Spec.eventSchema->S.castToUnknown,
+        moduleUrl: Spec.moduleUrl,
+      }),
+    ) catch {
+    | _ => None
+    }
+  )
 
   // Extracts the entity id of a read event from its own tags, for logging
   // which events the decision model was built from. Prefers this slice's
-  // partition key (derived from the produced event), but consumed events from
-  // other sources are tagged by their own key (e.g. CatalogProductSynced →
-  // productId, not this slice's orderId), so fall back to the read event's own
-  // tag value(s) instead of logging no id.
-  let readEventId = (tags: array<Reventless.DcbTag.tag>): option<string> => {
+  // partition key, but consumed events from other sources are tagged by their
+  // own key (e.g. CatalogProductSynced → productId, not this slice's orderId),
+  // so fall back to the read event's own tag value(s) instead of logging no id.
+  let readEventId = (
+    ~partitionTag: option<Reventless.DcbTag.derivedPartitionTag>,
+    tags: array<Reventless.DcbTag.tag>,
+  ): option<string> => {
     let ownTagValues = () => {
       let vals =
         tags->Array.reduce([], (acc, t: Reventless.DcbTag.tag) =>
@@ -93,15 +109,14 @@ module Make = (
         )
       vals->Array.length == 0 ? None : Some(vals->Array.join(","))
     }
-    switch derivedPartitionTag {
-    | Simple(pt) =>
-      switch tags->Array.findMap((t: Reventless.DcbTag.tag) =>
-        t.key == pt.key ? Some(t.value) : None
-      ) {
-      | Some(v) => Some(v)
-      | None => ownTagValues()
+    switch partitionTag {
+    | Some(Composite(spec)) => Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | Some(pt) =>
+      switch tags->Reventless.DcbTag.partitionValueOfTags(pt) {
+      | "" => ownTagValues()
+      | v => Some(v)
       }
-    | Composite(spec) => Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | None => ownTagValues()
     }
   }
 
@@ -147,6 +162,7 @@ module Make = (
   let handleSingleCommand = (
     ~tagKeysByEventType,
     ~crossPartitionTagKeys,
+    ~partitionTag,
     dcbEventLog: DcbEventLog.operations,
     command': Message.command'<Reventless.Id.String.t, Spec.command>,
   ) => {
@@ -192,11 +208,12 @@ module Make = (
     EffectLogger.logInfo(~comp, `query: ${queryDetail}`)->Effect.runSync
 
     // Extract the entity ID from the command for use in Accepted outcomes.
-    let entityId = switch derivedPartitionTag {
-    | Simple(pt) => Reventless.DcbTag.getPartitionTagValue(query, pt)
-    | Composite(spec) =>
+    let entityId = switch partitionTag {
+    | Some(Reventless.DcbTag.Composite(spec)) =>
       let tags = Reventless.DcbTag.extractTags(Spec.commandSchema, command'.command)
       Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
+    | Some(Simple(pt)) => Reventless.DcbTag.getPartitionTagValue(query, pt)
+    | Some(ByEventType(_)) | None => None
     }
 
     // Fail closed: a query that can't be serialized yields `None`, not the empty
@@ -267,7 +284,12 @@ module Make = (
           ~eventType=raw.eventType,
           ~data=raw.data->JSON.Decode.object->Option.getOr(Dict.make()),
         )
-        decoded->Option.map(event => (event, raw.position, raw.eventType, readEventId(raw.tags)))
+        decoded->Option.map(event => (
+          event,
+          raw.position,
+          raw.eventType,
+          readEventId(~partitionTag, raw.tags),
+        ))
       })
       ->Stream.flatMap(opt =>
         switch opt {
@@ -474,14 +496,20 @@ module Make = (
   let handleCommands = (
     ~tagKeysByEventType=Dict.make(),
     ~crossPartitionTagKeys=[],
+    ~partitionTag=?,
     dcbEventLog,
     stream,
-  ) =>
+  ) => {
+    let partitionTag = switch partitionTag {
+    | Some(_) => partitionTag
+    | None => slicePartitionTag->Lazy.get
+    }
     stream
     ->Stream.mapEffect(({ReventlessInfra.CommandTopic.reference: reference, command}) =>
       handleSingleCommand(
         ~tagKeysByEventType,
         ~crossPartitionTagKeys,
+        ~partitionTag,
         dcbEventLog,
         command,
       )->Effect.map(result =>
@@ -492,4 +520,5 @@ module Make = (
       )
     )
     ->Stream.runCollect
+  }
 }

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -2,6 +2,7 @@
 
 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_Lazy from "@rescript/runtime/lib/es6/Stdlib_Lazy.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -22,12 +23,20 @@ function Make(Spec) {
     let comp = `StateChangeSlice(` + Spec.name + `)`;
     let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
     let queryEventTypes = decoder.eventTypes;
-    let derivedPartitionTag = DcbTag$Reventless.derivePartitionTag([[
-        Spec.name,
-        Behavior.moduleUrl,
-        Spec.eventSchema
-      ]]);
-    let readEventId = tags => {
+    let slicePartitionTag = Stdlib_Lazy.make(() => {
+      try {
+        return DcbTag$Reventless.deriveSlicePartition({
+          name: Spec.name,
+          commandSchema: Spec.commandSchema,
+          consumedEventSchema: Spec.consumedEventSchema,
+          eventSchema: Spec.eventSchema,
+          moduleUrl: Spec.moduleUrl
+        });
+      } catch (exn) {
+        return;
+      }
+    });
+    let readEventId = (partitionTag, tags) => {
       let ownTagValues = () => {
         let vals = Stdlib_Array.reduce(tags, [], (acc, t) => {
           if (acc.includes(t.value)) {
@@ -42,24 +51,26 @@ function Make(Spec) {
           return vals.join(",");
         }
       };
-      if (derivedPartitionTag.TAG !== "Simple") {
-        return DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+      if (partitionTag === undefined) {
+        return ownTagValues();
       }
-      let pt = derivedPartitionTag._0;
-      let v = Stdlib_Array.findMap(tags, t => {
-        if (t.key === pt.key) {
-          return t.value;
-        }
-      });
-      if (v !== undefined) {
-        return v;
-      } else {
+      switch (partitionTag.TAG) {
+        case "Composite" :
+          return DcbTag$Reventless.getCompositePartitionKeyValue(tags, partitionTag._0);
+        case "Simple" :
+        case "ByEventType" :
+          break;
+      }
+      let v = DcbTag$Reventless.partitionValueOfTags(tags, partitionTag);
+      if (v === "") {
         return ownTagValues();
+      } else {
+        return v;
       }
     };
     let projectionCache = Lru$ReventlessCore.make(100);
     let resetCache = () => Lru$ReventlessCore.clear(projectionCache);
-    let handleSingleCommand = (tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, command$p) => {
+    let handleSingleCommand = (tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLog, command$p) => {
       let cmdJson = Message$ReventlessCore.commandJsonOfCommand$p(Id$Reventless.$$String.toString, Spec.commandSchema, command$p);
       Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, cmdJson.commandJson, `handling command: ` + LogFormat$ReventlessCore.cmdDetailNoId(cmdJson)));
       let query = DcbTag$Reventless.buildQueryFromCommand(queryEventTypes, Spec.commandSchema, command$p.command, tagKeysByEventType, crossPartitionTagKeys);
@@ -76,11 +87,21 @@ function Make(Spec) {
       }).join(" OR ");
       Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `query: ` + queryDetail));
       let entityId;
-      if (derivedPartitionTag.TAG === "Simple") {
-        entityId = DcbTag$Reventless.getPartitionTagValue(query, derivedPartitionTag._0);
+      if (partitionTag !== undefined) {
+        switch (partitionTag.TAG) {
+          case "Simple" :
+            entityId = DcbTag$Reventless.getPartitionTagValue(query, partitionTag._0);
+            break;
+          case "Composite" :
+            let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
+            entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, partitionTag._0);
+            break;
+          case "ByEventType" :
+            entityId = undefined;
+            break;
+        }
       } else {
-        let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
-        entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+        entityId = undefined;
       }
       let cacheKey = JSON.stringify(query);
       let cacheGet = () => {
@@ -131,7 +152,7 @@ function Make(Spec) {
             event,
             raw.position,
             raw.eventType,
-            readEventId(raw.tags)
+            readEventId(partitionTag, raw.tags)
           ]);
         }), opt => {
           if (opt !== undefined) {
@@ -290,12 +311,13 @@ function Make(Spec) {
       };
       return attempt(3);
     };
-    let handleCommands = (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, dcbEventLog, stream) => {
+    let handleCommands = (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, partitionTag, dcbEventLog, stream) => {
       let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
       let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+      let partitionTag$1 = partitionTag !== undefined ? partitionTag : Stdlib_Lazy.get(slicePartitionTag);
       return Stream.runCollect(Stream$1.mapEffect(stream, param => {
         let reference = param.reference;
-        return Effect.map(handleSingleCommand(tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, param.command), result => {
+        return Effect.map(handleSingleCommand(tagKeysByEventType, crossPartitionTagKeys, partitionTag$1, dcbEventLog, param.command), result => {
           if (result.TAG === "Ok") {
             return {
               TAG: "Ok",