@l-etabli/events 0.6.1 → 0.7.0

package/dist/effect/EffectInMemoryEventQueries.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EffectInMemoryEventQueries_exports = {};
+__export(EffectInMemoryEventQueries_exports, {
+  createEffectInMemoryEventQueries: () => createEffectInMemoryEventQueries
+});
+module.exports = __toCommonJS(EffectInMemoryEventQueries_exports);
+var import_effect = require("effect");
+var import_filterEvents = require("../filterEvents.ts");
+const createEffectInMemoryEventQueries = (helpers) => ({
+  eventQueries: {
+    getEvents: (params) => import_effect.Effect.sync(() => (0, import_filterEvents.filterEvents)(helpers.getAllEvents(), params))
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEffectInMemoryEventQueries
+});
+//# sourceMappingURL=EffectInMemoryEventQueries.cjs.map

package/dist/effect/EffectInMemoryEventQueries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectInMemoryEventQueries.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { filterEvents } from \"../filterEvents.ts\";\nimport type { DefaultContext, GenericEvent } from \"../types.ts\";\nimport type { InMemoryEventRepositoryHelpers } from \"./EffectInMemoryEventRepository.ts\";\nimport type { EventQueries } from \"./ports/EffectEventQueries.ts\";\n\nexport const createEffectInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: (params) =>\n      Effect.sync(() => filterEvents(helpers.getAllEvents(), params)),\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuB;AACvB,0BAA6B;AAKtB,MAAM,mCAAmC,CAG9C,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,CAAC,WACV,qBAAO,KAAK,UAAM,kCAAa,QAAQ,aAAa,GAAG,MAAM,CAAC;AAAA,EAClE;AACF;","names":[]}

package/dist/effect/EffectInMemoryEventQueries.d.cts

@@ -0,0 +1,12 @@
+import { GenericEvent, DefaultContext } from '../types.cjs';
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.cjs';
+import { EventQueries } from './ports/EffectEventQueries.cjs';
+import '../ports/EventRepository.cjs';
+import 'effect';
+import '../ports/EventQueries.cjs';
+
+declare const createEffectInMemoryEventQueries: <Event extends GenericEvent<string, unknown, DefaultContext>>(helpers: InMemoryEventRepositoryHelpers<Event>) => {
+    eventQueries: EventQueries<Event>;
+};
+
+export { createEffectInMemoryEventQueries };

package/dist/effect/EffectInMemoryEventQueries.d.ts

@@ -0,0 +1,12 @@
+import { GenericEvent, DefaultContext } from '../types.js';
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.js';
+import { EventQueries } from './ports/EffectEventQueries.js';
+import '../ports/EventRepository.js';
+import 'effect';
+import '../ports/EventQueries.js';
+
+declare const createEffectInMemoryEventQueries: <Event extends GenericEvent<string, unknown, DefaultContext>>(helpers: InMemoryEventRepositoryHelpers<Event>) => {
+    eventQueries: EventQueries<Event>;
+};
+
+export { createEffectInMemoryEventQueries };

package/dist/effect/EffectInMemoryEventQueries.mjs

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { filterEvents } from "../filterEvents.mjs";
+const createEffectInMemoryEventQueries = (helpers) => ({
+  eventQueries: {
+    getEvents: (params) => Effect.sync(() => filterEvents(helpers.getAllEvents(), params))
+  }
+});
+export {
+  createEffectInMemoryEventQueries
+};
+//# sourceMappingURL=EffectInMemoryEventQueries.mjs.map

package/dist/effect/EffectInMemoryEventQueries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectInMemoryEventQueries.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { filterEvents } from '../filterEvents.mjs';\nimport type { DefaultContext, GenericEvent } from '../types.mjs';\nimport type { InMemoryEventRepositoryHelpers } from './EffectInMemoryEventRepository.mjs';\nimport type { EventQueries } from './ports/EffectEventQueries.mjs';\n\nexport const createEffectInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: (params) =>\n      Effect.sync(() => filterEvents(helpers.getAllEvents(), params)),\n  },\n});\n"],"mappings":"AAAA,SAAS,cAAc;AACvB,SAAS,oBAAoB;AAKtB,MAAM,mCAAmC,CAG9C,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,CAAC,WACV,OAAO,KAAK,MAAM,aAAa,QAAQ,aAAa,GAAG,MAAM,CAAC;AAAA,EAClE;AACF;","names":[]}

