@bgord/bun 1.12.0 → 1.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.12.0",
+  "version": "1.12.1",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",

package/readme.md

@@ -247,6 +247,7 @@ src/
 ├── markdown-generator.adapter.ts
 ├── markdown-generator.port.ts
 ├── memory-consumption.service.ts
+├── message.types.ts
 ├── middleware-hono-noop.adapter.ts
 ├── middleware-hono.port.ts
 ├── modules
@@ -450,7 +451,6 @@ src/
 ├── timeout-runner.port.ts
 ├── timing-hono.middleware.ts
 ├── timing.middleware.ts
-├── to-event-map.types.ts
 ├── trailing-slash-hono.middleware.ts
 ├── trailing-slash.middleware.ts
 ├── translations-hono.handler.ts

package/src/command-bus-collecting.adapter.ts

@@ -1,15 +1,18 @@
 import type { CommandBusPort } from "./command-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class CommandBusCollectingAdapter<C extends { name: string }> implements CommandBusPort<C> {
-  public commands: Array<C> = [];
+export class CommandBusCollectingAdapter<Command extends Message> implements CommandBusPort<Command> {
+  public commands: Array<Command> = [];
 
-  async emit<K extends keyof ToEventMap<C>>(_name: K, command: ToEventMap<C>[K]): Promise<void> {
-    this.commands.push(command as C);
+  async emit<CommandName extends keyof ToMessageMap<Command>>(
+    _name: CommandName,
+    command: ToMessageMap<Command>[CommandName],
+  ): Promise<void> {
+    this.commands.push(command as Command);
   }
 
-  on<K extends keyof ToEventMap<C>>(
-    _name: K,
-    _handler: (command: ToEventMap<C>[K]) => void | Promise<void>,
+  on<CommandName extends keyof ToMessageMap<Command>>(
+    _name: CommandName,
+    _handler: (command: ToMessageMap<Command>[CommandName]) => void | Promise<void>,
   ): void {}
 }

package/src/command-bus-emittery-v1.adapter.ts

@@ -1,21 +1,24 @@
 import Emittery from "emittery";
 import type { CommandBusPort } from "./command-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class CommandBusEmitteryV1Adapter<C extends { name: string }> implements CommandBusPort<C> {
-  private readonly emittery: Emittery<ToEventMap<C>>;
+export class CommandBusEmitteryV1Adapter<Command extends Message> implements CommandBusPort<Command> {
+  private readonly emittery: Emittery<ToMessageMap<Command>>;
 
   constructor() {
-    this.emittery = new Emittery<ToEventMap<C>>();
+    this.emittery = new Emittery<ToMessageMap<Command>>();
   }
 
-  async emit<K extends keyof ToEventMap<C>>(name: K, command: ToEventMap<C>[K]): Promise<void> {
+  async emit<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    command: ToMessageMap<Command>[CommandName],
+  ): Promise<void> {
     await this.emittery.emit(name, command);
   }
 
-  on<K extends keyof ToEventMap<C>>(
-    name: K,
-    handler: (command: ToEventMap<C>[K]) => void | Promise<void>,
+  on<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    handler: (command: ToMessageMap<Command>[CommandName]) => void | Promise<void>,
   ): void {
     this.emittery.on(name, handler);
   }

package/src/command-bus-noop.adapter.ts

@@ -1,11 +1,14 @@
 import type { CommandBusPort } from "./command-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class CommandBusNoopAdapter<C extends { name: string }> implements CommandBusPort<C> {
-  async emit<K extends keyof ToEventMap<C>>(_name: K, _command: ToEventMap<C>[K]): Promise<void> {}
+export class CommandBusNoopAdapter<Command extends Message> implements CommandBusPort<Command> {
+  async emit<CommandName extends keyof ToMessageMap<Command>>(
+    _name: CommandName,
+    _command: ToMessageMap<Command>[CommandName],
+  ): Promise<void> {}
 
-  on<K extends keyof ToEventMap<C>>(
-    _name: K,
-    _handler: (command: ToEventMap<C>[K]) => void | Promise<void>,
+  on<CommandName extends keyof ToMessageMap<Command>>(
+    _name: CommandName,
+    _handler: (command: ToMessageMap<Command>[CommandName]) => void | Promise<void>,
   ): void {}
 }

package/src/command-bus-with-logger.adapter.ts

@@ -1,18 +1,21 @@
 import type { CommandBusPort } from "./command-bus.port";
 import type { LogCoreType, LoggerPort } from "./logger.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
 type Dependencies = { Logger: LoggerPort };
 
-export class CommandBusWithLoggerAdapter<C extends { name: string }> implements CommandBusPort<C> {
+export class CommandBusWithLoggerAdapter<Command extends Message> implements CommandBusPort<Command> {
   private readonly base = { component: "infra", operation: "command_emitted" };
 
   constructor(
-    private readonly inner: CommandBusPort<C>,
+    private readonly inner: CommandBusPort<Command>,
     private readonly deps: Dependencies,
   ) {}
 
-  async emit<K extends keyof ToEventMap<C>>(name: K, command: ToEventMap<C>[K]): Promise<void> {
+  async emit<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    command: ToMessageMap<Command>[CommandName],
+  ): Promise<void> {
     this.deps.Logger.info({
       message: `${name.toString()} emitted`,
       metadata: command as LogCoreType["metadata"],
@@ -22,9 +25,9 @@ export class CommandBusWithLoggerAdapter<C extends { name: string }> implements
     return this.inner.emit(name, command);
   }
 
-  on<K extends keyof ToEventMap<C>>(
-    name: K,
-    handler: (command: ToEventMap<C>[K]) => void | Promise<void>,
+  on<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    handler: (command: ToMessageMap<Command>[CommandName]) => void | Promise<void>,
   ): void {
     this.inner.on(name, handler);
   }

package/src/command-bus.port.ts

@@ -1,10 +1,13 @@
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export interface CommandBusPort<C extends { name: string }> {
-  emit<K extends keyof ToEventMap<C>>(name: K, command: ToEventMap<C>[K]): Promise<void>;
+export interface CommandBusPort<Command extends Message> {
+  emit<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    command: ToMessageMap<Command>[CommandName],
+  ): Promise<void>;
 
-  on<K extends keyof ToEventMap<C>>(
-    name: K,
-    handler: (command: ToEventMap<C>[K]) => void | Promise<void>,
+  on<CommandName extends keyof ToMessageMap<Command>>(
+    name: CommandName,
+    handler: (command: ToMessageMap<Command>[CommandName]) => void | Promise<void>,
   ): void;
 }

package/src/dispatching-event-store.ts

@@ -4,7 +4,7 @@ import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types
 import type { EventBusPort } from "./event-bus.port";
 import { EventStore as BaseStore } from "./event-store";
 import type { EventStreamType } from "./event-stream.vo";
-import type { ToEventMap } from "./to-event-map.types";
+import type { ToMessageMap } from "./message.types";
 
 export class DispatchingEventStore<AllEvents extends GenericEventSchema> extends BaseStore<AllEvents> {
   static EMPTY_STREAM_REVISION = -1;
@@ -31,7 +31,7 @@ export class DispatchingEventStore<AllEvents extends GenericEventSchema> extends
 
     await Promise.all(
       events.map((event) =>
-        this.publisher.emit(event.name as keyof ToEventMap<z.infer<AllEvents>>, event as any),
+        this.publisher.emit(event.name as keyof ToMessageMap<z.infer<AllEvents>>, event as any),
       ),
     );
 

package/src/event-bus-collecting.adapter.ts

@@ -1,15 +1,18 @@
 import type { EventBusPort } from "./event-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class EventBusCollectingAdapter<E extends { name: string }> implements EventBusPort<E> {
-  public events: Array<E> = [];
+export class EventBusCollectingAdapter<Event extends Message> implements EventBusPort<Event> {
+  public events: Array<Event> = [];
 
-  async emit<K extends keyof ToEventMap<E>>(_name: K, event: ToEventMap<E>[K]): Promise<void> {
-    this.events.push(event as E);
+  async emit<EventName extends keyof ToMessageMap<Event>>(
+    _name: EventName,
+    event: ToMessageMap<Event>[EventName],
+  ): Promise<void> {
+    this.events.push(event as Event);
   }
 
-  on<K extends keyof ToEventMap<E>>(
-    _name: K,
-    _handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  on<EventName extends keyof ToMessageMap<Event>>(
+    _name: EventName,
+    _handler: (event: ToMessageMap<Event>[EventName]) => void | Promise<void>,
   ): void {}
 }

package/src/event-bus-emittery-v1.adapter.ts

@@ -1,21 +1,24 @@
 import Emittery from "emittery";
 import type { EventBusPort } from "./event-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class EventBusEmitteryV1Adapter<E extends { name: string }> implements EventBusPort<E> {
-  private readonly emittery: Emittery<ToEventMap<E>>;
+export class EventBusEmitteryV1Adapter<Event extends Message> implements EventBusPort<Event> {
+  private readonly emittery: Emittery<ToMessageMap<Event>>;
 
   constructor() {
-    this.emittery = new Emittery<ToEventMap<E>>();
+    this.emittery = new Emittery<ToMessageMap<Event>>();
   }
 
-  async emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void> {
+  async emit<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    event: ToMessageMap<Event>[EventName],
+  ): Promise<void> {
     await this.emittery.emit(name, event);
   }
 
-  on<K extends keyof ToEventMap<E>>(
-    name: K,
-    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  on<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    handler: (event: ToMessageMap<Event>[EventName]) => void | Promise<void>,
   ): void {
     this.emittery.on(name, handler);
   }

package/src/event-bus-noop.adapter.ts

@@ -1,11 +1,14 @@
 import type { EventBusPort } from "./event-bus.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export class EventBusNoopAdapter<E extends { name: string }> implements EventBusPort<E> {
-  async emit<K extends keyof ToEventMap<E>>(_name: K, _event: ToEventMap<E>[K]): Promise<void> {}
+export class EventBusNoopAdapter<Event extends Message> implements EventBusPort<Event> {
+  async emit<EventName extends keyof ToMessageMap<Event>>(
+    _name: EventName,
+    _event: ToMessageMap<Event>[EventName],
+  ): Promise<void> {}
 
-  on<K extends keyof ToEventMap<E>>(
-    _name: K,
-    _handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  on<EventName extends keyof ToMessageMap<Event>>(
+    _name: EventName,
+    _handler: (event: ToMessageMap<Event>[EventName]) => void | Promise<void>,
   ): void {}
 }

package/src/event-bus-with-logger.adapter.ts

@@ -1,18 +1,21 @@
 import type { EventBusPort } from "./event-bus.port";
 import type { LogCoreType, LoggerPort } from "./logger.port";
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
 type Dependencies = { Logger: LoggerPort };
 
-export class EventBusWithLoggerAdapter<E extends { name: string }> implements EventBusPort<E> {
+export class EventBusWithLoggerAdapter<Event extends Message> implements EventBusPort<Event> {
   private readonly base = { component: "infra", operation: "event_emitted" };
 
   constructor(
-    private readonly inner: EventBusPort<E>,
+    private readonly inner: EventBusPort<Event>,
     private readonly deps: Dependencies,
   ) {}
 
-  async emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void> {
+  async emit<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    event: ToMessageMap<Event>[EventName],
+  ): Promise<void> {
     this.deps.Logger.info({
       message: `${name.toString()} emitted`,
       metadata: event as LogCoreType["metadata"],
@@ -22,9 +25,9 @@ export class EventBusWithLoggerAdapter<E extends { name: string }> implements Ev
     return this.inner.emit(name, event);
   }
 
-  on<K extends keyof ToEventMap<E>>(
-    name: K,
-    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  on<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    handler: (event: ToMessageMap<Event>[EventName]) => void | Promise<void>,
   ): void {
     this.inner.on(name, handler);
   }

package/src/event-bus.port.ts

@@ -1,10 +1,13 @@
-import type { ToEventMap } from "./to-event-map.types";
+import type { Message, ToMessageMap } from "./message.types";
 
-export interface EventBusPort<E extends { name: string }> {
-  emit<K extends keyof ToEventMap<E>>(name: K, event: ToEventMap<E>[K]): Promise<void>;
+export interface EventBusPort<Event extends Message> {
+  emit<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    event: ToMessageMap<Event>[EventName],
+  ): Promise<void>;
 
-  on<K extends keyof ToEventMap<E>>(
-    name: K,
-    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  on<EventName extends keyof ToMessageMap<Event>>(
+    name: EventName,
+    handler: (event: ToMessageMap<Event>[EventName]) => void | Promise<void>,
   ): void;
 }

package/src/event-handler-bare.strategy.ts

@@ -1,9 +1,8 @@
-import type * as z from "zod/v4";
-import type { GenericEventSchema } from "./event.types";
 import type { EventHandlerStrategy } from "./event-handler.strategy";
+import type { Message } from "./message.types";
 
 export class EventHandlerBareStrategy implements EventHandlerStrategy {
-  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(fn: (event: T) => Promise<void>) {
-    return async (event: T) => fn(event);
+  handle<Event extends Message>(fn: (event: Event) => Promise<void>) {
+    return async (event: Event) => fn(event);
   }
 }

package/src/event-handler-noop.strategy.ts

@@ -1,9 +1,8 @@
-import type * as z from "zod/v4";
-import type { GenericEventSchema } from "./event.types";
 import type { EventHandlerStrategy } from "./event-handler.strategy";
+import type { Message } from "./message.types";
 
 export class EventHandlerNoopStrategy implements EventHandlerStrategy {
-  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(_fn: (event: T) => Promise<void>) {
-    return async (_event: T) => {};
+  handle<Event extends Message>(_handler: (event: Event) => Promise<void>) {
+    return async (_event: Event) => {};
   }
 }

package/src/event-handler-with-logger.strategy.ts

@@ -1,8 +1,7 @@
-import type * as z from "zod/v4";
 import type { ClockPort } from "./clock.port";
-import type { GenericEventSchema } from "./event.types";
 import type { EventHandlerStrategy } from "./event-handler.strategy";
 import type { LoggerPort } from "./logger.port";
+import type { Message } from "./message.types";
 import { Stopwatch } from "./stopwatch.service";
 
 type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
@@ -10,12 +9,12 @@ type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
 export class EventHandlerWithLoggerStrategy implements EventHandlerStrategy {
   constructor(private readonly deps: Dependencies) {}
 
-  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(fn: (event: T) => Promise<void>) {
-    return async (event: T) => {
+  handle<Event extends Message>(handler: (event: Event) => Promise<void>) {
+    return async (event: Event) => {
       const duration = new Stopwatch(this.deps);
 
       try {
-        await fn(event);
+        await handler(event);
       } catch (error) {
         this.deps.Logger.error({
           message: `Unknown ${event.name} event handler error`,

package/src/event-handler.strategy.ts

@@ -1,8 +1,5 @@
-import type * as z from "zod/v4";
-import type { GenericEventSchema } from "./event.types";
+import type { Message } from "./message.types";
 
 export interface EventHandlerStrategy {
-  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(
-    fn: (event: T) => Promise<void>,
-  ): (event: T) => Promise<void>;
+  handle<Event extends Message>(fn: (event: Event) => Promise<void>): (event: Event) => Promise<void>;
 }

package/src/event-store-like.types.ts

@@ -1,3 +1,5 @@
-export type EventStoreLike<E extends { name: string }> = {
-  save(events: ReadonlyArray<E>): Promise<unknown>;
+import type { Message } from "./message.types";
+
+export type EventStoreLike<Event extends Message> = {
+  save(events: ReadonlyArray<Event>): Promise<unknown>;
 };

package/src/index.ts

@@ -216,6 +216,7 @@ export * from "./markdown-generator.adapter";
 export * from "./markdown-generator.port";
 export * from "./markdown-generator-noop.adapter";
 export * from "./memory-consumption.service";
+export * from "./message.types";
 export * from "./middleware-hono.port";
 export * from "./middleware-hono-noop.adapter";
 export * as History from "./modules/history";
@@ -374,7 +375,6 @@ export * from "./timeout-runner-monitor.adapter";
 export * from "./timeout-runner-noop.adapter";
 export * from "./timing.middleware";
 export * from "./timing-hono.middleware";
-export * from "./to-event-map.types";
 export * from "./trailing-slash.middleware";
 export * from "./trailing-slash.middleware";
 export * from "./trailing-slash-hono.middleware";

package/src/message.types.ts

@@ -0,0 +1,5 @@
+export type Message = { name: string };
+
+export type ToMessageMap<Definition extends Message> = {
+  [M in Definition as M["name"]]: M;
+};

package/dist/to-event-map.types.d.ts

@@ -1,6 +0,0 @@
-export type ToEventMap<E extends {
-    name: string;
-}> = {
-    [Ev in E as Ev["name"]]: Ev;
-};
-//# sourceMappingURL=to-event-map.types.d.ts.map

package/dist/to-event-map.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"to-event-map.types.d.ts","sourceRoot":"","sources":["../src/to-event-map.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,IAAI;KAClD,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE;CAC5B,CAAC"}

package/dist/to-event-map.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=to-event-map.types.js.map

package/dist/to-event-map.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"to-event-map.types.js","sourceRoot":"","sources":["../src/to-event-map.types.ts"],"names":[],"mappings":""}

package/src/to-event-map.types.ts

@@ -1,3 +0,0 @@
-export type ToEventMap<E extends { name: string }> = {
-  [Ev in E as Ev["name"]]: Ev;
-};