@geekmidas/constructs 0.3.2 → 0.6.0

package/src/endpoints/__tests__/HonoEndpointAdaptor.events.spec.ts

@@ -1,8 +1,8 @@
 import { EnvironmentParser } from '@geekmidas/envkit';
 import type {
-  EventPublisher,
-  MappedEvent,
-  PublishableMessage,
+	EventPublisher,
+	MappedEvent,
+	PublishableMessage,
 } from '@geekmidas/events';
 import type { Logger } from '@geekmidas/logger';
 import { type Service, ServiceDiscovery } from '@geekmidas/services';
@@ -14,564 +14,564 @@ import { HonoEndpoint } from '../HonoEndpointAdaptor';
 
 // Test event types
 type TestEvent =
-  | PublishableMessage<'user.created', { userId: string; email: string }>
-  | PublishableMessage<'user.updated', { userId: string; changes: string[] }>
-  | PublishableMessage<'notification.sent', { userId: string; type: string }>;
+	| PublishableMessage<'user.created', { userId: string; email: string }>
+	| PublishableMessage<'user.updated', { userId: string; changes: string[] }>
+	| PublishableMessage<'notification.sent', { userId: string; type: string }>;
 
 describe('HonoEndpoint Events', () => {
-  const mockLogger: Logger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    fatal: vi.fn(),
-    trace: vi.fn(),
-    child: vi.fn(() => mockLogger),
-  };
-  const envParser = new EnvironmentParser({});
-  const serviceDiscovery = ServiceDiscovery.getInstance(mockLogger, envParser);
-
-  it('should publish events after successful endpoint execution', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<
-      'publisher',
-      EventPublisher<TestEvent>
-    > = {
-      serviceName: 'publisher' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => ({ id: '123', email: 'test@example.com' }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      id: '123',
-      email: 'test@example.com',
-    });
-
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.created',
-        payload: { userId: '123', email: 'test@example.com' },
-      },
-    ]);
-  });
-
-  it('should publish multiple events after successful endpoint execution', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-      serviceName: Math.random().toString(),
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-      {
-        type: 'notification.sent',
-        payload: (response) => ({ userId: response.id, type: 'welcome' }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => ({ id: '456', email: 'user@example.com' }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 201,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(201);
-    expect(await response.json()).toEqual({
-      id: '456',
-      email: 'user@example.com',
-    });
-
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.created',
-        payload: { userId: '456', email: 'user@example.com' },
-      },
-      {
-        type: 'notification.sent',
-        payload: { userId: '456', type: 'welcome' },
-      },
-    ]);
-  });
-
-  it('should respect when conditions for events', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-      serviceName: Math.random().toString(),
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({
-      id: z.string(),
-      email: z.string(),
-      isNew: z.boolean(),
-    });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-        when: (response) => response.isNew === true,
-      },
-      {
-        type: 'user.updated',
-        payload: (response) => ({ userId: response.id, changes: ['email'] }),
-        when: (response) => response.isNew === false,
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users/:id',
-      method: 'PUT',
-      fn: async () => ({
-        id: '789',
-        email: 'updated@example.com',
-        isNew: false,
-      }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users/789', {
-      method: 'PUT',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      id: '789',
-      email: 'updated@example.com',
-      isNew: false,
-    });
-
-    // Only user.updated event should be published due to when condition
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.updated',
-        payload: { userId: '789', changes: ['email'] },
-      },
-    ]);
-  });
-
-  it('should not publish events when no publisher is configured', async () => {
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => ({ id: '999', email: 'test@example.com' }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: undefined, // No publisher service
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      id: '999',
-      email: 'test@example.com',
-    });
-
-    // No publisher calls should be made
-    expect(mockLogger.warn).toHaveBeenCalledWith(
-      'No publisher service available',
-    );
-  });
-
-  it('should not publish events when no events are configured', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<
-      'publisher',
-      EventPublisher<TestEvent>
-    > = {
-      serviceName: 'publisher' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => ({ id: '111', email: 'test@example.com' }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events: undefined, // No events
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      id: '111',
-      email: 'test@example.com',
-    });
-
-    // No events should be published
-    expect(mockPublisher.publish).not.toHaveBeenCalled();
-    expect(mockLogger.debug).toHaveBeenCalledWith('No events to publish');
-  });
-
-  it('should continue processing even when event publishing fails', async () => {
-    const publishError = new Error('Event bus connection failed');
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockRejectedValue(publishError),
-    };
-
-    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-      serviceName: Math.random().toString(),
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => ({ id: '888', email: 'error@example.com' }),
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    // The endpoint should still succeed despite event publishing failure
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      id: '888',
-      email: 'error@example.com',
-    });
-
-    expect(mockPublisher.publish).toHaveBeenCalled();
-    expect(mockLogger.error).toHaveBeenCalledWith(
-      publishError,
-      'Failed to publish events',
-    );
-  });
-
-  it('should publish events with input data context', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
-      serviceName: Math.random().toString(),
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const bodySchema = z.object({ name: z.string(), email: z.string() });
-    const outputSchema = z.object({
-      id: z.string(),
-      name: z.string(),
-      email: z.string(),
-    });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async ({ body }) => ({
-        id: '777',
-        name: body.name,
-        email: body.email,
-      }),
-      input: { body: bodySchema },
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 201,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({ name: 'John Doe', email: 'john@example.com' }),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    expect(response.status).toBe(201);
-    expect(await response.json()).toEqual({
-      id: '777',
-      name: 'John Doe',
-      email: 'john@example.com',
-    });
-
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.created',
-        payload: { userId: '777', email: 'john@example.com' },
-      },
-    ]);
-  });
-
-  it('should not publish events when endpoint throws an error', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const mockPublisherService: Service<
-      'publisher',
-      EventPublisher<TestEvent>
-    > = {
-      serviceName: 'publisher' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const outputSchema = z.object({ id: z.string(), email: z.string() });
-
-    const events: MappedEvent<
-      EventPublisher<TestEvent>,
-      typeof outputSchema
-    >[] = [
-      {
-        type: 'user.created',
-        payload: (response) => ({ userId: response.id, email: response.email }),
-      },
-    ];
-
-    const endpoint = new Endpoint({
-      route: '/users',
-      method: 'POST',
-      fn: async () => {
-        throw new Error('Something went wrong');
-      },
-      input: undefined,
-      output: outputSchema,
-      services: [],
-      logger: mockLogger,
-      timeout: undefined,
-      memorySize: undefined,
-      status: 200,
-      getSession: undefined,
-      authorize: undefined,
-      description: undefined,
-      events,
-      publisherService: mockPublisherService,
-    });
-
-    const adaptor = new HonoEndpoint(endpoint);
-    const app = new Hono();
-    HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
-
-    adaptor.addRoute(serviceDiscovery, app);
-
-    const response = await app.request('/users', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-    // Should return 500 due to error
-    expect(response.status).toBe(500);
-
-    // No events should be published when endpoint throws an error
-    expect(mockPublisher.publish).not.toHaveBeenCalled();
-  });
+	const mockLogger: Logger = {
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		trace: vi.fn(),
+		child: vi.fn(() => mockLogger),
+	};
+	const envParser = new EnvironmentParser({});
+	const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
+
+	it('should publish events after successful endpoint execution', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<
+			'publisher',
+			EventPublisher<TestEvent>
+		> = {
+			serviceName: 'publisher' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => ({ id: '123', email: 'test@example.com' }),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(200);
+		expect(await response.json()).toEqual({
+			id: '123',
+			email: 'test@example.com',
+		});
+
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.created',
+				payload: { userId: '123', email: 'test@example.com' },
+			},
+		]);
+	});
+
+	it('should publish multiple events after successful endpoint execution', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+			serviceName: Math.random().toString(),
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+			{
+				type: 'notification.sent',
+				payload: (response) => ({ userId: response.id, type: 'welcome' }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => ({ id: '456', email: 'user@example.com' }),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 201,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(201);
+		expect(await response.json()).toEqual({
+			id: '456',
+			email: 'user@example.com',
+		});
+
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.created',
+				payload: { userId: '456', email: 'user@example.com' },
+			},
+			{
+				type: 'notification.sent',
+				payload: { userId: '456', type: 'welcome' },
+			},
+		]);
+	});
+
+	it('should respect when conditions for events', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+			serviceName: Math.random().toString(),
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({
+			id: z.string(),
+			email: z.string(),
+			isNew: z.boolean(),
+		});
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+				when: (response) => response.isNew === true,
+			},
+			{
+				type: 'user.updated',
+				payload: (response) => ({ userId: response.id, changes: ['email'] }),
+				when: (response) => response.isNew === false,
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users/:id',
+			method: 'PUT',
+			fn: async () => ({
+				id: '789',
+				email: 'updated@example.com',
+				isNew: false,
+			}),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users/789', {
+			method: 'PUT',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(200);
+		expect(await response.json()).toEqual({
+			id: '789',
+			email: 'updated@example.com',
+			isNew: false,
+		});
+
+		// Only user.updated event should be published due to when condition
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.updated',
+				payload: { userId: '789', changes: ['email'] },
+			},
+		]);
+	});
+
+	it('should not publish events when no publisher is configured', async () => {
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => ({ id: '999', email: 'test@example.com' }),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: undefined, // No publisher service
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(200);
+		expect(await response.json()).toEqual({
+			id: '999',
+			email: 'test@example.com',
+		});
+
+		// No publisher calls should be made
+		expect(mockLogger.warn).toHaveBeenCalledWith(
+			'No publisher service available',
+		);
+	});
+
+	it('should not publish events when no events are configured', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<
+			'publisher',
+			EventPublisher<TestEvent>
+		> = {
+			serviceName: 'publisher' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => ({ id: '111', email: 'test@example.com' }),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events: undefined, // No events
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(200);
+		expect(await response.json()).toEqual({
+			id: '111',
+			email: 'test@example.com',
+		});
+
+		// No events should be published - with optimization, event processing is skipped entirely
+		// for endpoints without events configured, so no log message is emitted
+		expect(mockPublisher.publish).not.toHaveBeenCalled();
+	});
+
+	it('should continue processing even when event publishing fails', async () => {
+		const publishError = new Error('Event bus connection failed');
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockRejectedValue(publishError),
+		};
+
+		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+			serviceName: Math.random().toString(),
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => ({ id: '888', email: 'error@example.com' }),
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		// The endpoint should still succeed despite event publishing failure
+		expect(response.status).toBe(200);
+		expect(await response.json()).toEqual({
+			id: '888',
+			email: 'error@example.com',
+		});
+
+		expect(mockPublisher.publish).toHaveBeenCalled();
+		expect(mockLogger.error).toHaveBeenCalledWith(
+			publishError,
+			'Failed to publish events',
+		);
+	});
+
+	it('should publish events with input data context', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+			serviceName: Math.random().toString(),
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const bodySchema = z.object({ name: z.string(), email: z.string() });
+		const outputSchema = z.object({
+			id: z.string(),
+			name: z.string(),
+			email: z.string(),
+		});
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async ({ body }) => ({
+				id: '777',
+				name: body.name,
+				email: body.email,
+			}),
+			input: { body: bodySchema },
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 201,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({ name: 'John Doe', email: 'john@example.com' }),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		expect(response.status).toBe(201);
+		expect(await response.json()).toEqual({
+			id: '777',
+			name: 'John Doe',
+			email: 'john@example.com',
+		});
+
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.created',
+				payload: { userId: '777', email: 'john@example.com' },
+			},
+		]);
+	});
+
+	it('should not publish events when endpoint throws an error', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const mockPublisherService: Service<
+			'publisher',
+			EventPublisher<TestEvent>
+		> = {
+			serviceName: 'publisher' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+		const events: MappedEvent<
+			EventPublisher<TestEvent>,
+			typeof outputSchema
+		>[] = [
+			{
+				type: 'user.created',
+				payload: (response) => ({ userId: response.id, email: response.email }),
+			},
+		];
+
+		const endpoint = new Endpoint({
+			route: '/users',
+			method: 'POST',
+			fn: async () => {
+				throw new Error('Something went wrong');
+			},
+			input: undefined,
+			output: outputSchema,
+			services: [],
+			logger: mockLogger,
+			timeout: undefined,
+			memorySize: undefined,
+			status: 200,
+			getSession: undefined,
+			authorize: undefined,
+			description: undefined,
+			events,
+			publisherService: mockPublisherService,
+		});
+
+		const adaptor = new HonoEndpoint(endpoint);
+		const app = new Hono();
+		HonoEndpoint.applyEventMiddleware(app, serviceDiscovery);
+
+		adaptor.addRoute(serviceDiscovery, app);
+
+		const response = await app.request('/users', {
+			method: 'POST',
+			body: JSON.stringify({}),
+			headers: { 'Content-Type': 'application/json' },
+		});
+
+		// Should return 500 due to error
+		expect(response.status).toBe(500);
+
+		// No events should be published when endpoint throws an error
+		expect(mockPublisher.publish).not.toHaveBeenCalled();
+	});
 });