@imbingox/acex 0.4.0-beta.16 → 0.4.0-beta.18

package/src/managers/account-manager.ts

@@ -14,6 +14,8 @@ import type {
   PrivateAccountDataConsumer,
   PrivateSubscriptionState,
 } from "../client/context.ts";
+import { AcexError } from "../errors.ts";
+import type { AsyncEventBusOverflowInfo } from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { toCanonical } from "../internal/decimal.ts";
 import { matchesAccountFilter } from "../internal/filters.ts";
@@ -125,23 +127,33 @@ export class AccountManagerImpl
     this.context = context;
 
     this.events = {
-      status: (filter) =>
-        this.accountStatusBus.stream((event) =>
-          matchesAccountFilter(
-            { accountId: event.accountId, venue: event.venue },
-            filter,
-          ),
+      status: (filter, options) =>
+        this.accountStatusBus.stream(
+          (event) =>
+            matchesAccountFilter(
+              { accountId: event.accountId, venue: event.venue },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("account.status"),
+          },
         ),
-      updates: (filter) =>
-        this.accountBus.stream((event) =>
-          matchesAccountFilter(
-            {
-              accountId: event.accountId,
-              venue: event.venue,
-              symbol: "symbol" in event ? event.symbol : undefined,
-            },
-            filter,
-          ),
+      updates: (filter, options) =>
+        this.accountBus.stream(
+          (event) =>
+            matchesAccountFilter(
+              {
+                accountId: event.accountId,
+                venue: event.venue,
+                symbol: "symbol" in event ? event.symbol : undefined,
+              },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("account.updates"),
+          },
         ),
     };
   }
@@ -872,4 +884,19 @@ export class AccountManagerImpl
     this.accountStatusBus.publish(event);
     this.context.publishHealthEvent(event);
   }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("account", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
 }

package/src/managers/market-manager.ts

@@ -19,10 +19,15 @@ import {
   buildAcexErrorDetails,
   formatAcexErrorMessage,
 } from "../errors.ts";
+import type {
+  AsyncEventBusOverflowInfo,
+  AsyncEventBusStreamOptions,
+} from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { toCanonical } from "../internal/decimal.ts";
 import { matchesMarketFilter } from "../internal/filters.ts";
 import type {
+  EventStreamOptions,
   FundingRateSnapshot,
   FundingRateUpdatedEvent,
   L1Book,
@@ -67,6 +72,14 @@ interface MarketRecord {
   status: MarketDataStatus;
   l1BookStream?: StreamHandle;
   fundingRateStream?: StreamHandle;
+  lastPublishedStatusKey?: MarketStatusPublicationKey;
+}
+
+interface MarketStatusPublicationKey {
+  activity: MarketDataStatus["activity"];
+  ready: MarketDataStatus["ready"];
+  freshness: MarketDataStatus["freshness"];
+  reason: MarketDataStatus["reason"];
 }
 
 interface CatalogFetchResult {
@@ -85,10 +98,38 @@ function marketKey(input: MarketKeyInput): string {
   return `${input.venue}:${input.symbol}`;
 }
 
+function marketEventConflateKey(event: MarketEvent): string {
+  return `${event.type}:${marketKey(event)}`;
+}
+
 function cloneMarketStatus(status: MarketDataStatus): MarketDataStatus {
   return { ...status };
 }
 
+function statusPublicationKey(
+  status: MarketDataStatus,
+): MarketStatusPublicationKey {
+  return {
+    activity: status.activity,
+    ready: status.ready,
+    freshness: status.freshness,
+    reason: status.reason,
+  };
+}
+
+function sameStatusPublicationKey(
+  current: MarketStatusPublicationKey,
+  previous: MarketStatusPublicationKey | undefined,
+): boolean {
+  return (
+    previous !== undefined &&
+    current.activity === previous.activity &&
+    current.ready === previous.ready &&
+    current.freshness === previous.freshness &&
+    current.reason === previous.reason
+  );
+}
+
 function cloneStreamStatus(
   status: MarketDataStreamStatus,
 ): MarketDataStreamStatus {
@@ -153,23 +194,49 @@ export class MarketManagerImpl
       options.l1ReconnectMaxDelayMs ?? DEFAULT_L1_RECONNECT_MAX_DELAY_MS;
 
     this.events = {
-      all: (filter) =>
-        this.marketBus.stream((event) => matchesMarketFilter(event, filter)),
-      fundingRateUpdates: (filter) =>
+      all: (filter, options) =>
+        this.marketBus.stream(
+          (event) => matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.all",
+            options,
+            "buffer",
+            marketEventConflateKey,
+          ),
+        ),
+      fundingRateUpdates: (filter, options) =>
         this.marketBus.stream(
           (event): event is FundingRateUpdatedEvent =>
             event.type === "funding_rate.updated" &&
             matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.fundingRateUpdates",
+            options,
+            "conflate",
+            marketKey,
+          ),
         ),
-      l1BookUpdates: (filter) =>
+      l1BookUpdates: (filter, options) =>
         this.marketBus.stream(
           (event): event is L1BookUpdatedEvent =>
             event.type === "l1_book.updated" &&
             matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.l1BookUpdates",
+            options,
+            "conflate",
+            marketKey,
+          ),
         ),
-      status: (filter) =>
-        this.marketStatusBus.stream((event) =>
-          matchesMarketFilter(event, filter),
+      status: (filter, options) =>
+        this.marketStatusBus.stream(
+          (event) => matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.status",
+            options,
+            "buffer",
+            marketKey,
+          ),
         ),
     };
   }
