@webiny/api-core 0.0.0-unstable.61c048f412

package/features/buildParams/abstractions.d.ts

@@ -0,0 +1,15 @@
+export interface IBuildParam {
+    key: string;
+    value: any;
+}
+export declare const BuildParam: import("@webiny/di").Abstraction<IBuildParam>;
+export declare namespace BuildParam {
+    type Interface = IBuildParam;
+}
+export interface IBuildParams {
+    get<T = any>(key: string): T | null;
+}
+export declare const BuildParams: import("@webiny/di").Abstraction<IBuildParams>;
+export declare namespace BuildParams {
+    type Interface = IBuildParams;
+}

package/features/buildParams/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const BuildParam = createAbstraction("BuildParam");
+export const BuildParams = createAbstraction("BuildParams");
+
+//# sourceMappingURL=abstractions.js.map

package/features/buildParams/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","BuildParam","BuildParams"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IBuildParam {\n    key: string;\n    value: any;\n}\n\nexport const BuildParam = createAbstraction<IBuildParam>(\"BuildParam\");\n\nexport namespace BuildParam {\n    export type Interface = IBuildParam;\n}\n\nexport interface IBuildParams {\n    get<T = any>(key: string): T | null;\n}\n\nexport const BuildParams = createAbstraction<IBuildParams>(\"BuildParams\");\n\nexport namespace BuildParams {\n    export type Interface = IBuildParams;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAOvD,OAAO,MAAMC,UAAU,GAAGD,iBAAiB,CAAc,YAAY,CAAC;AAUtE,OAAO,MAAME,WAAW,GAAGF,iBAAiB,CAAe,aAAa,CAAC","ignoreList":[]}

package/features/buildParams/feature.d.ts

@@ -0,0 +1 @@
+export declare const BuildParamsFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/buildParams/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { BuildParams } from "./BuildParams.js";
+export const BuildParamsFeature = createFeature({
+  name: "BuildParamsFeature",
+  register(container) {
+    container.register(BuildParams);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/buildParams/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","BuildParams","BuildParamsFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { BuildParams } from \"./BuildParams.js\";\n\nexport const BuildParamsFeature = createFeature({\n    name: \"BuildParamsFeature\",\n    register(container: Container) {\n        container.register(BuildParams);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,WAAW;AAEpB,OAAO,MAAMC,kBAAkB,GAAGF,aAAa,CAAC;EAC5CG,IAAI,EAAE,oBAAoB;EAC1BC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACH,WAAW,CAAC;EACnC;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/buildParams/index.d.ts

@@ -0,0 +1 @@
+export { BuildParam, BuildParams } from "./abstractions.js";

package/features/buildParams/index.js

@@ -0,0 +1,3 @@
+export { BuildParam, BuildParams } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/buildParams/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BuildParam","BuildParams"],"sources":["index.ts"],"sourcesContent":["export { BuildParam, BuildParams } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,UAAU,EAAEC,WAAW","ignoreList":[]}

package/features/eventPublisher/EventPublisher.d.ts

@@ -0,0 +1,7 @@
+import type { Container } from "@webiny/di";
+import { EventPublisher as Abstraction, DomainEvent } from "./abstractions.js";
+export declare class EventPublisher implements Abstraction.Interface {
+    private container;
+    constructor(container: Container);
+    publish<TEvent extends DomainEvent>(event: TEvent): Promise<void>;
+}

package/features/eventPublisher/EventPublisher.js

@@ -0,0 +1,19 @@
+export class EventPublisher {
+  constructor(container) {
+    this.container = container;
+  }
+  async publish(event) {
+    // Get handler abstraction from the event itself
+    const handlerAbstraction = event.getHandlerAbstraction();
+
+    // Resolve ALL implementations of that abstraction
+    const handlers = this.container.resolveAll(handlerAbstraction);
+
+    // Execute all handlers
+    for (const handler of handlers) {
+      await handler.handle(event);
+    }
+  }
+}
+
+//# sourceMappingURL=EventPublisher.js.map

package/features/eventPublisher/EventPublisher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventPublisher","constructor","container","publish","event","handlerAbstraction","getHandlerAbstraction","handlers","resolveAll","handler","handle"],"sources":["EventPublisher.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventPublisher as Abstraction, DomainEvent } from \"./abstractions.js\";\n\nexport class EventPublisher implements Abstraction.Interface {\n    constructor(private container: Container) {}\n\n    async publish<TEvent extends DomainEvent>(event: TEvent): Promise<void> {\n        // Get handler abstraction from the event itself\n        const handlerAbstraction = event.getHandlerAbstraction();\n\n        // Resolve ALL implementations of that abstraction\n        const handlers = this.container.resolveAll(handlerAbstraction);\n\n        // Execute all handlers\n        for (const handler of handlers) {\n            await handler.handle(event);\n        }\n    }\n}\n"],"mappings":"AAGA,OAAO,MAAMA,cAAc,CAAkC;EACzDC,WAAWA,CAASC,SAAoB,EAAE;IAAA,KAAtBA,SAAoB,GAApBA,SAAoB;EAAG;EAE3C,MAAMC,OAAOA,CAA6BC,KAAa,EAAiB;IACpE;IACA,MAAMC,kBAAkB,GAAGD,KAAK,CAACE,qBAAqB,CAAC,CAAC;;IAExD;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACL,SAAS,CAACM,UAAU,CAACH,kBAAkB,CAAC;;IAE9D;IACA,KAAK,MAAMI,OAAO,IAAIF,QAAQ,EAAE;MAC5B,MAAME,OAAO,CAACC,MAAM,CAACN,KAAK,CAAC;IAC/B;EACJ;AACJ","ignoreList":[]}

