@bgord/bun 1.12.11 → 1.14.0

package/dist/sse-connection-with-logger.adapter.js

@@ -1,27 +0,0 @@
-import { CorrelationStorage } from "./correlation-storage.service";
-export class SseConnectionWithLoggerAdapter {
-    deps;
-    base = { component: "infra", operation: "sse_connection" };
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async send(message) {
-        this.deps.Logger.debug({
-            message: `${message.name} sent`,
-            metadata: message,
-            correlationId: CorrelationStorage.get(),
-            ...this.base,
-        });
-        await this.deps.inner.send(message);
-    }
-    close(callback) {
-        this.deps.Logger.debug({
-            message: "SSE connection closed",
-            metadata: {},
-            correlationId: CorrelationStorage.get(),
-            ...this.base,
-        });
-        this.deps.inner.close(callback);
-    }
-}
-//# sourceMappingURL=sse-connection-with-logger.adapter.js.map

package/dist/sse-connection-with-logger.adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse-connection-with-logger.adapter.js","sourceRoot":"","sources":["../src/sse-connection-with-logger.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAOnE,MAAM,OAAO,8BAA8B;IAGZ;IAFZ,IAAI,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAE5E,YAA6B,IAA4B;QAA5B,SAAI,GAAJ,IAAI,CAAwB;IAAG,CAAC;IAE7D,KAAK,CAAC,IAAI,CAAqB,OAAU;QACvC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YACrB,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,OAAO;YAC/B,QAAQ,EAAE,OAAO;YACjB,aAAa,EAAE,kBAAkB,CAAC,GAAG,EAAE;YACvC,GAAG,IAAI,CAAC,IAAI;SACb,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,QAAoB;QACxB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YACrB,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,EAAE;YACZ,aAAa,EAAE,kBAAkB,CAAC,GAAG,EAAE;YACvC,GAAG,IAAI,CAAC,IAAI;SACb,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist/sse-connection.port.d.ts

@@ -1,6 +0,0 @@
-import type { Message } from "./message.types";
-export interface SseConnectionPort<Messages extends Message> {
-    send<M extends Messages>(message: M): Promise<void>;
-    close(callback: () => void): void;
-}
-//# sourceMappingURL=sse-connection.port.d.ts.map

package/dist/sse-connection.port.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse-connection.port.d.ts","sourceRoot":"","sources":["../src/sse-connection.port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,WAAW,iBAAiB,CAAC,QAAQ,SAAS,OAAO;IACzD,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;CACnC"}

package/dist/sse-connection.port.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sse-connection.port.js.map

package/dist/sse-connection.port.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse-connection.port.js","sourceRoot":"","sources":["../src/sse-connection.port.ts"],"names":[],"mappings":""}

package/src/dispatching-event-store.ts

@@ -1,34 +0,0 @@
-// Stryker disable all
-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 class DispatchingEventStore<AllEvents extends GenericEventSchema> extends BaseStore<AllEvents> {
-  static EMPTY_STREAM_REVISION = -1;
-
-  constructor(
-    config: {
-      finder: (
-        stream: EventStreamType,
-        names: ReadonlyArray<string>,
-      ) => Promise<ReadonlyArray<z.infer<GenericEventSchema>>>;
-      inserter: (
-        events: ReadonlyArray<z.infer<GenericParsedEventSchema>>,
-      ) => Promise<ReadonlyArray<z.infer<GenericParsedEventSchema>>>;
-    },
-    private readonly publisher: EventBusPort<z.infer<AllEvents>>,
-  ) {
-    super(config);
-  }
-
-  async save(_events: ReadonlyArray<z.infer<AllEvents>>): Promise<ReadonlyArray<z.infer<AllEvents>>> {
-    const events = await super.save(_events);
-
-    await Promise.all(events.map((event) => this.publisher.emit(event)));
-
-    return events;
-  }
-}
-// Stryker restore all

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

@@ -1,8 +0,0 @@
-import type { EventHandlerStrategy } from "./event-handler.strategy";
-import type { Message } from "./message.types";
-
-export class EventHandlerBareStrategy implements EventHandlerStrategy {
-  handle<Event extends Message>(handler: (event: Event) => Promise<void>) {
-    return async (event: Event) => handler(event);
-  }
-}

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

