@bgord/bun 1.13.0 → 1.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -20,9 +20,9 @@
     "preinstall": "bunx only-allow bun"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.6",
-    "@commitlint/cli": "20.4.4",
-    "@commitlint/config-conventional": "20.4.4",
+    "@biomejs/biome": "2.4.7",
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
     "@stryker-mutator/core": "9.6.0",
     "@types/bun": "1.3.10",
     "@types/nodemailer": "7.0.11",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@bgord/tools": "1.3.24",
     "emittery": "2.0.0",
-    "hono": "4.12.7",
+    "hono": "4.12.8",
     "node-cache": "5.1.2"
   },
   "peerDependencies": {

package/readme.md

@@ -96,7 +96,6 @@ src/
 ├── disk-space-checker-noop.adapter.ts
 ├── disk-space-checker-shell.adapter.ts
 ├── disk-space-checker.port.ts
-├── dispatching-event-store.ts
 ├── dynamic-import.service.ts
 ├── encryption-aes-gcm.adapter.ts
 ├── encryption-iv.vo.ts
@@ -113,15 +112,25 @@ src/
 ├── etag-extractor-hono.middleware.ts
 ├── etag-extractor.middleware.ts
 ├── event-envelope.ts
-├── event-handler-bare.strategy.ts
-├── event-handler-noop.strategy.ts
-├── event-handler-with-logger.strategy.ts
-├── event-handler.strategy.ts
+├── event-finder-noop.adapter.ts
+├── event-finder.port.ts
+├── event-inserter-noop.adapter.ts
+├── event-inserter.port.ts
 ├── event-loop-lag.service.ts
 ├── event-loop-utilization.service.ts
-├── event-store-like.types.ts
-├── event-store.ts
+├── event-revision-assigner.adapter.ts
+├── event-revision-assigner.port.ts
+├── event-serializer-collecting.adapter.ts
+├── event-serializer-json.adapter.ts
+├── event-serializer.port.ts
+├── event-store-collecting.adapter.ts
+├── event-store-dispatching.adapter.ts
+├── event-store-noop.adapter.ts
+├── event-store.adapter.ts
+├── event-store.port.ts
 ├── event-stream.vo.ts
+├── event-validator-registry-zod.adapter.ts
+├── event-validator-registry.port.ts
 ├── event.types.ts
 ├── file-cleaner-forgiving.adapter.ts
 ├── file-cleaner-noop.adapter.ts
@@ -250,6 +259,10 @@ src/
 ├── message-bus-noop.adapter.ts
 ├── message-bus-with-logger.adapter.ts
 ├── message-bus.port.ts
+├── message-handler-bare.strategy.ts
+├── message-handler-noop.strategy.ts
+├── message-handler-with-logger.strategy.ts
+├── message-handler.strategy.ts
 ├── message.types.ts
 ├── middleware-hono-noop.adapter.ts
 ├── middleware-hono.port.ts

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

@@ -0,0 +1,14 @@
+import type { GenericEvent, GenericEventSerialized } from "./event.types";
+import type { EventFinderPort } from "./event-finder.port";
+import type { EventStreamType } from "./event-stream.vo";
+
+export class EventFinderNoopAdapter implements EventFinderPort {
+  constructor(private readonly events: ReadonlyArray<GenericEventSerialized>) {}
+
+  async find(
+    _stream: EventStreamType,
+    _names: ReadonlyArray<GenericEvent["name"]>,
+  ): Promise<ReadonlyArray<GenericEventSerialized>> {
+    return this.events;
+  }
+}

package/src/event-finder.port.ts

@@ -0,0 +1,9 @@
+import type { GenericEvent, GenericEventSerialized } from "./event.types";
+import type { EventStreamType } from "./event-stream.vo";
+
+export interface EventFinderPort {
+  find(
+    stream: EventStreamType,
+    names: ReadonlyArray<GenericEvent["name"]>,
+  ): Promise<ReadonlyArray<GenericEventSerialized>>;
+}

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

@@ -0,0 +1,10 @@
+import type { GenericEventSerialized } from "./event.types";
+import type { EventInserterPort } from "./event-inserter.port";
+
+export class EventInserterNoopAdapter implements EventInserterPort {
+  async insert(
+    events: ReadonlyArray<GenericEventSerialized>,
+  ): Promise<ReadonlyArray<GenericEventSerialized>> {
+    return events;
+  }
+}

package/src/event-inserter.port.ts

@@ -0,0 +1,5 @@
+import type { GenericEventSerialized } from "./event.types";
+
+export interface EventInserterPort {
+  insert(events: ReadonlyArray<GenericEventSerialized>): Promise<ReadonlyArray<GenericEventSerialized>>;
+}

package/src/event-revision-assigner.adapter.ts

@@ -0,0 +1,13 @@
+import type { GenericEventSerialized } from "./event.types";
+import type { EventRevisionAssignerPort } from "./event-revision-assigner.port";
+
+export class EventRevisionAssignerAdapter implements EventRevisionAssignerPort {
+  static readonly EMPTY_STREAM_REVISION = -1;
+
+  assign(
+    events: ReadonlyArray<GenericEventSerialized>,
+    currentMax: number,
+  ): ReadonlyArray<GenericEventSerialized> {
+    return events.map((event, index) => ({ ...event, revision: currentMax + index + 1 }));
+  }
+}

package/src/event-revision-assigner.port.ts

@@ -0,0 +1,8 @@
+import type { GenericEventSerialized } from "./event.types";
+
+export interface EventRevisionAssignerPort {
+  assign(
+    events: ReadonlyArray<GenericEventSerialized>,
+    currentMax: number,
+  ): ReadonlyArray<GenericEventSerialized>;
+}

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

@@ -0,0 +1,19 @@
+import type { EventSerializerPort } from "./event-serializer.port";
+
+export class EventSerializerCollectingAdapter implements EventSerializerPort {
+  readonly serialized: Array<unknown> = [];
+
+  readonly deserialized: Array<string> = [];
+
+  serialize(payload: unknown): string {
+    this.serialized.push(payload);
+
+    return JSON.stringify(payload);
+  }
+
+  deserialize(raw: string): unknown {
+    this.deserialized.push(raw);
+
+    return JSON.parse(raw);
+  }
+}

package/src/event-serializer-json.adapter.ts

@@ -0,0 +1,11 @@
+import type { EventSerializerPort } from "./event-serializer.port";
+
+export class EventSerializerJsonAdapter implements EventSerializerPort {
+  serialize(payload: unknown): string {
+    return JSON.stringify(payload);
+  }
+
+  deserialize(raw: string): unknown {
+    return JSON.parse(raw);
+  }
+}

package/src/event-serializer.port.ts

@@ -0,0 +1,4 @@
+export interface EventSerializerPort {
+  serialize(payload: unknown): string;
+  deserialize(raw: string): unknown;
+}

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

@@ -0,0 +1,21 @@
+import type { GenericEvent } from "./event.types";
+import type { EventStorePort } from "./event-store.port";
+import type { EventStreamType } from "./event-stream.vo";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+
+export class EventStoreCollectingAdapter<TEvent extends GenericEvent> implements EventStorePort<TEvent> {
+  readonly saved: Array<TEvent> = [];
+
+  async find<FoundEvent extends TEvent>(
+    _registry: EventValidatorRegistryPort<FoundEvent>,
+    _stream: EventStreamType,
+  ): Promise<ReadonlyArray<FoundEvent>> {
+    return [];
+  }
+
+  async save(events: ReadonlyArray<TEvent>): Promise<ReadonlyArray<TEvent>> {
+    this.saved.push(...events);
+
+    return [...events];
+  }
+}

package/src/event-store-dispatching.adapter.ts

@@ -0,0 +1,29 @@
+import type { GenericEvent } from "./event.types";
+import type { EventStorePort } from "./event-store.port";
+import type { EventStreamType } from "./event-stream.vo";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+import type { EventBusPort } from "./message-bus.port";
+
+type Dependencies<TEvent extends GenericEvent> = {
+  inner: EventStorePort<TEvent>;
+  EventBus: EventBusPort<TEvent>;
+};
+
+export class EventStoreDispatchingAdapter<Event extends GenericEvent> implements EventStorePort<Event> {
+  constructor(private readonly deps: Dependencies<Event>) {}
+
+  async find<FoundEvent extends Event>(
+    registry: EventValidatorRegistryPort<FoundEvent>,
+    stream: EventStreamType,
+  ): Promise<ReadonlyArray<FoundEvent>> {
+    return this.deps.inner.find(registry, stream);
+  }
+
+  async save(events: ReadonlyArray<Event>): Promise<ReadonlyArray<Event>> {
+    const saved = await this.deps.inner.save(events);
+
+    await Promise.all(saved.map((event) => this.deps.EventBus.emit(event)));
+
+    return saved;
+  }
+}

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

@@ -0,0 +1,17 @@
+import type { GenericEvent } from "./event.types";
+import type { EventStorePort } from "./event-store.port";
+import type { EventStreamType } from "./event-stream.vo";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+
+export class EventStoreNoopAdapter<Event extends GenericEvent> implements EventStorePort<Event> {
+  async find<FoundEvent extends Event>(
+    _registry: EventValidatorRegistryPort<FoundEvent>,
+    _stream: EventStreamType,
+  ): Promise<ReadonlyArray<FoundEvent>> {
+    return [];
+  }
+
+  async save(_events: ReadonlyArray<Event>): Promise<ReadonlyArray<Event>> {
+    return [];
+  }
+}

package/src/event-store.adapter.ts

@@ -0,0 +1,49 @@
+import type { GenericEvent } from "./event.types";
+import type { EventFinderPort } from "./event-finder.port";
+import type { EventInserterPort } from "./event-inserter.port";
+import type { EventSerializerPort } from "./event-serializer.port";
+import type { EventStorePort } from "./event-store.port";
+import type { EventStreamType } from "./event-stream.vo";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+
+type Config = {
+  finder: EventFinderPort;
+  inserter: EventInserterPort;
+  serializer: EventSerializerPort;
+};
+
+const EventStoreAdapterError = { UniqueStream: "event.store.adapter.error.unique.stream" };
+
+export class EventStoreAdapter<Event extends GenericEvent> implements EventStorePort<Event> {
+  constructor(private readonly config: Config) {}
+
+  async find<FoundEvent extends Event>(
+    registry: EventValidatorRegistryPort<FoundEvent>,
+    stream: EventStreamType,
+  ): Promise<ReadonlyArray<FoundEvent>> {
+    const events = await this.config.finder.find(stream, registry.names);
+
+    return events
+      .map((event) => ({ ...event, payload: this.config.serializer.deserialize(event.payload) }))
+      .map((event) => registry.validate(event));
+  }
+
+  async save(events: ReadonlyArray<Event>): Promise<ReadonlyArray<Event>> {
+    if (!events[0]) return [];
+
+    const stream = events[0].stream;
+
+    if (!events.every((event) => event.stream === stream)) {
+      throw new Error(EventStoreAdapterError.UniqueStream);
+    }
+
+    const serialized = await this.config.inserter.insert(
+      events.map((event) => ({ ...event, payload: this.config.serializer.serialize(event.payload) })),
+    );
+
+    return serialized.map((event) => ({
+      ...event,
+      payload: this.config.serializer.deserialize(event.payload),
+    })) as Array<Event>;
+  }
+}

package/src/event-store.port.ts

@@ -0,0 +1,12 @@
+import type { GenericEvent } from "./event.types";
+import type { EventStreamType } from "./event-stream.vo";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+
+export interface EventStorePort<Event extends GenericEvent> {
+  find<FoundEvent extends Event>(
+    registry: EventValidatorRegistryPort<FoundEvent>,
+    stream: EventStreamType,
+  ): Promise<ReadonlyArray<FoundEvent>>;
+
+  save(events: ReadonlyArray<Event>): Promise<ReadonlyArray<Event>>;
+}

package/src/event-validator-registry-zod.adapter.ts

@@ -0,0 +1,47 @@
+import type * as z from "zod/v4";
+import type { GenericEvent } from "./event.types";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+
+export type GenericEventSchema = z.ZodObject<{
+  id: z.ZodType<string>;
+  correlationId: z.ZodType<string>;
+  createdAt: z.ZodType<number>;
+  stream: z.ZodString;
+  revision: z.ZodOptional<z.ZodType<number>>;
+  name: z.ZodLiteral<string>;
+  version: z.ZodLiteral<number>;
+  payload: z.ZodType<any>;
+}>;
+
+export type GenericParsedEventSchema = z.ZodObject<
+  Omit<GenericEventSchema["shape"], "payload"> & { payload: z.ZodString }
+>;
+
+const EventValidatorRegistryZodAdapterError = {
+  MissingName: "event.validator.registry.zod.adapter.error.missing.name",
+  UnknownEvent: "event.validator.registry.zod.adapter.error.unknown.event",
+};
+
+export class EventValidatorRegistryZodAdapter<TEvent> implements EventValidatorRegistryPort<TEvent> {
+  private readonly map: Map<GenericEvent["name"], GenericEventSchema>;
+  readonly names: ReadonlyArray<GenericEvent["name"]>;
+
+  constructor(schemas: ReadonlyArray<GenericEventSchema>) {
+    this.map = new Map(schemas.map((schema) => [schema.shape.name.value, schema]));
+    this.names = [...this.map.keys()];
+  }
+
+  accepts(name: GenericEvent["name"]): boolean {
+    return this.map.has(name);
+  }
+
+  validate(raw: unknown): TEvent {
+    const name = (raw as { name?: GenericEvent["name"] }).name;
+    if (!name) throw new Error(EventValidatorRegistryZodAdapterError.MissingName);
+
+    const schema = this.map.get(name);
+    if (!schema) throw new Error(EventValidatorRegistryZodAdapterError.UnknownEvent);
+
+    return schema.parse(raw) as TEvent;
+  }
+}

package/src/event-validator-registry.port.ts

@@ -0,0 +1,7 @@
+import type { GenericEvent } from "./event.types";
+
+export interface EventValidatorRegistryPort<TEvent> {
+  readonly names: ReadonlyArray<GenericEvent["name"]>;
+  accepts(name: GenericEvent["name"]): boolean;
+  validate(raw: unknown): TEvent;
+}

package/src/event.types.ts

@@ -1,16 +1,13 @@
-import type * as z from "zod/v4";
+// TODO: use proper VO types.
+export type GenericEvent = {
+  id: string;
+  correlationId: string;
+  createdAt: number;
+  stream: string;
+  revision?: number;
+  name: string;
+  version: number;
+  payload: unknown;
+};
 
-export type GenericEventSchema = z.ZodObject<{
-  id: z.ZodType<string>;
-  correlationId: z.ZodType<string>;
-  createdAt: z.ZodType<number>;
-  stream: z.ZodString;
-  revision: z.ZodOptional<z.ZodType<number>>;
-  name: z.ZodLiteral<string>;
-  version: z.ZodLiteral<number>;
-  payload: z.ZodType<any>;
-}>;
-
-export type GenericParsedEventSchema = z.ZodObject<
-  Omit<GenericEventSchema["shape"], "payload"> & { payload: z.ZodString }
->;
+export type GenericEventSerialized = Omit<GenericEvent, "payload"> & { payload: string };

package/src/index.ts

@@ -68,7 +68,6 @@ export * from "./directory-ensurer-noop.adapter";
 export * from "./disk-space-checker.port";
 export * from "./disk-space-checker-noop.adapter";
 export * from "./disk-space-checker-shell.adapter";
-export * from "./dispatching-event-store";
 export * from "./dynamic-import.service";
 export * from "./encryption.port";
 export * from "./encryption-aes-gcm.adapter";
@@ -85,15 +84,26 @@ export * from "./etag-extractor.middleware";
 export * from "./etag-extractor-hono.middleware";
 export * from "./event.types";
 export * from "./event-envelope";
-export * from "./event-handler.strategy";
-export * from "./event-handler-bare.strategy";
-export * from "./event-handler-noop.strategy";
-export * from "./event-handler-with-logger.strategy";
+export * from "./event-finder.port";
+export * from "./event-finder-noop.adapter";
+export * from "./event-inserter.port";
+export * from "./event-inserter-noop.adapter";
 export * from "./event-loop-lag.service";
 export * from "./event-loop-utilization.service";
-export * from "./event-store";
-export * from "./event-store-like.types";
+export * from "./event-revision-assigner.adapter";
+export * from "./event-revision-assigner.port";
+export * from "./event-serializer.port";
+export * from "./event-serializer-collecting.adapter";
+export * from "./event-serializer-json.adapter";
+export * from "./event-store.adapter";
+export * from "./event-store.port";
+export * from "./event-store-collecting.adapter";
+export * from "./event-store-collecting.adapter";
+export * from "./event-store-dispatching.adapter";
+export * from "./event-store-noop.adapter";
 export * from "./event-stream.vo";
+export * from "./event-validator-registry.port";
+export * from "./event-validator-registry-zod.adapter";
 export * from "./file-cleaner.adapter";
 export * from "./file-cleaner.port";
 export * from "./file-cleaner-forgiving.adapter";
@@ -221,6 +231,10 @@ export * from "./message-bus-collecting.adapter";
 export * from "./message-bus-emittery.adapter";
 export * from "./message-bus-noop.adapter";
 export * from "./message-bus-with-logger.adapter";
+export * from "./message-handler.strategy";
+export * from "./message-handler-bare.strategy";
+export * from "./message-handler-noop.strategy";
+export * from "./message-handler-with-logger.strategy";
 export * from "./middleware-hono.port";
 export * from "./middleware-hono-noop.adapter";
 export * as History from "./modules/history";

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

@@ -0,0 +1,11 @@
+import type { Message } from "./message.types";
+import type { MessageHandlerStrategy } from "./message-handler.strategy";
+
+export class MessageHandlerBareStrategy implements MessageHandlerStrategy {
+  handle<M extends Message>(handler: (message: M) => Promise<void>) {
+    return async (message: M) => handler(message);
+  }
+}
+
+export const EventHandlerBareStrategy = MessageHandlerBareStrategy;
+export const CommandHandlerBareStrategy = MessageHandlerBareStrategy;

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

@@ -0,0 +1,11 @@
+import type { Message } from "./message.types";
+import type { MessageHandlerStrategy } from "./message-handler.strategy";
+
+export class MessageHandlerNoopStrategy implements MessageHandlerStrategy {
+  handle<M extends Message>(_handler: (message: M) => Promise<void>) {
+    return async (_message: M) => {};
+  }
+}
+
+export const EventHandlerNoopStrategy = MessageHandlerNoopStrategy;
+export const CommandHandlerNoopStrategy = MessageHandlerNoopStrategy;

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

@@ -0,0 +1,32 @@
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import type { Message } from "./message.types";
+import type { MessageHandlerStrategy } from "./message-handler.strategy";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+export class MessageHandlerWithLoggerStrategy implements MessageHandlerStrategy {
+  constructor(private readonly deps: Dependencies) {}
+
+  handle<M extends Message>(handler: (message: M) => Promise<void>) {
+    return async (message: M) => {
+      const duration = new Stopwatch(this.deps);
+
+      try {
+        await handler(message);
+      } catch (error) {
+        this.deps.Logger.error({
+          message: `Unknown ${message.name} message handler error`,
+          component: "infra",
+          operation: "message_handler",
+          metadata: { name: message.name, duration: duration.stop() },
+          error,
+        });
+      }
+    };
+  }
+}
+
+export const EventHandlerWithLoggerStrategy = MessageHandlerWithLoggerStrategy;
+export const CommandHandlerWithLoggerStrategy = MessageHandlerWithLoggerStrategy;

package/src/message-handler.strategy.ts

@@ -0,0 +1,8 @@
+import type { Message } from "./message.types";
+
+export interface MessageHandlerStrategy {
+  handle<M extends Message>(handler: (message: M) => Promise<void>): (message: M) => Promise<void>;
+}
+
+export type EventHandlerStrategy = MessageHandlerStrategy;
+export type CommandHandlerStrategy = MessageHandlerStrategy;

package/src/modules/preferences/command-handlers/handleSetUserLanguageCommand.ts

@@ -1,7 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
-import type { EventStoreLike } from "../../../event-store-like.types";
+import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { Languages } from "../../../languages.vo";
 import type * as Commands from "../commands";
@@ -14,7 +14,7 @@ export const HandleSetUserLanguageCommandError = {
 };
 
 type Dependencies = {
-  EventStore: EventStoreLike<AcceptedEvent>;
+  EventStore: EventStorePort<AcceptedEvent>;
   IdProvider: IdProviderPort;
   Clock: ClockPort;
   UserLanguageQuery: Ports.UserLanguageQueryPort;

package/src/modules/system/services/passage-of-time-hourly.service.ts

@@ -1,6 +1,6 @@
 import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
-import type { EventStoreLike } from "../../../event-store-like.types";
+import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
@@ -11,7 +11,7 @@ import {
 } from "../events/HOUR_HAS_PASSED_EVENT";
 
 type Dependencies = {
-  EventStore: EventStoreLike<HourHasPassedEventType>;
+  EventStore: EventStorePort<HourHasPassedEventType>;
   Clock: ClockPort;
   IdProvider: IdProviderPort;
 };

package/src/modules/system/services/passage-of-time-minute.service.ts

@@ -1,6 +1,6 @@
 import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
-import type { EventStoreLike } from "../../../event-store-like.types";
+import type { EventStorePort } from "../../../event-store.port";
 import type { IdProviderPort } from "../../../id-provider.port";
 import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
@@ -11,7 +11,7 @@ import {
 } from "../events/MINUTE_HAS_PASSED_EVENT";
 
 type Dependencies = {
-  EventStore: EventStoreLike<MinuteHasPassedEventType>;
+  EventStore: EventStorePort<MinuteHasPassedEventType>;
   Clock: ClockPort;
   IdProvider: IdProviderPort;
 };

package/src/security-countermeasure-ban.strategy.ts

@@ -1,7 +1,7 @@
 import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import { createEventEnvelope } from "./event-envelope";
-import type { EventStoreLike } from "./event-store-like.types";
+import type { EventStorePort } from "./event-store.port";
 import type { IdProviderPort } from "./id-provider.port";
 import type { LoggerPort } from "./logger.port";
 import {
@@ -24,7 +24,7 @@ type Dependencies = {
   IdProvider: IdProviderPort;
   Clock: ClockPort;
   Logger: LoggerPort;
-  EventStore: EventStoreLike<SecurityViolationDetectedEventType>;
+  EventStore: EventStorePort<SecurityViolationDetectedEventType>;
 };
 
 type Config = { response: { status: number } };

package/src/sse-hono.handler.ts

@@ -44,7 +44,7 @@ export class SseHonoHandler<Messages extends Message> implements HandlerHonoPort
 
         while (!stream.closed) {
           await stream.sleep(this.config.keepalive.ms);
-          await stream.writeSSE({ event: "ping", data: "" });
+          await stream.writeSSE({ event: "ping", data: JSON.stringify({ keepalive: true }) });
         }
       });
     });