package/features/eventPublisher/__tests__/EventPublisher.test.d.ts

@@ -0,0 +1,92 @@
+import { Abstraction } from "@webiny/di";
+import type { DomainEvent, IEventHandler } from "../abstractions.js";
+interface PagePublishedPayload {
+    pageId: string;
+    title: string;
+    publishedBy: string;
+    publishedAt: Date;
+}
+declare class PagePublishedEvent implements DomainEvent<PagePublishedPayload> {
+    payload: PagePublishedPayload;
+    eventType: "page.published";
+    occurredAt: Date;
+    constructor(payload: PagePublishedPayload);
+    getHandlerAbstraction(): Abstraction<IEventHandler<PagePublishedEvent>>;
+}
+export declare const PagePublishedHandler: Abstraction<IEventHandler<PagePublishedEvent>>;
+interface UserRegisteredPayload {
+    userId: string;
+    email: string;
+    name: string;
+}
+declare class UserRegisteredEvent implements DomainEvent<UserRegisteredPayload> {
+    payload: UserRegisteredPayload;
+    eventType: "user.registered";
+    occurredAt: Date;
+    constructor(payload: UserRegisteredPayload);
+    getHandlerAbstraction(): Abstraction<IEventHandler<UserRegisteredEvent>>;
+}
+export declare const UserRegisteredHandler: Abstraction<IEventHandler<UserRegisteredEvent>>;
+interface OrderPlacedPayload {
+    orderId: string;
+    customerId: string;
+    total: number;
+    items: Array<{
+        productId: string;
+        quantity: number;
+    }>;
+}
+declare class OrderPlacedEvent implements DomainEvent<OrderPlacedPayload> {
+    payload: OrderPlacedPayload;
+    eventType: "order.placed";
+    occurredAt: Date;
+    constructor(payload: OrderPlacedPayload);
+    getHandlerAbstraction(): Abstraction<IEventHandler<OrderPlacedEvent>>;
+}
+export declare const OrderPlacedHandler: Abstraction<IEventHandler<OrderPlacedEvent>>;
+declare class SendNotificationHandler implements IEventHandler<PagePublishedEvent> {
+    handledEvents: PagePublishedEvent[];
+    handle(event: PagePublishedEvent): Promise<void>;
+}
+export declare const SendNotificationHandlerImpl: import("@webiny/di").Implementation<typeof SendNotificationHandler>;
+declare class UpdateSearchIndexHandler implements IEventHandler<PagePublishedEvent> {
+    handledEvents: PagePublishedEvent[];
+    handle(event: PagePublishedEvent): Promise<void>;
+}
+export declare const UpdateSearchIndexHandlerImpl: import("@webiny/di").Implementation<typeof UpdateSearchIndexHandler>;
+declare class LogPagePublishedHandler implements IEventHandler<PagePublishedEvent> {
+    handledEvents: PagePublishedEvent[];
+    handle(event: PagePublishedEvent): Promise<void>;
+}
+export declare const LogPagePublishedHandlerImpl: import("@webiny/di").Implementation<typeof LogPagePublishedHandler>;
+declare class SendWelcomeEmailHandler implements IEventHandler<UserRegisteredEvent> {
+    handledEvents: UserRegisteredEvent[];
+    handle(event: UserRegisteredEvent): Promise<void>;
+}
+export declare const SendWelcomeEmailHandlerImpl: import("@webiny/di").Implementation<typeof SendWelcomeEmailHandler>;
+declare class CreateUserProfileHandler implements IEventHandler<UserRegisteredEvent> {
+    handledEvents: UserRegisteredEvent[];
+    handle(event: UserRegisteredEvent): Promise<void>;
+}
+export declare const CreateUserProfileHandlerImpl: import("@webiny/di").Implementation<typeof CreateUserProfileHandler>;
+declare class TrackUserRegistrationHandler implements IEventHandler<UserRegisteredEvent> {
+    handledEvents: UserRegisteredEvent[];
+    handle(event: UserRegisteredEvent): Promise<void>;
+}
+export declare const TrackUserRegistrationHandlerImpl: import("@webiny/di").Implementation<typeof TrackUserRegistrationHandler>;
+declare class ProcessPaymentHandler implements IEventHandler<OrderPlacedEvent> {
+    handledEvents: OrderPlacedEvent[];
+    handle(event: OrderPlacedEvent): Promise<void>;
+}
+export declare const ProcessPaymentHandlerImpl: import("@webiny/di").Implementation<typeof ProcessPaymentHandler>;
+declare class SendOrderConfirmationHandler implements IEventHandler<OrderPlacedEvent> {
+    handledEvents: OrderPlacedEvent[];
+    handle(event: OrderPlacedEvent): Promise<void>;
+}
+export declare const SendOrderConfirmationHandlerImpl: import("@webiny/di").Implementation<typeof SendOrderConfirmationHandler>;
+declare class UpdateInventoryHandler implements IEventHandler<OrderPlacedEvent> {
+    handledEvents: OrderPlacedEvent[];
+    handle(event: OrderPlacedEvent): Promise<void>;
+}
+export declare const UpdateInventoryHandlerImpl: import("@webiny/di").Implementation<typeof UpdateInventoryHandler>;
+export {};