@@ -1064,6 +1131,14 @@ export class MarketManagerImpl
       record.status.lastReadyAt = this.resolveLastReadyAt(record);
     }
 
+    const publicationKey = statusPublicationKey(record.status);
+    if (
+      sameStatusPublicationKey(publicationKey, record.lastPublishedStatusKey)
+    ) {
+      return;
+    }
+
+    record.lastPublishedStatusKey = publicationKey;
     this.publishStatus(record);
   }
 
@@ -1184,6 +1259,35 @@ export class MarketManagerImpl
     this.context.publishHealthEvent(event);
   }
 
+  private createStreamOptions<U extends { venue: Venue; symbol: string }>(
+    stream: string,
+    options: EventStreamOptions | undefined,
+    defaultMode: "buffer" | "conflate",
+    conflateKey: (event: U) => string,
+  ): AsyncEventBusStreamOptions<U> {
+    return {
+      mode: options?.mode ?? defaultMode,
+      maxBuffer: options?.maxBuffer,
+      conflateKey,
+      onOverflow: this.createOverflowHandler(stream),
+    };
+  }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("market", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
+
   private async resumeStreams(): Promise<void> {
     for (const record of this.records.values()) {
       const market = record.market;

package/src/managers/order-manager.ts

@@ -17,6 +17,7 @@ import {
   buildAcexErrorDetails,
   formatAcexErrorMessage,
 } from "../errors.ts";
+import type { AsyncEventBusOverflowInfo } from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { matchesOrderFilter } from "../internal/filters.ts";
 import { isTransportError } from "../internal/http-client.ts";
@@ -116,23 +117,33 @@ export class OrderManagerImpl
     );
 
     this.events = {
-      status: (filter) =>
-        this.orderStatusBus.stream((event) =>
-          matchesOrderFilter(
-            { accountId: event.accountId, venue: event.venue },
-            filter,
-          ),
+      status: (filter, options) =>
+        this.orderStatusBus.stream(
+          (event) =>
+            matchesOrderFilter(
+              { accountId: event.accountId, venue: event.venue },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("order.status"),
+          },
         ),
-      updates: (filter) =>
-        this.orderBus.stream((event) =>
-          matchesOrderFilter(
-            {
-              accountId: event.accountId,
-              venue: event.venue,
-              symbol: "symbol" in event ? event.symbol : undefined,
-            },
-            filter,
-          ),
+      updates: (filter, options) =>
+        this.orderBus.stream(
+          (event) =>
+            matchesOrderFilter(
+              {
+                accountId: event.accountId,
+                venue: event.venue,
+                symbol: "symbol" in event ? event.symbol : undefined,
+              },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("order.updates"),
+          },
         ),
     };
   }
@@ -1270,6 +1281,21 @@ export class OrderManagerImpl
       },
     };
   }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("order", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
 }
 
 function isOrderErrorCode(

package/src/types/account.ts

@@ -1,4 +1,5 @@
 import type {
+  BufferedEventStreamOptions,
   PrivateRuntimeReason,
   PrivateRuntimeStatus,
   SubscriptionActivity,
@@ -158,8 +159,14 @@ export type AccountEvent =
   | AccountSnapshotReplacedEvent;
 
 export interface AccountEventStreams {
-  updates(filter?: AccountEventFilter): AsyncIterable<AccountEvent>;
-  status(filter?: AccountEventFilter): AsyncIterable<AccountStatusChangedEvent>;
+  updates(
+    filter?: AccountEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AccountEvent>;
+  status(
+    filter?: AccountEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AccountStatusChangedEvent>;
 }
 
 export interface AccountManager {

package/src/types/client.ts

@@ -18,6 +18,7 @@ import type {
 import type {
   AccountCredentials,
   AcexInternalError,
+  BufferedEventStreamOptions,
   ClientStatus,
   CreateClientOptions,
   RegisterAccountInput,
@@ -54,8 +55,13 @@ export interface HealthEventFilter {
 }
 
 export interface ClientEventStreams {
-  health(filter?: HealthEventFilter): AsyncIterable<HealthEvent>;
-  errors(): AsyncIterable<AcexInternalError>;
+  health(
+    filter?: HealthEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<HealthEvent>;
+  errors(
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AcexInternalError>;
 }
 
 export type VenueRuntimeStatus = "available" | "type_only" | "reserved";

package/src/types/market.ts

@@ -1,6 +1,11 @@
 import type BigNumber from "bignumber.js";
 import type { AcexError } from "../errors.ts";
-import type { MarketFreshness, SubscriptionActivity, Venue } from "./shared.ts";
+import type {
+  EventStreamOptions,
+  MarketFreshness,
+  SubscriptionActivity,
+  Venue,
+} from "./shared.ts";
 
 export type MarketType = "spot" | "swap" | "future";
 
@@ -170,12 +175,22 @@ export type MarketEvent =
   | MarketStatusChangedEvent;
 
 export interface MarketEventStreams {
-  l1BookUpdates(filter?: MarketEventFilter): AsyncIterable<L1BookUpdatedEvent>;
+  l1BookUpdates(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<L1BookUpdatedEvent>;
   fundingRateUpdates(
     filter?: MarketEventFilter,
+    options?: EventStreamOptions,
   ): AsyncIterable<FundingRateUpdatedEvent>;
-  status(filter?: MarketEventFilter): AsyncIterable<MarketStatusChangedEvent>;
-  all(filter?: MarketEventFilter): AsyncIterable<MarketEvent>;
+  status(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<MarketStatusChangedEvent>;
+  all(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<MarketEvent>;
 }
 
 export interface MarketManager {

package/src/types/order.ts

@@ -1,5 +1,6 @@
 import type { PositionSide } from "./account.ts";
 import type {
+  BufferedEventStreamOptions,
   PrivateRuntimeReason,
   PrivateRuntimeStatus,
   SubscriptionActivity,
@@ -160,8 +161,14 @@ export type OrderEvent =
   | OrderSnapshotReplacedEvent;
 
 export interface OrderEventStreams {
-  updates(filter?: OrderEventFilter): AsyncIterable<OrderEvent>;
-  status(filter?: OrderEventFilter): AsyncIterable<OrderStatusChangedEvent>;
+  updates(
+    filter?: OrderEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<OrderEvent>;
+  status(
+    filter?: OrderEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<OrderStatusChangedEvent>;
 }
 
 export interface OrderManager {