@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/dcb/DcbTagTest.res.mjs

@@ -0,0 +1,867 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as DcbFixtures$ReventlessCore from "./DcbFixtures.res.mjs";
+
+globalThis.describe("DcbTag:", () => {
+  globalThis.describe("jsonValueToString", () => {
+    globalThis.test("converts string value", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString("hello")).toBe("hello");
+    });
+    globalThis.test("converts integer-like number", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString(42)).toBe("42");
+    });
+    globalThis.test("converts float number", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString(3.14)).toBe("3.14");
+    });
+    globalThis.test("converts boolean true", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString(true)).toBe("true");
+    });
+    globalThis.test("converts boolean false", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString(false)).toBe("false");
+    });
+    globalThis.test("converts null", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString(null)).toBe("null");
+    });
+    globalThis.test("converts array via JSON.stringify", () => {
+      globalThis.expect(DcbTag$Reventless.jsonValueToString([
+        1,
+        2
+      ])).toBe("[1,2]");
+    });
+  });
+  globalThis.describe("isTagged", () => {
+    globalThis.test("returns true for Reventless.DcbTag.string schema", () => {
+      globalThis.expect(DcbTag$Reventless.isTagged(DcbTag$Reventless.string)).toBe(true);
+    });
+    globalThis.test("returns true for Reventless.DcbTag.int schema", () => {
+      globalThis.expect(DcbTag$Reventless.isTagged(DcbTag$Reventless.int)).toBe(true);
+    });
+    globalThis.test("returns false for plain S.string schema", () => {
+      globalThis.expect(DcbTag$Reventless.isTagged(S.string)).toBe(false);
+    });
+  });
+  globalThis.describe("extractTags from variant (Union) schema", () => {
+    globalThis.test("extracts itemId tag from ItemCreated", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, {
+        TAG: "ItemCreated",
+        itemId: "item-1",
+        name: "Test"
+      })).toEqual([{
+          key: "itemId",
+          value: "item-1"
+        }]);
+    });
+    globalThis.test("extracts itemId tag from ItemRenamed", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, {
+        TAG: "ItemRenamed",
+        itemId: "item-2",
+        newName: "Updated"
+      })).toEqual([{
+          key: "itemId",
+          value: "item-2"
+        }]);
+    });
+    globalThis.test("extracts multiple tags from CountUpdated", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, {
+        TAG: "CountUpdated",
+        category: "electronics",
+        amount: 42
+      })).toEqual([
+        {
+          key: "category",
+          value: "electronics"
+        },
+        {
+          key: "amount",
+          value: "42"
+        }
+      ]);
+    });
+    globalThis.test("returns empty array for SimpleEvent (no payload)", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, "SimpleEvent")).toEqual([]);
+    });
+    globalThis.test("returns empty array for untagged PlainEvent", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.UntaggedEventSpec.eventSchema, {
+        TAG: "PlainEvent",
+        name: "test",
+        value: 1
+      })).toEqual([]);
+    });
+    globalThis.test("returns empty array for untagged EmptyEvent", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.UntaggedEventSpec.eventSchema, "EmptyEvent")).toEqual([]);
+    });
+  });
+  globalThis.describe("extractTags from Object schema", () => {
+    globalThis.test("extracts tenantId tag from object record", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.objectEventSchema, {
+        tenantId: "tenant-1",
+        data: "test"
+      })).toEqual([{
+          key: "tenantId",
+          value: "tenant-1"
+        }]);
+    });
+  });
+  globalThis.describe("extractTags from command schema", () => {
+    globalThis.test("extracts itemId tag from CreateItem command", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema, {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      })).toEqual([{
+          key: "itemId",
+          value: "item-1"
+        }]);
+    });
+    globalThis.test("extracts itemId tag from RenameItem command", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema, {
+        TAG: "RenameItem",
+        itemId: "item-3",
+        newName: "New"
+      })).toEqual([{
+          key: "itemId",
+          value: "item-3"
+        }]);
+    });
+  });
+  globalThis.describe("extractTaggedFields from schema", () => {
+    globalThis.describe("Union (variant) schemas", () => {
+      globalThis.test("extracts all unique tagged field names from event schema", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema)).toEqual([
+          "amount",
+          "category",
+          "itemId"
+        ]);
+      });
+      globalThis.test("extracts tagged field names from command schema", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema)).toEqual(["itemId"]);
+      });
+      globalThis.test("returns empty array for untagged variant schema", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.UntaggedEventSpec.eventSchema)).toEqual([]);
+      });
+      globalThis.test("deduplicates field names across variants", () => {
+        let fields = DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+        globalThis.expect(fields).toEqual([
+          "amount",
+          "category",
+          "itemId"
+        ]);
+      });
+      globalThis.test("returns sorted field names", () => {
+        let fields = DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+        let sorted = fields.toSorted(Primitive_string.compare);
+        globalThis.expect(fields).toEqual(sorted);
+      });
+    });
+    globalThis.describe("Object (record) schemas", () => {
+      globalThis.test("extracts tagged field names from object schema", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.objectEventSchema)).toEqual(["tenantId"]);
+      });
+      globalThis.test("returns empty array for object with no tagged fields", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.plainRecordSchema)).toEqual([]);
+      });
+      globalThis.test("extracts multiple tagged fields from object schema", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.multiTagRecordSchema)).toEqual([
+          "tenantId",
+          "userId"
+        ]);
+      });
+    });
+    globalThis.describe("Edge cases", () => {
+      globalThis.test("handles variants with no payload (SimpleEvent)", () => {
+        let fields = DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+        globalThis.expect(fields.length).toBeGreaterThan(0);
+      });
+      globalThis.test("handles schema with mix of tagged and untagged fields", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.mixedEventSchema)).toEqual(["id"]);
+      });
+      globalThis.test("handles empty schema gracefully", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.emptyVariantSchema)).toEqual([]);
+      });
+      globalThis.test("handles schema with int tags", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.intTagEventSchema)).toEqual(["count"]);
+      });
+    });
+    globalThis.describe("isTaggedArray", () => {
+      globalThis.test("returns true for array of tagged strings", () => {
+        let schema = S.array(DcbTag$Reventless.string);
+        globalThis.expect(DcbTag$Reventless.isTaggedArray(schema)).toBe(true);
+      });
+      globalThis.test("returns false for array of plain strings", () => {
+        let schema = S.array(S.string);
+        globalThis.expect(DcbTag$Reventless.isTaggedArray(schema)).toBe(false);
+      });
+      globalThis.test("returns false for tagged scalar", () => {
+        globalThis.expect(DcbTag$Reventless.isTaggedArray(DcbTag$Reventless.string)).toBe(false);
+      });
+      globalThis.test("returns false for plain string", () => {
+        globalThis.expect(DcbTag$Reventless.isTaggedArray(S.string)).toBe(false);
+      });
+    });
+    globalThis.describe("Complex schemas", () => {
+      globalThis.test("extracts from schema with many variants and fields", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.complexEventSchema)).toEqual([
+          "orderId",
+          "paymentId",
+          "trackingId",
+          "userId"
+        ]);
+      });
+      globalThis.test("handles variants with multiple tagged fields in same variant", () => {
+        globalThis.expect(DcbTag$Reventless.extractTaggedFields(DcbFixtures$ReventlessCore.multiFieldEventSchema)).toEqual([
+          "sessionId",
+          "tenantId",
+          "userId"
+        ]);
+      });
+    });
+  });
+  globalThis.describe("extractTagsExpanded (array expansion)", () => {
+    globalThis.test("expands array tagged field into per-element tags", () => {
+      globalThis.expect(DcbTag$Reventless.extractTagsExpanded(DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: [
+          "prod-1",
+          "prod-2"
+        ]
+      })).toEqual([
+        {
+          key: "orderId",
+          value: "ord-1"
+        },
+        {
+          key: "productId",
+          value: "prod-1"
+        },
+        {
+          key: "productId",
+          value: "prod-2"
+        }
+      ]);
+    });
+    globalThis.test("handles empty array tagged field", () => {
+      globalThis.expect(DcbTag$Reventless.extractTagsExpanded(DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: []
+      })).toEqual([{
+          key: "orderId",
+          value: "ord-1"
+        }]);
+    });
+    globalThis.test("scalar tagged fields unchanged", () => {
+      globalThis.expect(DcbTag$Reventless.extractTagsExpanded(DcbFixtures$ReventlessCore.singleTagCommandSchema, {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      })).toEqual([{
+          key: "itemId",
+          value: "item-1"
+        }]);
+    });
+  });
+  globalThis.describe("extractCompositePartitionFields", () => {
+    globalThis.test("extracts 3 fields from single-variant composite schema", () => {
+      let fields = DcbTag$Reventless.extractCompositePartitionFields(DcbFixtures$ReventlessCore.compositeEventSchema);
+      globalThis.expect(fields.length).toBe(3);
+      globalThis.expect(fields.map(f => f.name)).toEqual([
+        "environment",
+        "platformName",
+        "pluginName"
+      ]);
+    });
+    globalThis.test("fields are sorted by position", () => {
+      let fields = DcbTag$Reventless.extractCompositePartitionFields(DcbFixtures$ReventlessCore.compositeEventSchema);
+      let positions = fields.map(f => f.position);
+      globalThis.expect(positions).toEqual([
+        0,
+        1,
+        2
+      ]);
+    });
+    globalThis.test("extracts separator values", () => {
+      let fields = DcbTag$Reventless.extractCompositePartitionFields(DcbFixtures$ReventlessCore.compositeEventCustomSepSchema);
+      globalThis.expect(fields.map(f => f.sep)).toEqual([
+        ":",
+        "/",
+        "/"
+      ]);
+    });
+    globalThis.test("deduplicates fields across variants", () => {
+      let fields = DcbTag$Reventless.extractCompositePartitionFields(DcbFixtures$ReventlessCore.compositeMultiVariantSchema);
+      globalThis.expect(fields.length).toBe(2);
+      globalThis.expect(fields.map(f => f.name)).toEqual([
+        "env",
+        "name"
+      ]);
+    });
+    globalThis.test("returns empty for schema without composite fields", () => {
+      let fields = DcbTag$Reventless.extractCompositePartitionFields(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+      globalThis.expect(fields).toEqual([]);
+    });
+  });
+  globalThis.describe("getCompositePartitionKeyValue", () => {
+    globalThis.test("joins values with default separator", () => {
+      let spec_keys = [
+        "environment",
+        "platformName",
+        "pluginName"
+      ];
+      let spec_seps = [
+        "/",
+        "/"
+      ];
+      let spec = {
+        keys: spec_keys,
+        seps: spec_seps
+      };
+      let tags = [
+        {
+          key: "environment",
+          value: "prod"
+        },
+        {
+          key: "platformName",
+          value: "aws"
+        },
+        {
+          key: "pluginName",
+          value: "catalog"
+        }
+      ];
+      globalThis.expect(DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)).toBe("prod/aws/catalog");
+    });
+    globalThis.test("joins values with mixed separators", () => {
+      let spec_keys = [
+        "tenantId",
+        "region",
+        "service"
+      ];
+      let spec_seps = [
+        ":",
+        "/"
+      ];
+      let spec = {
+        keys: spec_keys,
+        seps: spec_seps
+      };
+      let tags = [
+        {
+          key: "tenantId",
+          value: "acme"
+        },
+        {
+          key: "region",
+          value: "eu-west-1"
+        },
+        {
+          key: "service",
+          value: "auth"
+        }
+      ];
+      globalThis.expect(DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)).toBe("acme:eu-west-1/auth");
+    });
+    globalThis.test("uses empty string for missing tag values", () => {
+      let spec_keys = [
+        "a",
+        "b"
+      ];
+      let spec_seps = ["/"];
+      let spec = {
+        keys: spec_keys,
+        seps: spec_seps
+      };
+      let tags = [{
+          key: "a",
+          value: "x"
+        }];
+      globalThis.expect(DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)).toBe("x/");
+    });
+    globalThis.test("handles tags in different order than keys", () => {
+      let spec_keys = [
+        "a",
+        "b",
+        "c"
+      ];
+      let spec_seps = [
+        "/",
+        "/"
+      ];
+      let spec = {
+        keys: spec_keys,
+        seps: spec_seps
+      };
+      let tags = [
+        {
+          key: "c",
+          value: "3"
+        },
+        {
+          key: "a",
+          value: "1"
+        },
+        {
+          key: "b",
+          value: "2"
+        }
+      ];
+      globalThis.expect(DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)).toBe("1/2/3");
+    });
+  });
+  globalThis.describe("derivePartitionTag", () => {
+    globalThis.test("returns Composite for schema with >= 2 composite fields", () => {
+      let result = DcbTag$Reventless.derivePartitionTag([[
+          "Sync",
+          "test.res",
+          DcbFixtures$ReventlessCore.compositeEventSchema
+        ]]);
+      if (result.TAG === "Simple") {
+        return JestGlobals.fail("Expected Composite");
+      }
+      let spec = result._0;
+      globalThis.expect(spec.keys).toEqual([
+        "environment",
+        "platformName",
+        "pluginName"
+      ]);
+      globalThis.expect(spec.seps).toEqual([
+        "/",
+        "/"
+      ]);
+    });
+    globalThis.test("returns Composite with custom separators", () => {
+      let result = DcbTag$Reventless.derivePartitionTag([[
+          "Config",
+          "test.res",
+          DcbFixtures$ReventlessCore.compositeEventCustomSepSchema
+        ]]);
+      if (result.TAG === "Simple") {
+        return JestGlobals.fail("Expected Composite");
+      }
+      let spec = result._0;
+      globalThis.expect(spec.keys).toEqual([
+        "tenantId",
+        "region",
+        "service"
+      ]);
+      globalThis.expect(spec.seps).toEqual([
+        ":",
+        "/"
+      ]);
+    });
+    globalThis.test("returns Simple for schema with only @partitionTag", () => {
+      let result = DcbTag$Reventless.derivePartitionTag([[
+          "Order",
+          "test.res",
+          DcbFixtures$ReventlessCore.simplePartitionEventSchema
+        ]]);
+      if (result.TAG !== "Simple") {
+        return JestGlobals.fail("Expected Simple");
+      }
+      globalThis.expect(result._0.key).toBe("orderId");
+    });
+    globalThis.test("returns Simple for schema with single tagged field", () => {
+      let result = DcbTag$Reventless.derivePartitionTag([[
+          "Item",
+          "test.res",
+          DcbFixtures$ReventlessCore.singleTagCommandSchema
+        ]]);
+      if (result.TAG !== "Simple") {
+        return JestGlobals.fail("Expected Simple");
+      }
+      globalThis.expect(result._0.key).toBe("itemId");
+    });
+    globalThis.test("throws on mixed composite and simple partition strategy", () => {
+      let threw = false;
+      try {
+        DcbTag$Reventless.derivePartitionTag([[
+            "Mixed",
+            "test.res",
+            DcbFixtures$ReventlessCore.mixedStrategyEventSchema
+          ]]);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === "JsExn") {
+          threw = true;
+          globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "").includes("mixes @compositePartitionTag and @partitionTag")).toBe(true);
+        } else {
+          throw err;
+        }
+      }
+      globalThis.expect(threw).toBe(true);
+    });
+    globalThis.test("throws on single composite field (< 2)", () => {
+      let threw = false;
+      try {
+        DcbTag$Reventless.derivePartitionTag([[
+            "Single",
+            "test.res",
+            DcbFixtures$ReventlessCore.singleCompositeEventSchema
+          ]]);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === "JsExn") {
+          threw = true;
+          globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "").includes("at least 2 annotated fields")).toBe(true);
+        } else {
+          throw err;
+        }
+      }
+      globalThis.expect(threw).toBe(true);
+    });
+  });
+  globalThis.describe("isCompositePartitionMember", () => {
+    globalThis.test("returns true for compositePartitionMember schema", () => {
+      globalThis.expect(DcbTag$Reventless.isCompositePartitionMember(DcbTag$Reventless.compositePartitionMember(0, undefined))).toBe(true);
+    });
+    globalThis.test("returns false for plain DcbTag.string", () => {
+      globalThis.expect(DcbTag$Reventless.isCompositePartitionMember(DcbTag$Reventless.string)).toBe(false);
+    });
+    globalThis.test("returns false for plain S.string", () => {
+      globalThis.expect(DcbTag$Reventless.isCompositePartitionMember(S.string)).toBe(false);
+    });
+  });
+  globalThis.describe("buildQueryFromCommand", () => {
+    let eventTypes = [
+      "EventA",
+      "EventB"
+    ];
+    globalThis.test("scalar-only command produces single AND clause", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(eventTypes, DcbFixtures$ReventlessCore.singleTagCommandSchema, {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      }, undefined, undefined)).toEqual([{
+          eventTypes: eventTypes,
+          tags: [{
+              key: "itemId",
+              value: "item-1"
+            }]
+        }]);
+    });
+    globalThis.test("tagged array command produces per-element OR clauses", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(eventTypes, DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: [
+          "prod-1",
+          "prod-2"
+        ]
+      }, undefined, undefined)).toEqual([
+        {
+          eventTypes: eventTypes,
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        },
+        {
+          eventTypes: eventTypes,
+          tags: [{
+              key: "productId",
+              value: "prod-1"
+            }]
+        },
+        {
+          eventTypes: eventTypes,
+          tags: [{
+              key: "productId",
+              value: "prod-2"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("tagged array with single element produces two OR clauses", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(eventTypes, DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: ["prod-1"]
+      }, undefined, undefined)).toEqual([
+        {
+          eventTypes: eventTypes,
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        },
+        {
+          eventTypes: eventTypes,
+          tags: [{
+              key: "productId",
+              value: "prod-1"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("tagged array with empty array produces single clause for scalar tag", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(eventTypes, DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: []
+      }, undefined, undefined)).toEqual([{
+          eventTypes: eventTypes,
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        }]);
+    });
+    let orderTagKeys = DcbTag$Reventless.extractTagKeysByEventType(DcbFixtures$ReventlessCore.orderEventLogSchema);
+    globalThis.test("extractTagKeysByEventType maps each event type to its produced tag keys", () => {
+      globalThis.expect(Object.entries(orderTagKeys).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]))).toEqual([
+        [
+          "CatalogProductSynced",
+          ["productId"]
+        ],
+        [
+          "OrderPlaced",
+          [
+            "orderId",
+            "customerId",
+            "productId"
+          ]
+        ]
+      ]);
+    });
+    globalThis.test("narrowing drops the vacuous (CatalogProductSynced, orderId) combination but keeps OrderPlaced under productId", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand([
+        "OrderPlaced",
+        "CatalogProductSynced"
+      ], DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: ["prod-1"]
+      }, orderTagKeys, undefined)).toEqual([
+        {
+          eventTypes: ["OrderPlaced"],
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        },
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "productId",
+              value: "prod-1"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("narrowing the single AND clause keeps only types carrying every clause tag", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand([
+        "OrderPlaced",
+        "CatalogProductSynced"
+      ], DcbFixtures$ReventlessCore.singleTagCommandSchema, {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      }, orderTagKeys, undefined)).toEqual([{
+          eventTypes: [],
+          tags: [{
+              key: "itemId",
+              value: "item-1"
+            }]
+        }]);
+    });
+    globalThis.test("an empty map leaves all event types in place (no narrowing)", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand([
+        "OrderPlaced",
+        "CatalogProductSynced"
+      ], DcbFixtures$ReventlessCore.crossEntityCommandSchema, {
+        TAG: "PlaceOrder",
+        orderId: "ord-1",
+        customerId: "cust-1",
+        productId: ["prod-1"]
+      }, {}, undefined)).toEqual([
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        },
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "productId",
+              value: "prod-1"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("extractCrossPartitionTagKeys returns only the @crossPartition keys", () => {
+      globalThis.expect(DcbTag$Reventless.extractCrossPartitionTagKeys(DcbFixtures$ReventlessCore.subscriptionEventSchema)).toEqual(["studentId"]);
+    });
+    globalThis.test("extractCrossPartitionTagKeys is empty when no field is @crossPartition", () => {
+      globalThis.expect(DcbTag$Reventless.extractCrossPartitionTagKeys(DcbFixtures$ReventlessCore.simplePartitionEventSchema)).toEqual([]);
+    });
+    globalThis.test("a cross-partition tag fans a 2-tag command into two single-tag clauses", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(["StudentSubscribed"], DcbFixtures$ReventlessCore.subscribeCommandSchema, {
+        TAG: "SubscribeStudent",
+        courseId: "C1",
+        studentId: "S1"
+      }, undefined, ["studentId"])).toEqual([
+        {
+          eventTypes: ["StudentSubscribed"],
+          tags: [{
+              key: "courseId",
+              value: "C1"
+            }]
+        },
+        {
+          eventTypes: ["StudentSubscribed"],
+          tags: [{
+              key: "studentId",
+              value: "S1"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("without crossPartitionTagKeys the same 2-tag command stays one composite clause", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand(["StudentSubscribed"], DcbFixtures$ReventlessCore.subscribeCommandSchema, {
+        TAG: "SubscribeStudent",
+        courseId: "C1",
+        studentId: "S1"
+      }, undefined, undefined)).toEqual([{
+          eventTypes: ["StudentSubscribed"],
+          tags: [
+            {
+              key: "courseId",
+              value: "C1"
+            },
+            {
+              key: "studentId",
+              value: "S1"
+            }
+          ]
+        }]);
+    });
+    globalThis.test("hasTaggedArrayFields detects tagged arrays", () => {
+      globalThis.expect(DcbTag$Reventless.hasTaggedArrayFields(DcbFixtures$ReventlessCore.crossEntityCommandSchema)).toBe(true);
+    });
+    globalThis.test("hasTaggedArrayFields returns false for scalar-only schemas", () => {
+      globalThis.expect(DcbTag$Reventless.hasTaggedArrayFields(DcbFixtures$ReventlessCore.singleTagCommandSchema)).toBe(false);
+    });
+  });
+  globalThis.describe("stringForKey (tag-key override)", () => {
+    globalThis.test("isTagged is true for stringForKey schema", () => {
+      globalThis.expect(DcbTag$Reventless.isTagged(DcbTag$Reventless.stringForKey("productId"))).toBe(true);
+    });
+    globalThis.test("extractTags returns the override key for a scalar field", () => {
+      globalThis.expect(DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.customKeyEventSchema, {
+        TAG: "ProductLabelled",
+        sku: "SKU-42"
+      })).toEqual([{
+          key: "productSku",
+          value: "SKU-42"
+        }]);
+    });
+    globalThis.test("extractTagsExpanded uses the override key on every array element", () => {
+      globalThis.expect(DcbTag$Reventless.extractTagsExpanded(DcbFixtures$ReventlessCore.multiProductCommandSchema, {
+        TAG: "PlaceOrderWithMany",
+        orderId: "ord-1",
+        productIds: [
+          "prod-1",
+          "prod-2"
+        ]
+      })).toEqual([
+        {
+          key: "orderId",
+          value: "ord-1"
+        },
+        {
+          key: "productId",
+          value: "prod-1"
+        },
+        {
+          key: "productId",
+          value: "prod-2"
+        }
+      ]);
+    });
+    globalThis.test("buildQueryFromCommand emits the override key in OR clauses", () => {
+      globalThis.expect(DcbTag$Reventless.buildQueryFromCommand([
+        "OrderPlaced",
+        "CatalogProductSynced"
+      ], DcbFixtures$ReventlessCore.multiProductCommandSchema, {
+        TAG: "PlaceOrderWithMany",
+        orderId: "ord-1",
+        productIds: [
+          "prod-1",
+          "prod-2"
+        ]
+      }, undefined, undefined)).toEqual([
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "orderId",
+              value: "ord-1"
+            }]
+        },
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "productId",
+              value: "prod-1"
+            }]
+        },
+        {
+          eventTypes: [
+            "OrderPlaced",
+            "CatalogProductSynced"
+          ],
+          tags: [{
+              key: "productId",
+              value: "prod-2"
+            }]
+        }
+      ]);
+    });
+    globalThis.test("singular producer + plural consumer share the same tag key (round-trip)", () => {
+      let producerTags = DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.singleProductEventSchema, {
+        TAG: "CatalogProductSynced",
+        productId: "prod-1"
+      });
+      let consumerTags = DcbTag$Reventless.extractTagsExpanded(DcbFixtures$ReventlessCore.multiProductCommandSchema, {
+        TAG: "PlaceOrderWithMany",
+        orderId: "ord-1",
+        productIds: ["prod-1"]
+      });
+      let producerHead = producerTags[0];
+      let consumerProductTag = Stdlib_Option.getOrThrow(consumerTags.find(t => t.key !== "orderId"), undefined);
+      globalThis.expect(consumerProductTag.key).toBe(producerHead.key);
+    });
+  });
+});
+
+/*  Not a pure module */