@reventlessdev/reventless-core 3.0.0-alpha.170 → 3.0.0-alpha.171

package/tests/dcb/DcbTagTest.res.mjs

@@ -1,867 +0,0 @@
-// 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 */