@@ -1,8 +0,0 @@
-import type { EventHandlerStrategy } from "./event-handler.strategy";
-import type { Message } from "./message.types";
-
-export class EventHandlerNoopStrategy implements EventHandlerStrategy {
-  handle<Event extends Message>(_handler: (event: Event) => Promise<void>) {
-    return async (_event: Event) => {};
-  }
-}

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

@@ -1,29 +0,0 @@
-import type { ClockPort } from "./clock.port";
-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 };
-
-export class EventHandlerWithLoggerStrategy implements EventHandlerStrategy {
-  constructor(private readonly deps: Dependencies) {}
-
-  handle<Event extends Message>(handler: (event: Event) => Promise<void>) {
-    return async (event: Event) => {
-      const duration = new Stopwatch(this.deps);
-
-      try {
-        await handler(event);
-      } catch (error) {
-        this.deps.Logger.error({
-          message: `Unknown ${event.name} event handler error`,
-          component: "infra",
-          operation: "event_handler",
-          metadata: { name: event.name, duration: duration.stop() },
-          error,
-        });
-      }
-    };
-  }
-}

package/src/event-handler.strategy.ts

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

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

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

package/src/event-store.ts

@@ -1,64 +0,0 @@
-// Stryker disable all
-import type * as z from "zod/v4";
-import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types";
-import type { EventStreamType } from "./event-stream.vo";
-
-export type EventNameType = z.infer<GenericEventSchema["shape"]["name"]>;
-
-type FindEventsHandler = (
-  stream: EventStreamType,
-  acceptedEventsNames: ReadonlyArray<EventNameType>,
-) => Promise<ReadonlyArray<z.infer<GenericEventSchema>>>;
-
-type InserterEventsHandler = (
-  events: ReadonlyArray<z.infer<GenericParsedEventSchema>>,
-) => Promise<ReadonlyArray<z.infer<GenericParsedEventSchema>>>;
-
-type Config = { finder: FindEventsHandler; inserter: InserterEventsHandler };
-
-export class EventStore<AllEvents extends GenericEventSchema> {
-  constructor(private readonly config: Config) {}
-
-  static EMPTY_STREAM_REVISION = -1;
-
-  async find<AcceptedEvents extends ReadonlyArray<AllEvents>>(
-    acceptedEvents: AcceptedEvents,
-    stream: EventStreamType,
-  ): Promise<ReadonlyArray<z.infer<AcceptedEvents[number]>>> {
-    const acceptedEventsNames = acceptedEvents.map((event) => event.shape.name.value);
-
-    const rows = await this.config.finder(stream, acceptedEventsNames);
-
-    return rows
-      .map((row) => ({ ...row, payload: JSON.parse(row.payload) }))
-      .map((row) => acceptedEvents.find((event) => event.shape.name.value === row.name)?.parse(row))
-      .filter((event): event is z.infer<AcceptedEvents[number]> => event !== undefined);
-  }
-
-  async save(events: ReadonlyArray<z.infer<AllEvents>>): Promise<ReadonlyArray<z.infer<AllEvents>>> {
-    if (!events[0]) return [];
-
-    const stream = events[0].stream;
-
-    if (!events.every((event) => event.stream === stream)) throw new EventStoreSaveUniqueStream();
-
-    // The returned variable has the `revision` fields added by the inserter,
-    // but we need to re-parse it to keep the contract.
-    const processed = await this.config.inserter(
-      events.map((event) => ({ ...event, payload: JSON.stringify(event.payload) })),
-    );
-
-    return processed.map((event) => ({
-      ...event,
-      payload: JSON.parse(event.payload),
-    })) as Array<z.infer<AllEvents>>;
-  }
-}
-
-export class EventStoreSaveUniqueStream extends Error {
-  constructor() {
-    super();
-    Object.setPrototypeOf(this, EventStoreSaveUniqueStream.prototype);
-  }
-}
-// Stryker restore all

package/src/sse-connection-hono.adapter.ts