package/features/eventPublisher/__tests__/EventPublisher.test.js

@@ -0,0 +1,463 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { Container, Abstraction, createImplementation } from "@webiny/di";
+import { EventPublisherFeature } from "../feature.js";
+import { EventPublisher as EventPublisherAbstraction } from "../abstractions.js";
+
+// ============================================================================
+// Test Event: PagePublished
+// ============================================================================
+
+class PagePublishedEvent {
+  eventType = "page.published";
+  constructor(payload) {
+    this.payload = payload;
+    this.occurredAt = new Date();
+  }
+  getHandlerAbstraction() {
+    return PagePublishedHandler;
+  }
+}
+export const PagePublishedHandler = new Abstraction("PagePublishedHandler");
+
+// ============================================================================
+// Test Event: UserRegistered
+// ============================================================================
+
+class UserRegisteredEvent {
+  eventType = "user.registered";
+  constructor(payload) {
+    this.payload = payload;
+    this.occurredAt = new Date();
+  }
+  getHandlerAbstraction() {
+    return UserRegisteredHandler;
+  }
+}
+export const UserRegisteredHandler = new Abstraction("UserRegisteredHandler");
+
+// ============================================================================
+// Test Event: OrderPlaced
+// ============================================================================
+
+class OrderPlacedEvent {
+  eventType = "order.placed";
+  constructor(payload) {
+    this.payload = payload;
+    this.occurredAt = new Date();
+  }
+  getHandlerAbstraction() {
+    return OrderPlacedHandler;
+  }
+}
+export const OrderPlacedHandler = new Abstraction("OrderPlacedHandler");
+
+// ============================================================================
+// Handler Implementations for PagePublished
+// ============================================================================
+
+class SendNotificationHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`📧 Sending notification for page: ${event.payload.title}`);
+  }
+}
+export const SendNotificationHandlerImpl = createImplementation({
+  abstraction: PagePublishedHandler,
+  implementation: SendNotificationHandler,
+  dependencies: []
+});
+class UpdateSearchIndexHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`🔍 Updating search index for page: ${event.payload.pageId}`);
+  }
+}
+export const UpdateSearchIndexHandlerImpl = createImplementation({
+  abstraction: PagePublishedHandler,
+  implementation: UpdateSearchIndexHandler,
+  dependencies: []
+});
+class LogPagePublishedHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`📝 Logging: Page ${event.payload.pageId} published by ${event.payload.publishedBy}`);
+  }
+}
+export const LogPagePublishedHandlerImpl = createImplementation({
+  abstraction: PagePublishedHandler,
+  implementation: LogPagePublishedHandler,
+  dependencies: []
+});
+
+// ============================================================================
+// Handler Implementations for UserRegistered
+// ============================================================================
+
+class SendWelcomeEmailHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`👋 Sending welcome email to: ${event.payload.email}`);
+  }
+}
+export const SendWelcomeEmailHandlerImpl = createImplementation({
+  abstraction: UserRegisteredHandler,
+  implementation: SendWelcomeEmailHandler,
+  dependencies: []
+});
+class CreateUserProfileHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`👤 Creating profile for user: ${event.payload.userId}`);
+  }
+}
+export const CreateUserProfileHandlerImpl = createImplementation({
+  abstraction: UserRegisteredHandler,
+  implementation: CreateUserProfileHandler,
+  dependencies: []
+});
+class TrackUserRegistrationHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`📊 Tracking registration analytics for: ${event.payload.userId}`);
+  }
+}
+export const TrackUserRegistrationHandlerImpl = createImplementation({
+  abstraction: UserRegisteredHandler,
+  implementation: TrackUserRegistrationHandler,
+  dependencies: []
+});
+
+// ============================================================================
+// Handler Implementations for OrderPlaced
+// ============================================================================
+
+class ProcessPaymentHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`💳 Processing payment for order: ${event.payload.orderId}`);
+  }
+}
+export const ProcessPaymentHandlerImpl = createImplementation({
+  abstraction: OrderPlacedHandler,
+  implementation: ProcessPaymentHandler,
+  dependencies: []
+});
+class SendOrderConfirmationHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`📧 Sending order confirmation for: ${event.payload.orderId}`);
+  }
+}
+export const SendOrderConfirmationHandlerImpl = createImplementation({
+  abstraction: OrderPlacedHandler,
+  implementation: SendOrderConfirmationHandler,
+  dependencies: []
+});
+class UpdateInventoryHandler {
+  handledEvents = [];
+  async handle(event) {
+    this.handledEvents.push(event);
+    console.log(`📦 Updating inventory for ${event.payload.items.length} items`);
+  }
+}
+export const UpdateInventoryHandlerImpl = createImplementation({
+  abstraction: OrderPlacedHandler,
+  implementation: UpdateInventoryHandler,
+  dependencies: []
+});
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("EventPublisher", () => {
+  let container;
+  let publisher;
+  beforeEach(() => {
+    container = new Container();
+
+    // ✅ Register EventPublisher using the feature
+    EventPublisherFeature.register(container);
+    publisher = container.resolve(EventPublisherAbstraction);
+  });
+  describe("PagePublished Event", () => {
+    it("should execute all registered PagePublished handlers", async () => {
+      // Register handlers
+      container.register(SendNotificationHandlerImpl).inSingletonScope();
+      container.register(UpdateSearchIndexHandlerImpl).inSingletonScope();
+      container.register(LogPagePublishedHandlerImpl).inSingletonScope();
+
+      // Create and publish event
+      const event = new PagePublishedEvent({
+        pageId: "page-123",
+        title: "Getting Started with TypeScript",
+        publishedBy: "user-456",
+        publishedAt: new Date()
+      });
+      await publisher.publish(event);
+
+      // Verify all handlers were called
+      const handlers = container.resolveAll(PagePublishedHandler);
+      expect(handlers).toHaveLength(3);
+      expect(handlers[0].handledEvents).toHaveLength(1);
+      expect(handlers[1].handledEvents).toHaveLength(1);
+      expect(handlers[2].handledEvents).toHaveLength(1);
+    });
+    it("should pass correct event data to handlers", async () => {
+      container.register(SendNotificationHandlerImpl).inSingletonScope();
+      const eventData = {
+        pageId: "page-789",
+        title: "Advanced Patterns",
+        publishedBy: "admin-001",
+        publishedAt: new Date("2024-01-15")
+      };
+      const event = new PagePublishedEvent(eventData);
+      await publisher.publish(event);
+      const handler = container.resolve(PagePublishedHandler);
+      const handledEvent = handler.handledEvents[0];
+      expect(handledEvent.payload.pageId).toBe(eventData.pageId);
+      expect(handledEvent.payload.title).toBe(eventData.title);
+      expect(handledEvent.payload.publishedBy).toBe(eventData.publishedBy);
+      expect(handledEvent.eventType).toBe("page.published");
+    });
+    it("should handle multiple events sequentially", async () => {
+      container.register(LogPagePublishedHandlerImpl).inSingletonScope();
+      const event1 = new PagePublishedEvent({
+        pageId: "page-1",
+        title: "First Page",
+        publishedBy: "user-1",
+        publishedAt: new Date()
+      });
+      const event2 = new PagePublishedEvent({
+        pageId: "page-2",
+        title: "Second Page",
+        publishedBy: "user-2",
+        publishedAt: new Date()
+      });
+      await publisher.publish(event1);
+      await publisher.publish(event2);
+      const handler = container.resolve(PagePublishedHandler);
+      expect(handler.handledEvents).toHaveLength(2);
+      expect(handler.handledEvents[0].payload.pageId).toBe("page-1");
+      expect(handler.handledEvents[1].payload.pageId).toBe("page-2");
+    });
+    it("should work with no handlers registered", async () => {
+      const event = new PagePublishedEvent({
+        pageId: "page-999",
+        title: "Orphan Page",
+        publishedBy: "user-999",
+        publishedAt: new Date()
+      });
+
+      // Should not throw
+      await expect(publisher.publish(event)).resolves.not.toThrow();
+    });
+  });
+  describe("UserRegistered Event", () => {
+    it("should execute all registered UserRegistered handlers", async () => {
+      container.register(SendWelcomeEmailHandlerImpl).inSingletonScope();
+      container.register(CreateUserProfileHandlerImpl).inSingletonScope();
+      container.register(TrackUserRegistrationHandlerImpl).inSingletonScope();
+      const event = new UserRegisteredEvent({
+        userId: "user-123",
+        email: "john@example.com",
+        name: "John Doe"
+      });
+      await publisher.publish(event);
+      const handlers = container.resolveAll(UserRegisteredHandler);
+      expect(handlers).toHaveLength(3);
+      expect(handlers[0].handledEvents).toHaveLength(1);
+      expect(handlers[1].handledEvents).toHaveLength(1);
+      expect(handlers[2].handledEvents).toHaveLength(1);
+    });
+    it("should pass correct user data to handlers", async () => {
+      container.register(CreateUserProfileHandlerImpl).inSingletonScope();
+      const event = new UserRegisteredEvent({
+        userId: "user-456",
+        email: "jane@example.com",
+        name: "Jane Smith"
+      });
+      await publisher.publish(event);
+      const handler = container.resolve(UserRegisteredHandler);
+      const handledEvent = handler.handledEvents[0];
+      expect(handledEvent.payload.userId).toBe("user-456");
+      expect(handledEvent.payload.email).toBe("jane@example.com");
+      expect(handledEvent.payload.name).toBe("Jane Smith");
+      expect(handledEvent.eventType).toBe("user.registered");
+    });
+  });
+  describe("OrderPlaced Event", () => {
+    it("should execute all registered OrderPlaced handlers", async () => {
+      container.register(ProcessPaymentHandlerImpl).inSingletonScope();
+      container.register(SendOrderConfirmationHandlerImpl).inSingletonScope();
+      container.register(UpdateInventoryHandlerImpl).inSingletonScope();
+      const event = new OrderPlacedEvent({
+        orderId: "order-123",
+        customerId: "customer-456",
+        total: 99.99,
+        items: [{
+          productId: "prod-1",
+          quantity: 2
+        }, {
+          productId: "prod-2",
+          quantity: 1
+        }]
+      });
+      await publisher.publish(event);
+      const handlers = container.resolveAll(OrderPlacedHandler);
+      expect(handlers).toHaveLength(3);
+      expect(handlers[0].handledEvents).toHaveLength(1);
+      expect(handlers[1].handledEvents).toHaveLength(1);
+      expect(handlers[2].handledEvents).toHaveLength(1);
+    });
+    it("should pass correct order data to handlers", async () => {
+      container.register(UpdateInventoryHandlerImpl).inSingletonScope();
+      const orderData = {
+        orderId: "order-789",
+        customerId: "customer-123",
+        total: 249.99,
+        items: [{
+          productId: "prod-10",
+          quantity: 1
+        }, {
+          productId: "prod-20",
+          quantity: 3
+        }]
+      };
+      const event = new OrderPlacedEvent(orderData);
+      await publisher.publish(event);
+      const handler = container.resolve(OrderPlacedHandler);
+      const handledEvent = handler.handledEvents[0];
+      expect(handledEvent.payload.orderId).toBe(orderData.orderId);
+      expect(handledEvent.payload.total).toBe(orderData.total);
+      expect(handledEvent.payload.items).toHaveLength(2);
+      expect(handledEvent.eventType).toBe("order.placed");
+    });
+  });
+  describe("Mixed Events", () => {
+    it("should handle different event types independently", async () => {
+      // Register handlers for different events
+      container.register(SendNotificationHandlerImpl).inSingletonScope();
+      container.register(SendWelcomeEmailHandlerImpl).inSingletonScope();
+      container.register(ProcessPaymentHandlerImpl).inSingletonScope();
+
+      // Publish different events
+      const pageEvent = new PagePublishedEvent({
+        pageId: "page-1",
+        title: "Test Page",
+        publishedBy: "user-1",
+        publishedAt: new Date()
+      });
+      const userEvent = new UserRegisteredEvent({
+        userId: "user-2",
+        email: "test@example.com",
+        name: "Test User"
+      });
+      const orderEvent = new OrderPlacedEvent({
+        orderId: "order-1",
+        customerId: "customer-1",
+        total: 50.0,
+        items: [{
+          productId: "prod-1",
+          quantity: 1
+        }]
+      });
+      await publisher.publish(pageEvent);
+      await publisher.publish(userEvent);
+      await publisher.publish(orderEvent);
+
+      // Verify each handler only received its event type
+      const pageHandlers = container.resolveAll(PagePublishedHandler);
+      const userHandlers = container.resolveAll(UserRegisteredHandler);
+      const orderHandlers = container.resolveAll(OrderPlacedHandler);
+      expect(pageHandlers[0].handledEvents).toHaveLength(1);
+      expect(userHandlers[0].handledEvents).toHaveLength(1);
+      expect(orderHandlers[0].handledEvents).toHaveLength(1);
+    });
+    it("should maintain event isolation between types", async () => {
+      container.register(SendNotificationHandlerImpl).inSingletonScope();
+      container.register(SendWelcomeEmailHandlerImpl).inSingletonScope();
+      const pageEvent = new PagePublishedEvent({
+        pageId: "page-1",
+        title: "Test",
+        publishedBy: "user-1",
+        publishedAt: new Date()
+      });
+      const userEvent = new UserRegisteredEvent({
+        userId: "user-1",
+        email: "test@test.com",
+        name: "Test"
+      });
+      await publisher.publish(pageEvent);
+      await publisher.publish(userEvent);
+      const pageHandler = container.resolve(PagePublishedHandler);
+      const userHandler = container.resolve(UserRegisteredHandler);
+
+      // Page handler should only have page events
+      expect(pageHandler.handledEvents).toHaveLength(1);
+      expect(pageHandler.handledEvents[0].eventType).toBe("page.published");
+
+      // User handler should only have user events
+      expect(userHandler.handledEvents).toHaveLength(1);
+      expect(userHandler.handledEvents[0].eventType).toBe("user.registered");
+    });
+  });
+  describe("Error Handling", () => {
+    it("should handle handler errors gracefully", async () => {
+      class FailingHandler {
+        async handle() {
+          throw new Error("Handler failed!");
+        }
+      }
+      const FailingHandlerImpl = createImplementation({
+        abstraction: PagePublishedHandler,
+        implementation: FailingHandler,
+        dependencies: []
+      });
+      container.register(FailingHandlerImpl);
+      const event = new PagePublishedEvent({
+        pageId: "page-1",
+        title: "Test",
+        publishedBy: "user-1",
+        publishedAt: new Date()
+      });
+
+      // Should throw the handler error
+      await expect(publisher.publish(event)).rejects.toThrow("Handler failed!");
+    });
+  });
+  describe("Handler Registration", () => {
+    it("should support dynamic handler registration", async () => {
+      const event = new PagePublishedEvent({
+        pageId: "page-1",
+        title: "Test",
+        publishedBy: "user-1",
+        publishedAt: new Date()
+      });
+
+      // No handlers yet
+      await publisher.publish(event);
+      let handlers = container.resolveAll(PagePublishedHandler);
+      expect(handlers).toHaveLength(0);
+
+      // Register handler
+      container.register(SendNotificationHandlerImpl).inSingletonScope();
+
+      // Now handler should execute
+      await publisher.publish(event);
+      handlers = container.resolveAll(PagePublishedHandler);
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].handledEvents).toHaveLength(1);
+    });
+  });
+});
+
+//# sourceMappingURL=EventPublisher.test.js.map