package/dist/effect/EffectInMemoryEventRepository.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EffectInMemoryEventRepository_exports = {};
+__export(EffectInMemoryEventRepository_exports, {
+  createEffectInMemoryEventRepository: () => createEffectInMemoryEventRepository,
+  createEffectInMemoryWithUow: () => createEffectInMemoryWithUow
+});
+module.exports = __toCommonJS(EffectInMemoryEventRepository_exports);
+var import_effect = require("effect");
+const createEffectInMemoryEventRepository = () => {
+  const eventById = {};
+  const eventRepository = {
+    save: (event) => import_effect.Effect.sync(() => {
+      eventById[event.id] = event;
+    }),
+    saveNewEventsBatch: (events) => import_effect.Effect.sync(() => {
+      for (const event of events) {
+        eventById[event.id] = event;
+      }
+    }),
+    markEventsAsInProcess: (events) => import_effect.Effect.sync(() => {
+      for (const event of events) {
+        eventById[event.id] = { ...event, status: "in-process" };
+      }
+    })
+  };
+  return {
+    eventRepository,
+    helpers: {
+      getAllEvents: () => Object.values(eventById),
+      setEvents: (events) => {
+        for (const key of Object.keys(eventById)) {
+          delete eventById[key];
+        }
+        for (const event of events) {
+          eventById[event.id] = event;
+        }
+      }
+    }
+  };
+};
+const createEffectInMemoryWithUow = (eventRepository) => {
+  const withUow = (fn, options) => import_effect.Effect.gen(function* () {
+    const result = yield* fn({ eventRepository });
+    if (options?.afterCommit) {
+      yield* options.afterCommit();
+    }
+    return result;
+  });
+  return { withUow };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEffectInMemoryEventRepository,
+  createEffectInMemoryWithUow
+});
+//# sourceMappingURL=EffectInMemoryEventRepository.cjs.map

package/dist/effect/EffectInMemoryEventRepository.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectInMemoryEventRepository.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport type { InMemoryEventRepositoryHelpers } from \"../adapters/in-memory/InMemoryEventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"../types.ts\";\nimport type {\n  EventRepository,\n  WithEventsUow,\n} from \"./ports/EffectEventRepository.ts\";\n\nexport type { InMemoryEventRepositoryHelpers };\n\nexport const createEffectInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: (event) =>\n      Effect.sync(() => {\n        eventById[event.id] = event;\n      }),\n    saveNewEventsBatch: (events) =>\n      Effect.sync(() => {\n        for (const event of events) {\n          eventById[event.id] = event;\n        }\n      }),\n    markEventsAsInProcess: (events) =>\n      Effect.sync(() => {\n        for (const event of events) {\n          eventById[event.id] = { ...event, status: \"in-process\" };\n        }\n      }),\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        for (const key of Object.keys(eventById)) {\n          delete eventById[key];\n        }\n        for (const event of events) {\n          eventById[event.id] = event;\n        }\n      },\n    },\n  };\n};\n\nexport const createEffectInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  const withUow: WithEventsUow<Event> = (fn, options) =>\n    Effect.gen(function* () {\n      const result = yield* fn({ eventRepository });\n      if (options?.afterCommit) {\n        yield* options.afterCommit();\n      }\n      return result;\n    });\n  return { withUow };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuB;AAUhB,MAAM,sCAAsC,MAK9C;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,CAAC,UACL,qBAAO,KAAK,MAAM;AAChB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB,CAAC;AAAA,IACH,oBAAoB,CAAC,WACnB,qBAAO,KAAK,MAAM;AAChB,iBAAW,SAAS,QAAQ;AAC1B,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB;AAAA,IACF,CAAC;AAAA,IACH,uBAAuB,CAAC,WACtB,qBAAO,KAAK,MAAM;AAChB,iBAAW,SAAS,QAAQ;AAC1B,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD;AAAA,IACF,CAAC;AAAA,EACL;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,mBAAW,OAAO,OAAO,KAAK,SAAS,GAAG;AACxC,iBAAO,UAAU,GAAG;AAAA,QACtB;AACA,mBAAW,SAAS,QAAQ;AAC1B,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,8BAA8B,CAGzC,oBACsC;AACtC,QAAM,UAAgC,CAAC,IAAI,YACzC,qBAAO,IAAI,aAAa;AACtB,UAAM,SAAS,OAAO,GAAG,EAAE,gBAAgB,CAAC;AAC5C,QAAI,SAAS,aAAa;AACxB,aAAO,QAAQ,YAAY;AAAA,IAC7B;AACA,WAAO;AAAA,EACT,CAAC;AACH,SAAO,EAAE,QAAQ;AACnB;","names":[]}

package/dist/effect/EffectInMemoryEventRepository.d.cts

@@ -0,0 +1,15 @@
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.cjs';
+import { GenericEvent, DefaultContext } from '../types.cjs';
+import { EventRepository, WithEventsUow } from './ports/EffectEventRepository.cjs';
+import '../ports/EventRepository.cjs';
+import 'effect';
+
+declare const createEffectInMemoryEventRepository: <Event extends GenericEvent<string, unknown, DefaultContext>>() => {
+    eventRepository: EventRepository<Event>;
+    helpers: InMemoryEventRepositoryHelpers<Event>;
+};
+declare const createEffectInMemoryWithUow: <Event extends GenericEvent<string, unknown, DefaultContext>>(eventRepository: EventRepository<Event>) => {
+    withUow: WithEventsUow<Event>;
+};
+
+export { InMemoryEventRepositoryHelpers, createEffectInMemoryEventRepository, createEffectInMemoryWithUow };

package/dist/effect/EffectInMemoryEventRepository.d.ts