package/dist/dispatching-event-store.d.ts

@@ -1,15 +0,0 @@
-import type * as z from "zod/v4";
-import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types";
-import { EventStore as BaseStore } from "./event-store";
-import type { EventStreamType } from "./event-stream.vo";
-import type { EventBusPort } from "./message-bus.port";
-export declare class DispatchingEventStore<AllEvents extends GenericEventSchema> extends BaseStore<AllEvents> {
-    private readonly publisher;
-    static EMPTY_STREAM_REVISION: number;
-    constructor(config: {
-        finder: (stream: EventStreamType, names: ReadonlyArray<string>) => Promise<ReadonlyArray<z.infer<GenericEventSchema>>>;
-        inserter: (events: ReadonlyArray<z.infer<GenericParsedEventSchema>>) => Promise<ReadonlyArray<z.infer<GenericParsedEventSchema>>>;
-    }, publisher: EventBusPort<z.infer<AllEvents>>);
-    save(_events: ReadonlyArray<z.infer<AllEvents>>): Promise<ReadonlyArray<z.infer<AllEvents>>>;
-}
-//# sourceMappingURL=dispatching-event-store.d.ts.map

package/dist/dispatching-event-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dispatching-event-store.d.ts","sourceRoot":"","sources":["../src/dispatching-event-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,qBAAa,qBAAqB,CAAC,SAAS,SAAS,kBAAkB,CAAE,SAAQ,SAAS,CAAC,SAAS,CAAC;IAajG,OAAO,CAAC,QAAQ,CAAC,SAAS;IAZ5B,MAAM,CAAC,qBAAqB,SAAM;gBAGhC,MAAM,EAAE;QACN,MAAM,EAAE,CACN,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KACzB,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QACzD,QAAQ,EAAE,CACR,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,KACrD,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;KAChE,EACgB,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAKxD,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;CAOnG"}