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

package/tests/dcb/DcbValidationTest.res.mjs

@@ -1,476 +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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
-
-let producedASchema = S.union([
-  S.schema(s => ({
-    TAG: "ItemCreated",
-    itemId: s.m(DcbTag$Reventless.string),
-    name: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ItemRenamed",
-    itemId: s.m(DcbTag$Reventless.string),
-    newName: s.m(S.string)
-  }))
-]);
-
-let producedBSchema = S.schema(s => ({
-  TAG: "ItemArchived",
-  itemId: s.m(DcbTag$Reventless.string)
-}));
-
-let producedADuplicateSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(DcbTag$Reventless.string),
-  name: s.m(S.string)
-}));
-
-let producedAMismatchFieldsSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(DcbTag$Reventless.string)
-}));
-
-let producedAMismatchTagsSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(S.string),
-  name: s.m(S.string)
-}));
-
-let producedAMismatchTypeSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(DcbTag$Reventless.string),
-  name: s.m(S.float)
-}));
-
-let consumedFullSchema = S.union([
-  S.schema(s => ({
-    TAG: "ItemCreated",
-    itemId: s.m(S.string),
-    name: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ItemRenamed",
-    itemId: s.m(S.string),
-    newName: s.m(S.string)
-  }))
-]);
-
-let consumedPartialSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(S.string)
-}));
-
-let consumedPayloadLessSchema = S.union([
-  S.literal("ItemCreated"),
-  S.literal("ItemArchived")
-]);
-
-let consumedDanglingSchema = S.schema(s => ({
-  TAG: "ItemDeleted",
-  itemId: s.m(S.string)
-}));
-
-let consumedBadFieldSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(S.string),
-  rating: s.m(S.float)
-}));
-
-let consumedBadTypeSchema = S.schema(s => ({
-  TAG: "ItemCreated",
-  itemId: s.m(S.string),
-  name: s.m(S.float)
-}));
-
-let recordDemandCommandSchema = S.schema(s => ({
-  TAG: "RecordDemand",
-  productId: s.m(DcbTag$Reventless.string),
-  orderId: s.m(DcbTag$Reventless.string)
-}));
-
-let touchDemandCommandSchema = S.schema(s => ({
-  TAG: "TouchDemand",
-  productId: s.m(DcbTag$Reventless.string)
-}));
-
-let placeOrderCommandSchema = S.schema(s => ({
-  TAG: "PlaceOrder",
-  orderId: s.m(DcbTag$Reventless.string),
-  productIds: s.m(S.array(DcbTag$Reventless.stringForKey("productId")))
-}));
-
-let demandConsumedSchema = S.union([
-  S.schema(s => ({
-    TAG: "ProductDemandRecorded",
-    productId: s.m(S.string),
-    orderId: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ProductDemandRevoked",
-    productId: s.m(S.string),
-    orderId: s.m(S.string)
-  }))
-]);
-
-let demandProducedSchema = S.union([
-  S.schema(s => ({
-    TAG: "ProductDemandRecorded",
-    productId: s.m(DcbTag$Reventless.string),
-    orderId: s.m(DcbTag$Reventless.string)
-  })),
-  S.schema(s => ({
-    TAG: "ProductDemandRevoked",
-    productId: s.m(DcbTag$Reventless.string),
-    orderId: s.m(DcbTag$Reventless.string),
-    customerId: s.m(DcbTag$Reventless.string)
-  }))
-]);
-
-function u(prim) {
-  return prim;
-}
-
-let producedTagKeys = DcbTag$Reventless.extractTagKeysByEventType(demandProducedSchema);
-
-let subscribedCrossPartitionSchema = S.schema(s => ({
-  TAG: "StudentSubscribed",
-  courseId: s.m(DcbTag$Reventless.partition),
-  studentId: s.m(DcbTag$Reventless.crossPartition)
-}));
-
-let unsubscribedCrossPartitionSchema = S.schema(s => ({
-  TAG: "StudentUnsubscribed",
-  courseId: s.m(DcbTag$Reventless.partition),
-  studentId: s.m(DcbTag$Reventless.crossPartition)
-}));
-
-let flaggedPartitionScopedSchema = S.schema(s => ({
-  TAG: "StudentFlagged",
-  studentId: s.m(DcbTag$Reventless.partition),
-  courseId: s.m(DcbTag$Reventless.string)
-}));
-
-globalThis.describe("DcbValidation:", () => {
-  globalThis.describe("validateProducedAndConsumed", () => {
-    globalThis.test("passes when all consumed events match produced events", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "ArchiveItem",
-          producedBSchema
-        ]
-      ], [[
-          "ItemView",
-          consumedFullSchema
-        ]]);
-      globalThis.expect(result).toEqual({
-        TAG: "Ok",
-        _0: undefined
-      });
-    });
-    globalThis.test("passes with partial field projection", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
-          "AddItem",
-          producedASchema
-        ]], [[
-          "CheckExists",
-          consumedPartialSchema
-        ]]);
-      globalThis.expect(result).toEqual({
-        TAG: "Ok",
-        _0: undefined
-      });
-    });
-    globalThis.test("passes with payload-less consumed events", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "ArchiveItem",
-          producedBSchema
-        ]
-      ], [[
-          "CheckExists",
-          consumedPayloadLessSchema
-        ]]);
-      globalThis.expect(result).toEqual({
-        TAG: "Ok",
-        _0: undefined
-      });
-    });
-    globalThis.test("passes when multiple producers have identical shapes and tags", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "CloneItem",
-          producedADuplicateSchema
-        ]
-      ], []);
-      globalThis.expect(result).toEqual({
-        TAG: "Ok",
-        _0: undefined
-      });
-    });
-    globalThis.test("fails when consumed event has no producer", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
-          "AddItem",
-          producedASchema
-        ]], [[
-          "DeleteHandler",
-          consumedDanglingSchema
-        ]]);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBe(1);
-      let err = errors[0];
-      globalThis.expect(err.sliceName).toBe("DeleteHandler");
-      globalThis.expect(err.message.includes("ItemDeleted")).toBe(true);
-      globalThis.expect(err.message.includes("no slice produces it")).toBe(true);
-    });
-    globalThis.test("fails when consumed event references field not in produced shape", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
-          "AddItem",
-          producedASchema
-        ]], [[
-          "RatingView",
-          consumedBadFieldSchema
-        ]]);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBe(1);
-      let err = errors[0];
-      globalThis.expect(err.sliceName).toBe("RatingView");
-      globalThis.expect(err.message.includes("rating")).toBe(true);
-      globalThis.expect(err.message.includes("no field")).toBe(true);
-    });
-    globalThis.test("fails when consumed field type mismatches produced field type", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
-          "AddItem",
-          producedASchema
-        ]], [[
-          "BadTypeView",
-          consumedBadTypeSchema
-        ]]);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBe(1);
-      let err = errors[0];
-      globalThis.expect(err.sliceName).toBe("BadTypeView");
-      globalThis.expect(err.message.includes("name")).toBe(true);
-      globalThis.expect(err.message.includes("float")).toBe(true);
-      globalThis.expect(err.message.includes("string")).toBe(true);
-    });
-    globalThis.test("fails when producers have different fields for same TAG", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "ImportItem",
-          producedAMismatchFieldsSchema
-        ]
-      ], []);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
-      let err = errors[0];
-      globalThis.expect(err.message.includes("AddItem")).toBe(true);
-      globalThis.expect(err.message.includes("ImportItem")).toBe(true);
-      globalThis.expect(err.message.includes("name")).toBe(true);
-    });
-    globalThis.test("fails when producers have different tag annotations for same TAG", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "UntaggerItem",
-          producedAMismatchTagsSchema
-        ]
-      ], []);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
-      let hasTagError = errors.some(err => err.message.includes("tag annotations"));
-      globalThis.expect(hasTagError).toBe(true);
-    });
-    globalThis.test("fails when producers have different field types for same TAG", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([
-        [
-          "AddItem",
-          producedASchema
-        ],
-        [
-          "BadTypeItem",
-          producedAMismatchTypeSchema
-        ]
-      ], []);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation error");
-      }
-      let errors = result._0;
-      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
-      let err = errors[0];
-      globalThis.expect(err.message.includes("name")).toBe(true);
-      globalThis.expect(err.message.includes("string")).toBe(true);
-      globalThis.expect(err.message.includes("float")).toBe(true);
-    });
-    globalThis.test("passes with empty produced and consumed", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([], []);
-      globalThis.expect(result).toEqual({
-        TAG: "Ok",
-        _0: undefined
-      });
-    });
-    globalThis.test("collects multiple errors at once", () => {
-      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
-          "AddItem",
-          producedASchema
-        ]], [
-        [
-          "DeleteHandler",
-          consumedDanglingSchema
-        ],
-        [
-          "BadTypeView",
-          consumedBadTypeSchema
-        ]
-      ]);
-      if (result.TAG === "Ok") {
-        return JestGlobals.fail("Expected validation errors");
-      }
-      globalThis.expect(result._0.length).toBeGreaterThanOrEqual(2);
-    });
-  });
-  globalThis.describe("validateCompositeReads (Issue 5)", () => {
-    globalThis.test("warns when a composite read's consumed type carries an extra tag", () => {
-      let warnings = DcbValidation$Reventless.validateCompositeReads([[
-          "RecordDemand",
-          recordDemandCommandSchema,
-          demandConsumedSchema
-        ]], producedTagKeys);
-      globalThis.expect(warnings.length).toBe(1);
-      let w = warnings[0];
-      globalThis.expect(w.sliceName).toBe("RecordDemand");
-      globalThis.expect(w.message.includes("ProductDemandRevoked")).toBe(true);
-      globalThis.expect(w.message.includes("customerId")).toBe(true);
-    });
-    globalThis.test("does not warn for an exact-match consumed type", () => {
-      let warnings = DcbValidation$Reventless.validateCompositeReads([[
-          "RecordDemand",
-          recordDemandCommandSchema,
-          demandConsumedSchema
-        ]], producedTagKeys);
-      globalThis.expect(warnings.some(w => w.message.includes("ProductDemandRecorded"))).toBe(false);
-    });
-    globalThis.test("ignores single-tag commands (partition read, not composite)", () => {
-      let warnings = DcbValidation$Reventless.validateCompositeReads([[
-          "TouchDemand",
-          touchDemandCommandSchema,
-          demandConsumedSchema
-        ]], producedTagKeys);
-      globalThis.expect(warnings).toEqual([]);
-    });
-    globalThis.test("ignores tagged-array commands (per-element OR, not composite)", () => {
-      let warnings = DcbValidation$Reventless.validateCompositeReads([[
-          "PlaceOrder",
-          placeOrderCommandSchema,
-          demandConsumedSchema
-        ]], producedTagKeys);
-      globalThis.expect(warnings).toEqual([]);
-    });
-    globalThis.test("no warnings when nothing reads compositely", () => {
-      globalThis.expect(DcbValidation$Reventless.validateCompositeReads([], producedTagKeys)).toEqual([]);
-    });
-  });
-  globalThis.describe("validateCrossPartitionScope (Issue 13)", () => {
-    globalThis.test("no warning when every carrier of a key agrees on cross-partition scope", () => {
-      let warnings = DcbValidation$Reventless.validateCrossPartitionScope([
-        [
-          "Subscribe",
-          subscribedCrossPartitionSchema
-        ],
-        [
-          "Unsubscribe",
-          unsubscribedCrossPartitionSchema
-        ]
-      ]);
-      globalThis.expect(warnings).toEqual([]);
-    });
-    globalThis.test("warns when one producer leaves a cross-partition key partition-scoped", () => {
-      let warnings = DcbValidation$Reventless.validateCrossPartitionScope([
-        [
-          "Subscribe",
-          subscribedCrossPartitionSchema
-        ],
-        [
-          "Flag",
-          flaggedPartitionScopedSchema
-        ]
-      ]);
-      globalThis.expect(warnings.length).toBe(1);
-      let w = warnings[0];
-      globalThis.expect(w.sliceName).toBe("Flag");
-      globalThis.expect(w.message.includes("studentId")).toBe(true);
-    });
-    globalThis.test("no warning when no key is cross-partition anywhere", () => {
-      globalThis.expect(DcbValidation$Reventless.validateCrossPartitionScope([[
-          "Flag",
-          flaggedPartitionScopedSchema
-        ]])).toEqual([]);
-    });
-  });
-});
-
-let validate = DcbValidation$Reventless.validateProducedAndConsumed;
-
-export {
-  producedASchema,
-  producedBSchema,
-  producedADuplicateSchema,
-  producedAMismatchFieldsSchema,
-  producedAMismatchTagsSchema,
-  producedAMismatchTypeSchema,
-  consumedFullSchema,
-  consumedPartialSchema,
-  consumedPayloadLessSchema,
-  consumedDanglingSchema,
-  consumedBadFieldSchema,
-  consumedBadTypeSchema,
-  recordDemandCommandSchema,
-  touchDemandCommandSchema,
-  placeOrderCommandSchema,
-  demandConsumedSchema,
-  demandProducedSchema,
-  validate,
-  u,
-  producedTagKeys,
-  subscribedCrossPartitionSchema,
-  unsubscribedCrossPartitionSchema,
-  flaggedPartitionScopedSchema,
-}
-/* producedASchema Not a pure module */

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -1,196 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as S from "sury/src/S.res.mjs";
-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";
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-
-S.enableJson();
-
-let eventSchema = S.union([
-  S.schema(s => ({
-    TAG: "ItemCreated",
-    name: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ItemDeleted",
-    id: s.m(S.string)
-  }))
-]);
-
-let ItemEventLogSpec = {
-  Id: undefined,
-  name: "TestItemEventLog",
-  eventSchema: eventSchema
-};
-
-let storedEvents = {
-  contents: {}
-};
-
-let storedSnapshots = {
-  contents: {}
-};
-
-let failNextAppend = {
-  contents: false
-};
-
-let failNextAppendsWithTransient = {
-  contents: 0
-};
-
-let appendCallCount = {
-  contents: 0
-};
-
-async function mockStorage_append(_seqNr, id, jsons) {
-  appendCallCount.contents = appendCallCount.contents + 1 | 0;
-  if (failNextAppend.contents) {
-    failNextAppend.contents = false;
-    return {
-      TAG: "Error",
-      _0: {
-        TAG: "StorageFailure",
-        _0: "mock storage failure"
-      }
-    };
-  }
-  if (failNextAppendsWithTransient.contents > 0) {
-    failNextAppendsWithTransient.contents = failNextAppendsWithTransient.contents - 1 | 0;
-    return {
-      TAG: "Error",
-      _0: {
-        TAG: "StorageFailure",
-        _0: "ThrottlingException: Rate exceeded"
-      }
-    };
-  }
-  let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);
-  storedEvents.contents[id] = existing.concat(jsons);
-  return {
-    TAG: "Ok",
-    _0: undefined
-  };
-}
-
-async function mockStorage_replay(id) {
-  return Stdlib_Option.getOr(storedEvents.contents[id], []);
-}
-
-function mockStorage_replayStream(id, fromSeqOpt) {
-  let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
-  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []).slice(fromSeq));
-}
-
-function mockStorage_appendStream(_startingSeqNr, id, stream) {
-  return Stream.runForEach(stream, json => Effect.sync(() => {
-    let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);
-    storedEvents.contents[id] = existing.concat([json]);
-  }));
-}
-
-async function mockStorage_latestSnapshot(id) {
-  return {
-    TAG: "Ok",
-    _0: storedSnapshots.contents[id]
-  };
-}
-
-async function mockStorage_writeSnapshot(id, snap) {
-  storedSnapshots.contents[id] = snap;
-  return {
-    TAG: "Ok",
-    _0: undefined
-  };
-}
-
-let mockStorage = {
-  append: mockStorage_append,
-  replay: mockStorage_replay,
-  replayStream: mockStorage_replayStream,
-  appendStream: mockStorage_appendStream,
-  latestSnapshot: mockStorage_latestSnapshot,
-  writeSnapshot: mockStorage_writeSnapshot
-};
-
-let capturedPublishes = {
-  contents: []
-};
-
-function make(param, param$1, param$2) {
-  return 0;
-}
-
-let MockEventTopic_Spec = {
-  Id: Id$Reventless.StringPure,
-  name: "TestItem",
-  eventSchema: eventSchema
-};
-
-let MockEventTopic = {
-  Spec: MockEventTopic_Spec,
-  make: make
-};
-
-async function mockEventTopicOps_publish(events) {
-  capturedPublishes.contents = capturedPublishes.contents.concat(events);
-}
-
-async function mockEventTopicOps_publishJson(_service, _meta, _json) {
-  
-}
-
-function mockEventTopicOps_publishJsonStream(_stream) {
-  return Effect.succeed();
-}
-
-let mockEventTopicOps = {
-  publish: mockEventTopicOps_publish,
-  publishJson: mockEventTopicOps_publishJson,
-  publishJsonStream: mockEventTopicOps_publishJsonStream
-};
-
-let testMeta = {
-  service: "test",
-  time: "2024-01-01T00:00:00.000Z",
-  ip: "127.0.0.1",
-  user: "testuser",
-  msgId: "msg-001",
-  correlationId: "corr-001"
-};
-
-function makeEvent$p(id, event) {
-  return {
-    id: id,
-    meta: testMeta,
-    event: event
-  };
-}
-
-function reset() {
-  storedEvents.contents = {};
-  storedSnapshots.contents = {};
-  failNextAppend.contents = false;
-  failNextAppendsWithTransient.contents = 0;
-  appendCallCount.contents = 0;
-  capturedPublishes.contents = [];
-}
-
-export {
-  ItemEventLogSpec,
-  storedEvents,
-  storedSnapshots,
-  failNextAppend,
-  failNextAppendsWithTransient,
-  appendCallCount,
-  mockStorage,
-  capturedPublishes,
-  MockEventTopic,
-  mockEventTopicOps,
-  testMeta,
-  makeEvent$p,
-  reset,
-}
-/*  Not a pure module */