@@ -1,49 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { Context } from "hono";
-import { streamSSE } from "hono/streaming";
-import type { Message } from "./message.types";
-import type { SseConnectionPort } from "./sse-connection.port";
-import type { SseRegistryPort } from "./sse-registry.port";
-
-export type SseConnectionHonoAdapterConfig = { keepalive: tools.Duration };
-
-export class SseConnectionHonoAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
-  private stream: Awaited<Parameters<Parameters<typeof streamSSE>[1]>[0]> | null = null;
-
-  constructor(
-    private readonly registry: SseRegistryPort<Messages>,
-    private readonly userId: string,
-    private readonly config: SseConnectionHonoAdapterConfig,
-  ) {}
-
-  attach(c: Context): Response {
-    return streamSSE(c, async (stream) => {
-      this.stream = stream;
-
-      this.registry.register(this.userId, this);
-
-      // Stryker disable all
-      stream.onAbort(() => this.registry.unregister(this.userId, this));
-      // Stryker restore all
-
-      while (!stream.closed) {
-        await stream.sleep(this.config.keepalive.ms);
-        await stream.writeSSE({ event: "ping", data: "" });
-      }
-    });
-  }
-
-  async send<M extends Messages>(message: M): Promise<void> {
-    // Stryker disable all
-    await this.stream?.writeSSE({ event: message.name, data: JSON.stringify(message) });
-    // Stryker restore all;
-  }
-
-  close(callback: () => void): void {
-    this.registry.unregister(this.userId, this);
-    callback();
-    // Stryker disable all
-    this.stream?.close();
-    // Stryker restore all
-  }
-}

package/src/sse-connection-hono.handler.ts

@@ -1,22 +0,0 @@
-import { createFactory } from "hono/factory";
-import type { HandlerHonoPort } from "./handler-hono.port";
-import type { Message } from "./message.types";
-import { SseConnectionHonoAdapter, type SseConnectionHonoAdapterConfig } from "./sse-connection-hono.adapter";
-import type { SseRegistryPort } from "./sse-registry.port";
-
-const factory = createFactory();
-
-export class SseConnectionHonoHandler<Messages extends Message> implements HandlerHonoPort {
-  constructor(
-    private readonly registry: SseRegistryPort<Messages>,
-    private readonly config: SseConnectionHonoAdapterConfig,
-  ) {}
-
-  handle() {
-    return factory.createHandlers<{}, any, { Variables: { user: { id: string } } }>((c) => {
-      const userId = c.get("user").id;
-      const adapter = new SseConnectionHonoAdapter<Messages>(this.registry, userId, this.config);
-      return adapter.attach(c);
-    });
-  }
-}

package/src/sse-connection-noop.adapter.ts

@@ -1,8 +0,0 @@
-import type { Message } from "./message.types";
-import type { SseConnectionPort } from "./sse-connection.port";
-
-export class SseConnectionNoopAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
-  async send<M extends Messages>(_message: M) {}
-
-  close(_callback: () => void): void {}
-}

package/src/sse-connection-with-logger.adapter.ts

@@ -1,34 +0,0 @@
-import { CorrelationStorage } from "./correlation-storage.service";
-import type { LoggerPort } from "./logger.port";
-import type { Message } from "./message.types";
-import type { SseConnectionPort } from "./sse-connection.port";
-
-type Dependencies<Messages extends Message> = { inner: SseConnectionPort<Messages>; Logger: LoggerPort };
-
-export class SseConnectionWithLoggerAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
-  private readonly base = { component: "infra", operation: "sse_connection" };
-
-  constructor(private readonly deps: Dependencies<Messages>) {}
-
-  async send<M extends Messages>(message: M) {
-    this.deps.Logger.debug({
-      message: `${message.name} sent`,
-      metadata: message,
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    await this.deps.inner.send(message);
-  }
-
-  close(callback: () => void): void {
-    this.deps.Logger.debug({
-      message: "SSE connection closed",
-      metadata: {},
-      correlationId: CorrelationStorage.get(),
-      ...this.base,
-    });
-
-    this.deps.inner.close(callback);
-  }
-}

package/src/sse-connection.port.ts

@@ -1,7 +0,0 @@
-import type { Message } from "./message.types";
-
-export interface SseConnectionPort<Messages extends Message> {
-  send<M extends Messages>(message: M): Promise<void>;
-
-  close(callback: () => void): void;
-}