@@ -0,0 +1,15 @@
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.js';
+import { GenericEvent, DefaultContext } from '../types.js';
+import { EventRepository, WithEventsUow } from './ports/EffectEventRepository.js';
+import '../ports/EventRepository.js';
+import 'effect';
+
+declare const createEffectInMemoryEventRepository: <Event extends GenericEvent<string, unknown, DefaultContext>>() => {
+    eventRepository: EventRepository<Event>;
+    helpers: InMemoryEventRepositoryHelpers<Event>;
+};
+declare const createEffectInMemoryWithUow: <Event extends GenericEvent<string, unknown, DefaultContext>>(eventRepository: EventRepository<Event>) => {
+    withUow: WithEventsUow<Event>;
+};
+
+export { InMemoryEventRepositoryHelpers, createEffectInMemoryEventRepository, createEffectInMemoryWithUow };

package/dist/effect/EffectInMemoryEventRepository.mjs

@@ -0,0 +1,48 @@
+import { Effect } from "effect";
+const createEffectInMemoryEventRepository = () => {
+  const eventById = {};
+  const eventRepository = {
+    save: (event) => Effect.sync(() => {
+      eventById[event.id] = event;
+    }),
+    saveNewEventsBatch: (events) => Effect.sync(() => {
+      for (const event of events) {
+        eventById[event.id] = event;
+      }
+    }),
+    markEventsAsInProcess: (events) => Effect.sync(() => {
+      for (const event of events) {
+        eventById[event.id] = { ...event, status: "in-process" };
+      }
+    })
+  };
+  return {
+    eventRepository,
+    helpers: {
+      getAllEvents: () => Object.values(eventById),
+      setEvents: (events) => {
+        for (const key of Object.keys(eventById)) {
+          delete eventById[key];
+        }
+        for (const event of events) {
+          eventById[event.id] = event;
+        }
+      }
+    }
+  };
+};
+const createEffectInMemoryWithUow = (eventRepository) => {
+  const withUow = (fn, options) => Effect.gen(function* () {
+    const result = yield* fn({ eventRepository });
+    if (options?.afterCommit) {
+      yield* options.afterCommit();
+    }
+    return result;
+  });
+  return { withUow };
+};
+export {
+  createEffectInMemoryEventRepository,
+  createEffectInMemoryWithUow
+};
+//# sourceMappingURL=EffectInMemoryEventRepository.mjs.map

package/dist/effect/EffectInMemoryEventRepository.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectInMemoryEventRepository.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport type { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.mjs';\nimport type { DefaultContext, GenericEvent } from '../types.mjs';\nimport type {\n  EventRepository,\n  WithEventsUow,\n} from './ports/EffectEventRepository.mjs';\n\nexport type { InMemoryEventRepositoryHelpers };\n\nexport const createEffectInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: (event) =>\n      Effect.sync(() => {\n        eventById[event.id] = event;\n      }),\n    saveNewEventsBatch: (events) =>\n      Effect.sync(() => {\n        for (const event of events) {\n          eventById[event.id] = event;\n        }\n      }),\n    markEventsAsInProcess: (events) =>\n      Effect.sync(() => {\n        for (const event of events) {\n          eventById[event.id] = { ...event, status: \"in-process\" };\n        }\n      }),\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        for (const key of Object.keys(eventById)) {\n          delete eventById[key];\n        }\n        for (const event of events) {\n          eventById[event.id] = event;\n        }\n      },\n    },\n  };\n};\n\nexport const createEffectInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  const withUow: WithEventsUow<Event> = (fn, options) =>\n    Effect.gen(function* () {\n      const result = yield* fn({ eventRepository });\n      if (options?.afterCommit) {\n        yield* options.afterCommit();\n      }\n      return result;\n    });\n  return { withUow };\n};\n"],"mappings":"AAAA,SAAS,cAAc;AAUhB,MAAM,sCAAsC,MAK9C;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,CAAC,UACL,OAAO,KAAK,MAAM;AAChB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB,CAAC;AAAA,IACH,oBAAoB,CAAC,WACnB,OAAO,KAAK,MAAM;AAChB,iBAAW,SAAS,QAAQ;AAC1B,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB;AAAA,IACF,CAAC;AAAA,IACH,uBAAuB,CAAC,WACtB,OAAO,KAAK,MAAM;AAChB,iBAAW,SAAS,QAAQ;AAC1B,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD;AAAA,IACF,CAAC;AAAA,EACL;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,mBAAW,OAAO,OAAO,KAAK,SAAS,GAAG;AACxC,iBAAO,UAAU,GAAG;AAAA,QACtB;AACA,mBAAW,SAAS,QAAQ;AAC1B,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,8BAA8B,CAGzC,oBACsC;AACtC,QAAM,UAAgC,CAAC,IAAI,YACzC,OAAO,IAAI,aAAa;AACtB,UAAM,SAAS,OAAO,GAAG,EAAE,gBAAgB,CAAC;AAC5C,QAAI,SAAS,aAAa;AACxB,aAAO,QAAQ,YAAY;AAAA,IAC7B;AACA,WAAO;AAAA,EACT,CAAC;AACH,SAAO,EAAE,QAAQ;AACnB;","names":[]}

package/dist/effect/EffectSubscriptions.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EffectSubscriptions_exports = {};
+__export(EffectSubscriptions_exports, {
+  subscribeByTopic: () => subscribeByTopic,
+  subscribeGlobalToTopics: () => subscribeGlobalToTopics
+});
+module.exports = __toCommonJS(EffectSubscriptions_exports);
+function subscribeByTopic(eventBus, subscriptions) {
+  for (const topic of Object.keys(subscriptions)) {
+    const handlers = subscriptions[topic];
+    for (const { subscriptionId, handler } of handlers) {
+      eventBus.subscribe({
+        topic,
+        subscriptionId,
+        callBack: handler
+      });
+    }
+  }
+}
+function subscribeGlobalToTopics(eventBus, subscriptions, config) {
+  const allTopics = Object.keys(subscriptions);
+  let topicsToSubscribe;
+  const filter = config.filter;
+  if (!filter) {
+    topicsToSubscribe = allTopics;
+  } else if ("include" in filter) {
+    topicsToSubscribe = filter.include;
+  } else {
+    topicsToSubscribe = allTopics.filter((t) => !filter.exclude.includes(t));
+  }
+  for (const topic of topicsToSubscribe) {
+    eventBus.subscribe({
+      topic,
+      subscriptionId: config.subscriptionId,
+      callBack: config.handler
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  subscribeByTopic,
+  subscribeGlobalToTopics
+});
+//# sourceMappingURL=EffectSubscriptions.cjs.map

package/dist/effect/EffectSubscriptions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectSubscriptions.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport type { NarrowEvent, TopicFilter } from \"../subscriptions.ts\";\nimport type { DefaultContext, GenericEvent, SubscriptionId } from \"../types.ts\";\nimport type { EventBus } from \"./ports/EffectEventBus.ts\";\n\nexport type { NarrowEvent, TopicFilter };\n\nexport type TopicSubscriber<\n  E extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  subscriptionId: SubscriptionId;\n  handler: (event: E) => Effect.Effect<void>;\n};\n\nexport type TopicSubscriptions<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  [K in AllEvents[\"topic\"]]: Array<TopicSubscriber<NarrowEvent<AllEvents, K>>>;\n};\n\nexport type GlobalSubscriberConfig<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  subscriptionId: SubscriptionId;\n  handler: (event: AllEvents) => Effect.Effect<void>;\n  filter?: TopicFilter<AllEvents[\"topic\"]>;\n};\n\nexport function subscribeByTopic<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventBus: EventBus<AllEvents>,\n  subscriptions: TopicSubscriptions<AllEvents>,\n): void {\n  for (const topic of Object.keys(subscriptions) as AllEvents[\"topic\"][]) {\n    const handlers = subscriptions[topic];\n    for (const { subscriptionId, handler } of handlers) {\n      eventBus.subscribe({\n        topic,\n        subscriptionId,\n        callBack: handler,\n      });\n    }\n  }\n}\n\nexport function subscribeGlobalToTopics<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventBus: EventBus<AllEvents>,\n  subscriptions: TopicSubscriptions<AllEvents>,\n  config: GlobalSubscriberConfig<AllEvents>,\n): void {\n  const allTopics = Object.keys(subscriptions) as AllEvents[\"topic\"][];\n\n  let topicsToSubscribe: AllEvents[\"topic\"][];\n\n  const filter = config.filter;\n  if (!filter) {\n    topicsToSubscribe = allTopics;\n  } else if (\"include\" in filter) {\n    topicsToSubscribe = filter.include;\n  } else {\n    topicsToSubscribe = allTopics.filter((t) => !filter.exclude.includes(t));\n  }\n\n  for (const topic of topicsToSubscribe) {\n    eventBus.subscribe({\n      topic,\n      subscriptionId: config.subscriptionId,\n      callBack: config.handler,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BO,SAAS,iBAGd,UACA,eACM;AACN,aAAW,SAAS,OAAO,KAAK,aAAa,GAA2B;AACtE,UAAM,WAAW,cAAc,KAAK;AACpC,eAAW,EAAE,gBAAgB,QAAQ,KAAK,UAAU;AAClD,eAAS,UAAU;AAAA,QACjB;AAAA,QACA;AAAA,QACA,UAAU;AAAA,MACZ,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,SAAS,wBAGd,UACA,eACA,QACM;AACN,QAAM,YAAY,OAAO,KAAK,aAAa;AAE3C,MAAI;AAEJ,QAAM,SAAS,OAAO;AACtB,MAAI,CAAC,QAAQ;AACX,wBAAoB;AAAA,EACtB,WAAW,aAAa,QAAQ;AAC9B,wBAAoB,OAAO;AAAA,EAC7B,OAAO;AACL,wBAAoB,UAAU,OAAO,CAAC,MAAM,CAAC,OAAO,QAAQ,SAAS,CAAC,CAAC;AAAA,EACzE;AAEA,aAAW,SAAS,mBAAmB;AACrC,aAAS,UAAU;AAAA,MACjB;AAAA,MACA,gBAAgB,OAAO;AAAA,MACvB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/effect/EffectSubscriptions.d.cts

@@ -0,0 +1,22 @@
+import { Effect } from 'effect';
+import { NarrowEvent, TopicFilter } from '../subscriptions.cjs';
+import { GenericEvent, DefaultContext, SubscriptionId } from '../types.cjs';
+import { EventBus } from './ports/EffectEventBus.cjs';
+import '../ports/EventBus.cjs';
+
+type TopicSubscriber<E extends GenericEvent<string, unknown, DefaultContext>> = {
+    subscriptionId: SubscriptionId;
+    handler: (event: E) => Effect.Effect<void>;
+};
+type TopicSubscriptions<AllEvents extends GenericEvent<string, unknown, DefaultContext>> = {
+    [K in AllEvents["topic"]]: Array<TopicSubscriber<NarrowEvent<AllEvents, K>>>;
+};
+type GlobalSubscriberConfig<AllEvents extends GenericEvent<string, unknown, DefaultContext>> = {
+    subscriptionId: SubscriptionId;
+    handler: (event: AllEvents) => Effect.Effect<void>;
+    filter?: TopicFilter<AllEvents["topic"]>;
+};
+declare function subscribeByTopic<AllEvents extends GenericEvent<string, unknown, DefaultContext>>(eventBus: EventBus<AllEvents>, subscriptions: TopicSubscriptions<AllEvents>): void;
+declare function subscribeGlobalToTopics<AllEvents extends GenericEvent<string, unknown, DefaultContext>>(eventBus: EventBus<AllEvents>, subscriptions: TopicSubscriptions<AllEvents>, config: GlobalSubscriberConfig<AllEvents>): void;
+
+export { type GlobalSubscriberConfig, NarrowEvent, TopicFilter, type TopicSubscriber, type TopicSubscriptions, subscribeByTopic, subscribeGlobalToTopics };

package/dist/effect/EffectSubscriptions.d.ts

@@ -0,0 +1,22 @@
+import { Effect } from 'effect';
+import { NarrowEvent, TopicFilter } from '../subscriptions.js';
+import { GenericEvent, DefaultContext, SubscriptionId } from '../types.js';
+import { EventBus } from './ports/EffectEventBus.js';
+import '../ports/EventBus.js';
+
+type TopicSubscriber<E extends GenericEvent<string, unknown, DefaultContext>> = {
+    subscriptionId: SubscriptionId;
+    handler: (event: E) => Effect.Effect<void>;
+};
+type TopicSubscriptions<AllEvents extends GenericEvent<string, unknown, DefaultContext>> = {
+    [K in AllEvents["topic"]]: Array<TopicSubscriber<NarrowEvent<AllEvents, K>>>;
+};
+type GlobalSubscriberConfig<AllEvents extends GenericEvent<string, unknown, DefaultContext>> = {
+    subscriptionId: SubscriptionId;
+    handler: (event: AllEvents) => Effect.Effect<void>;
+    filter?: TopicFilter<AllEvents["topic"]>;
+};
+declare function subscribeByTopic<AllEvents extends GenericEvent<string, unknown, DefaultContext>>(eventBus: EventBus<AllEvents>, subscriptions: TopicSubscriptions<AllEvents>): void;
+declare function subscribeGlobalToTopics<AllEvents extends GenericEvent<string, unknown, DefaultContext>>(eventBus: EventBus<AllEvents>, subscriptions: TopicSubscriptions<AllEvents>, config: GlobalSubscriberConfig<AllEvents>): void;
+
+export { type GlobalSubscriberConfig, NarrowEvent, TopicFilter, type TopicSubscriber, type TopicSubscriptions, subscribeByTopic, subscribeGlobalToTopics };

package/dist/effect/EffectSubscriptions.mjs

@@ -0,0 +1,36 @@
+function subscribeByTopic(eventBus, subscriptions) {
+  for (const topic of Object.keys(subscriptions)) {
+    const handlers = subscriptions[topic];
+    for (const { subscriptionId, handler } of handlers) {
+      eventBus.subscribe({
+        topic,
+        subscriptionId,
+        callBack: handler
+      });
+    }
+  }
+}
+function subscribeGlobalToTopics(eventBus, subscriptions, config) {
+  const allTopics = Object.keys(subscriptions);
+  let topicsToSubscribe;
+  const filter = config.filter;
+  if (!filter) {
+    topicsToSubscribe = allTopics;
+  } else if ("include" in filter) {
+    topicsToSubscribe = filter.include;
+  } else {
+    topicsToSubscribe = allTopics.filter((t) => !filter.exclude.includes(t));
+  }
+  for (const topic of topicsToSubscribe) {
+    eventBus.subscribe({
+      topic,
+      subscriptionId: config.subscriptionId,
+      callBack: config.handler
+    });
+  }
+}
+export {
+  subscribeByTopic,
+  subscribeGlobalToTopics
+};
+//# sourceMappingURL=EffectSubscriptions.mjs.map

package/dist/effect/EffectSubscriptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/EffectSubscriptions.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport type { NarrowEvent, TopicFilter } from '../subscriptions.mjs';\nimport type { DefaultContext, GenericEvent, SubscriptionId } from '../types.mjs';\nimport type { EventBus } from './ports/EffectEventBus.mjs';\n\nexport type { NarrowEvent, TopicFilter };\n\nexport type TopicSubscriber<\n  E extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  subscriptionId: SubscriptionId;\n  handler: (event: E) => Effect.Effect<void>;\n};\n\nexport type TopicSubscriptions<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  [K in AllEvents[\"topic\"]]: Array<TopicSubscriber<NarrowEvent<AllEvents, K>>>;\n};\n\nexport type GlobalSubscriberConfig<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  subscriptionId: SubscriptionId;\n  handler: (event: AllEvents) => Effect.Effect<void>;\n  filter?: TopicFilter<AllEvents[\"topic\"]>;\n};\n\nexport function subscribeByTopic<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventBus: EventBus<AllEvents>,\n  subscriptions: TopicSubscriptions<AllEvents>,\n): void {\n  for (const topic of Object.keys(subscriptions) as AllEvents[\"topic\"][]) {\n    const handlers = subscriptions[topic];\n    for (const { subscriptionId, handler } of handlers) {\n      eventBus.subscribe({\n        topic,\n        subscriptionId,\n        callBack: handler,\n      });\n    }\n  }\n}\n\nexport function subscribeGlobalToTopics<\n  AllEvents extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventBus: EventBus<AllEvents>,\n  subscriptions: TopicSubscriptions<AllEvents>,\n  config: GlobalSubscriberConfig<AllEvents>,\n): void {\n  const allTopics = Object.keys(subscriptions) as AllEvents[\"topic\"][];\n\n  let topicsToSubscribe: AllEvents[\"topic\"][];\n\n  const filter = config.filter;\n  if (!filter) {\n    topicsToSubscribe = allTopics;\n  } else if (\"include\" in filter) {\n    topicsToSubscribe = filter.include;\n  } else {\n    topicsToSubscribe = allTopics.filter((t) => !filter.exclude.includes(t));\n  }\n\n  for (const topic of topicsToSubscribe) {\n    eventBus.subscribe({\n      topic,\n      subscriptionId: config.subscriptionId,\n      callBack: config.handler,\n    });\n  }\n}\n"],"mappings":"AA4BO,SAAS,iBAGd,UACA,eACM;AACN,aAAW,SAAS,OAAO,KAAK,aAAa,GAA2B;AACtE,UAAM,WAAW,cAAc,KAAK;AACpC,eAAW,EAAE,gBAAgB,QAAQ,KAAK,UAAU;AAClD,eAAS,UAAU;AAAA,QACjB;AAAA,QACA;AAAA,QACA,UAAU;AAAA,MACZ,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,SAAS,wBAGd,UACA,eACA,QACM;AACN,QAAM,YAAY,OAAO,KAAK,aAAa;AAE3C,MAAI;AAEJ,QAAM,SAAS,OAAO;AACtB,MAAI,CAAC,QAAQ;AACX,wBAAoB;AAAA,EACtB,WAAW,aAAa,QAAQ;AAC9B,wBAAoB,OAAO;AAAA,EAC7B,OAAO;AACL,wBAAoB,UAAU,OAAO,CAAC,MAAM,CAAC,OAAO,QAAQ,SAAS,CAAC,CAAC;AAAA,EACzE;AAEA,aAAW,SAAS,mBAAmB;AACrC,aAAS,UAAU;AAAA,MACjB;AAAA,MACA,gBAAgB,OAAO;AAAA,MACvB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/effect/index.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var effect_exports = {};
+__export(effect_exports, {
+  createEffectInMemoryEventRepositoryAndQueries: () => createEffectInMemoryEventRepositoryAndQueries
+});
+module.exports = __toCommonJS(effect_exports);
+var import_EffectInMemoryEventQueries = require("./EffectInMemoryEventQueries.ts");
+var import_EffectInMemoryEventRepository = require("./EffectInMemoryEventRepository.ts");
+__reExport(effect_exports, require("./EffectEventCrawler.ts"), module.exports);
+__reExport(effect_exports, require("./EffectInMemoryEventBus.ts"), module.exports);
+__reExport(effect_exports, require("./EffectInMemoryEventQueries.ts"), module.exports);
+__reExport(effect_exports, require("./EffectInMemoryEventRepository.ts"), module.exports);
+__reExport(effect_exports, require("./EffectSubscriptions.ts"), module.exports);
+const createEffectInMemoryEventRepositoryAndQueries = () => {
+  const { eventRepository, helpers } = (0, import_EffectInMemoryEventRepository.createEffectInMemoryEventRepository)();
+  const { eventQueries } = (0, import_EffectInMemoryEventQueries.createEffectInMemoryEventQueries)(helpers);
+  const { withUow } = (0, import_EffectInMemoryEventRepository.createEffectInMemoryWithUow)(eventRepository);
+  return { eventRepository, eventQueries, helpers, withUow };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEffectInMemoryEventRepositoryAndQueries,
+  ...require("./EffectEventCrawler.ts"),
+  ...require("./EffectInMemoryEventBus.ts"),
+  ...require("./EffectInMemoryEventQueries.ts"),
+  ...require("./EffectInMemoryEventRepository.ts"),
+  ...require("./EffectSubscriptions.ts")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/effect/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/index.ts"],"sourcesContent":["import type { DefaultContext, GenericEvent } from \"../types.ts\";\nimport { createEffectInMemoryEventQueries } from \"./EffectInMemoryEventQueries.ts\";\nimport {\n  createEffectInMemoryEventRepository,\n  createEffectInMemoryWithUow,\n} from \"./EffectInMemoryEventRepository.ts\";\n\nexport type { GetEventsParams } from \"../ports/EventQueries.ts\";\nexport * from \"./EffectEventCrawler.ts\";\nexport * from \"./EffectInMemoryEventBus.ts\";\nexport * from \"./EffectInMemoryEventQueries.ts\";\nexport * from \"./EffectInMemoryEventRepository.ts\";\nexport * from \"./EffectSubscriptions.ts\";\nexport type * from \"./ports/EffectEventBus.ts\";\nexport type * from \"./ports/EffectEventQueries.ts\";\nexport type * from \"./ports/EffectEventRepository.ts\";\n\nexport const createEffectInMemoryEventRepositoryAndQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>() => {\n  const { eventRepository, helpers } =\n    createEffectInMemoryEventRepository<Event>();\n  const { eventQueries } = createEffectInMemoryEventQueries<Event>(helpers);\n  const { withUow } = createEffectInMemoryWithUow<Event>(eventRepository);\n  return { eventRepository, eventQueries, helpers, withUow };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wCAAiD;AACjD,2CAGO;AAGP,2BAAc,oCARd;AASA,2BAAc,wCATd;AAUA,2BAAc,4CAVd;AAWA,2BAAc,+CAXd;AAYA,2BAAc,qCAZd;AAiBO,MAAM,gDAAgD,MAEtD;AACL,QAAM,EAAE,iBAAiB,QAAQ,QAC/B,0EAA2C;AAC7C,QAAM,EAAE,aAAa,QAAI,oEAAwC,OAAO;AACxE,QAAM,EAAE,QAAQ,QAAI,kEAAmC,eAAe;AACtE,SAAO,EAAE,iBAAiB,cAAc,SAAS,QAAQ;AAC3D;","names":[]}

package/dist/effect/index.d.cts

@@ -0,0 +1,27 @@
+export { createEffectInMemoryEventRepository, createEffectInMemoryWithUow } from './EffectInMemoryEventRepository.cjs';
+import { GenericEvent, DefaultContext } from '../types.cjs';
+export { GetEventsParams } from '../ports/EventQueries.cjs';
+export { createEffectEventCrawler } from './EffectEventCrawler.cjs';
+export { createEffectInMemoryEventBus } from './EffectInMemoryEventBus.cjs';
+export { createEffectInMemoryEventQueries } from './EffectInMemoryEventQueries.cjs';
+export { GlobalSubscriberConfig, TopicSubscriber, TopicSubscriptions, subscribeByTopic, subscribeGlobalToTopics } from './EffectSubscriptions.cjs';
+export { EventBus } from './ports/EffectEventBus.cjs';
+import { EventQueries } from './ports/EffectEventQueries.cjs';
+import { EventRepository, WithEventsUow } from './ports/EffectEventRepository.cjs';
+export { EventsUnitOfWork, WithEventsUowOptions } from './ports/EffectEventRepository.cjs';
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.cjs';
+export { NarrowEvent, TopicFilter } from '../subscriptions.cjs';
+import 'effect';
+import '../createNewEvent.cjs';
+import '../eventDefinitions.cjs';
+import '../ports/EventRepository.cjs';
+import '../ports/EventBus.cjs';
+
+declare const createEffectInMemoryEventRepositoryAndQueries: <Event extends GenericEvent<string, unknown, DefaultContext>>() => {
+    eventRepository: EventRepository<Event>;
+    eventQueries: EventQueries<Event>;
+    helpers: InMemoryEventRepositoryHelpers<Event>;
+    withUow: WithEventsUow<Event>;
+};
+
+export { EventQueries, EventRepository, InMemoryEventRepositoryHelpers, WithEventsUow, createEffectInMemoryEventRepositoryAndQueries };

package/dist/effect/index.d.ts

@@ -0,0 +1,27 @@
+export { createEffectInMemoryEventRepository, createEffectInMemoryWithUow } from './EffectInMemoryEventRepository.js';
+import { GenericEvent, DefaultContext } from '../types.js';
+export { GetEventsParams } from '../ports/EventQueries.js';
+export { createEffectEventCrawler } from './EffectEventCrawler.js';
+export { createEffectInMemoryEventBus } from './EffectInMemoryEventBus.js';
+export { createEffectInMemoryEventQueries } from './EffectInMemoryEventQueries.js';
+export { GlobalSubscriberConfig, TopicSubscriber, TopicSubscriptions, subscribeByTopic, subscribeGlobalToTopics } from './EffectSubscriptions.js';
+export { EventBus } from './ports/EffectEventBus.js';
+import { EventQueries } from './ports/EffectEventQueries.js';
+import { EventRepository, WithEventsUow } from './ports/EffectEventRepository.js';
+export { EventsUnitOfWork, WithEventsUowOptions } from './ports/EffectEventRepository.js';
+import { InMemoryEventRepositoryHelpers } from '../adapters/in-memory/InMemoryEventRepository.js';
+export { NarrowEvent, TopicFilter } from '../subscriptions.js';
+import 'effect';
+import '../createNewEvent.js';
+import '../eventDefinitions.js';
+import '../ports/EventRepository.js';
+import '../ports/EventBus.js';
+
+declare const createEffectInMemoryEventRepositoryAndQueries: <Event extends GenericEvent<string, unknown, DefaultContext>>() => {
+    eventRepository: EventRepository<Event>;
+    eventQueries: EventQueries<Event>;
+    helpers: InMemoryEventRepositoryHelpers<Event>;
+    withUow: WithEventsUow<Event>;
+};
+
+export { EventQueries, EventRepository, InMemoryEventRepositoryHelpers, WithEventsUow, createEffectInMemoryEventRepositoryAndQueries };

package/dist/effect/index.mjs

@@ -0,0 +1,20 @@
+import { createEffectInMemoryEventQueries } from "./EffectInMemoryEventQueries.mjs";
+import {
+  createEffectInMemoryEventRepository,
+  createEffectInMemoryWithUow
+} from "./EffectInMemoryEventRepository.mjs";
+export * from "./EffectEventCrawler.mjs";
+export * from "./EffectInMemoryEventBus.mjs";
+export * from "./EffectInMemoryEventQueries.mjs";
+export * from "./EffectInMemoryEventRepository.mjs";
+export * from "./EffectSubscriptions.mjs";
+const createEffectInMemoryEventRepositoryAndQueries = () => {
+  const { eventRepository, helpers } = createEffectInMemoryEventRepository();
+  const { eventQueries } = createEffectInMemoryEventQueries(helpers);
+  const { withUow } = createEffectInMemoryWithUow(eventRepository);
+  return { eventRepository, eventQueries, helpers, withUow };
+};
+export {
+  createEffectInMemoryEventRepositoryAndQueries
+};
+//# sourceMappingURL=index.mjs.map

package/dist/effect/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/index.ts"],"sourcesContent":["import type { DefaultContext, GenericEvent } from '../types.mjs';\nimport { createEffectInMemoryEventQueries } from './EffectInMemoryEventQueries.mjs';\nimport {\n  createEffectInMemoryEventRepository,\n  createEffectInMemoryWithUow,\n} from './EffectInMemoryEventRepository.mjs';\n\nexport type { GetEventsParams } from '../ports/EventQueries.mjs';\nexport * from './EffectEventCrawler.mjs';\nexport * from './EffectInMemoryEventBus.mjs';\nexport * from './EffectInMemoryEventQueries.mjs';\nexport * from './EffectInMemoryEventRepository.mjs';\nexport * from './EffectSubscriptions.mjs';\nexport type * from './ports/EffectEventBus.mjs';\nexport type * from './ports/EffectEventQueries.mjs';\nexport type * from './ports/EffectEventRepository.mjs';\n\nexport const createEffectInMemoryEventRepositoryAndQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>() => {\n  const { eventRepository, helpers } =\n    createEffectInMemoryEventRepository<Event>();\n  const { eventQueries } = createEffectInMemoryEventQueries<Event>(helpers);\n  const { withUow } = createEffectInMemoryWithUow<Event>(eventRepository);\n  return { eventRepository, eventQueries, helpers, withUow };\n};\n"],"mappings":"AACA,SAAS,wCAAwC;AACjD;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAGP,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AAKP,MAAM,gDAAgD,MAEtD;AACL,QAAM,EAAE,iBAAiB,QAAQ,IAC/B,oCAA2C;AAC7C,QAAM,EAAE,aAAa,IAAI,iCAAwC,OAAO;AACxE,QAAM,EAAE,QAAQ,IAAI,4BAAmC,eAAe;AACtE,SAAO,EAAE,iBAAiB,cAAc,SAAS,QAAQ;AAC3D;","names":[]}

package/dist/effect/ports/EffectEventBus.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EffectEventBus_exports = {};
+module.exports = __toCommonJS(EffectEventBus_exports);
+//# sourceMappingURL=EffectEventBus.cjs.map

package/dist/effect/ports/EffectEventBus.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/effect/ports/EffectEventBus.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport type {\n  DefaultContext,\n  GenericEvent,\n  SubscriptionId,\n} from \"../../types.ts\";\n\nexport type EventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  publish: (event: Event) => Effect.Effect<void>;\n  subscribe: <E extends GenericEvent<string, unknown, DefaultContext>>(params: {\n    topic: E[\"topic\"];\n    subscriptionId: SubscriptionId;\n    callBack: (e: E) => Effect.Effect<void>;\n  }) => void;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/effect/ports/EffectEventBus.d.cts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { GenericEvent, DefaultContext, SubscriptionId } from '../../types.cjs';
+
+type EventBus<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    publish: (event: Event) => Effect.Effect<void>;
+    subscribe: <E extends GenericEvent<string, unknown, DefaultContext>>(params: {
+        topic: E["topic"];
+        subscriptionId: SubscriptionId;
+        callBack: (e: E) => Effect.Effect<void>;
+    }) => void;
+};
+
+export type { EventBus };

package/dist/effect/ports/EffectEventBus.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { GenericEvent, DefaultContext, SubscriptionId } from '../../types.js';
+
+type EventBus<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    publish: (event: Event) => Effect.Effect<void>;
+    subscribe: <E extends GenericEvent<string, unknown, DefaultContext>>(params: {
+        topic: E["topic"];
+        subscriptionId: SubscriptionId;
+        callBack: (e: E) => Effect.Effect<void>;
+    }) => void;
+};
+
+export type { EventBus };

package/dist/effect/ports/EffectEventBus.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=EffectEventBus.mjs.map

package/dist/effect/ports/EffectEventBus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}