@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/src/types/protocols-types.ts

@@ -154,6 +154,36 @@ export type ProtocolSizeDefinition = {
   max?: number;
 };
 
+/**
+ * Supported strategies for handling writes that would exceed a `$recordLimit`.
+ */
+export enum ProtocolRecordLimitStrategy {
+  /** Reject the incoming write with an error. The author must delete old records first. */
+  Reject = 'reject',
+  /** Automatically delete the oldest record(s) (by `dateCreated`) to make room for the new one. */
+  PurgeOldest = 'purgeOldest',
+}
+
+/**
+ * Limits the number of records at a given protocol path within the same parent context.
+ *
+ * For root-level records, the count is across the entire protocol for the tenant.
+ * For nested records, the count is scoped to the parent record's context.
+ *
+ * Only initial writes (new records) count toward the limit; updates to existing records do not.
+ */
+export type ProtocolRecordLimitDefinition = {
+  /** Maximum number of records allowed at this path within the same parent context. Must be >= 1. */
+  max: number;
+
+  /**
+   * Strategy when the limit is reached.
+   * Currently only `'reject'` is implemented. Future strategies (e.g. `'purgeOldest'`)
+   * are defined in the wire format but not yet enforced.
+   */
+  strategy: ProtocolRecordLimitStrategy | `${ProtocolRecordLimitStrategy}` | (string & {});
+};
+
 /**
  * Tag rules for records at a given protocol path. Each non-`$`-prefixed property
  * is a JSON Schema object constraining that tag's value.
@@ -201,6 +231,7 @@ type ProtocolRuleSetValue =
   | ProtocolPathEncryption
   | ProtocolTagsDefinition
   | ProtocolSizeDefinition
+  | ProtocolRecordLimitDefinition
   | boolean
   | string
   | undefined;
@@ -247,6 +278,21 @@ export type ProtocolRuleSet = {
    */
   $tags?: ProtocolTagsDefinition;
 
+  /**
+   * If $recordLimit is set, the number of records at this protocol path within the same
+   * parent context is constrained. When the limit is reached, the `strategy` determines
+   * whether the write is rejected or the oldest record is purged.
+   */
+  $recordLimit?: ProtocolRecordLimitDefinition;
+
+  /**
+   * If `$immutable` is `true`, records at this protocol path are write-once: they can be
+   * created but never updated after the initial write. `RecordsDelete` is still governed
+   * by `$actions` — immutability means the record's data cannot change, not that it
+   * cannot be removed.
+   */
+  $immutable?: boolean;
+
   /**
    * Non-`$`-prefixed keys are nested child `ProtocolRuleSet` entries.
    * At runtime, JSON Schema validation ensures only valid child rule sets appear here.

package/src/types/records-types.ts

@@ -1,5 +1,6 @@
 import type { GeneralJws } from './jws-types.js';
 import type { JweEncryption } from '../utils/encryption.js';
+import type { SubscriptionListener } from './subscriptions.js';
 import type { AuthorizationModel, GenericMessage, GenericMessageReply, GenericSignaturePayload, MessageSubscription, Pagination } from './message-types.js';
 import type { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
 import type { PaginationCursor, RangeCriterion, RangeFilter, StartsWithFilter } from './query-types.js';
@@ -23,8 +24,8 @@ export type RecordsWriteTagsFilter = StartsWithFilter | RangeFilter | string | n
 export type RecordsWriteDescriptor = {
   interface: DwnInterfaceName.Records;
   method: DwnMethodName.Write;
-  protocol?: string;
-  protocolPath?: string;
+  protocol: string;
+  protocolPath: string;
   recipient?: string;
   schema?: string;
   tags?: RecordsWriteTags;
@@ -57,7 +58,7 @@ export type InternalRecordsWriteMessage = GenericMessage & {
 export type RecordsWriteMessage = {
   authorization: AuthorizationModel; // overriding `GenericMessage` with `authorization` being required
   recordId: string,
-  contextId?: string;
+  contextId: string;
   descriptor: RecordsWriteDescriptor;
   attestation?: GeneralJws;
   encryption?: JweEncryption;
@@ -122,6 +123,12 @@ export type RecordsSubscribeDescriptor = {
   filter: RecordsFilter;
   dateSort?: DateSort;
   pagination?: Pagination;
+  /**
+   * Opaque EventLog cursor string to resume from. When provided, the handler replays
+   * events from the EventLog starting after this cursor instead of querying the
+   * MessageStore for an initial snapshot. An EOSE marker is sent after catch-up.
+   */
+  cursor?: string;
 };
 
 export type RecordsFilter = {
@@ -157,7 +164,7 @@ export type RecordsWriteAttestationPayload = {
 
 export type RecordsWriteSignaturePayload = GenericSignaturePayload & {
   recordId: string;
-  contextId?: string;
+  contextId: string;
   attestationCid?: string;
   encryptionCid?: string;
 };
@@ -176,10 +183,13 @@ export type RecordEvent = {
   initialWrite?: RecordsWriteMessage;
 };
 
-export type RecordSubscriptionHandler = (event: RecordEvent) => void;
+/**
+ * @deprecated Use {@link SubscriptionListener} directly. Retained as an alias for migration.
+ */
+export type RecordSubscriptionHandler = SubscriptionListener;
 
 export type RecordsSubscribeMessageOptions = {
-  subscriptionHandler: RecordSubscriptionHandler;
+  subscriptionHandler: SubscriptionListener;
 };
 
 export type RecordsSubscribeMessage = GenericMessage & {

package/src/types/subscriptions.ts

@@ -1,9 +1,13 @@
-import type { GenericMessageReply } from '../types/message-types.js';
-import type { KeyValues } from './query-types.js';
 import type { RecordsWriteMessage } from './records-types.js';
-import type { GenericMessage, MessageSubscription } from './message-types.js';
+import type { Filter, KeyValues } from './query-types.js';
+import type { GenericMessage, GenericMessageReply, MessageSubscription } from './message-types.js';
 
-export type EventListener = (tenant: string, event: MessageEvent, indexes: KeyValues) => void;
+/**
+ * Internal listener type used by {@link EventLog.emit} to notify in-process
+ * subscribers. Not intended for direct consumer use — consumers should use
+ * {@link SubscriptionListener} via {@link EventLog.subscribe}.
+ */
+export type EventListener = (tenant: string, event: MessageEvent, indexes: KeyValues, seq: number) => void;
 
 /**
  * MessageEvent contains the message being emitted and an optional initial write message.
@@ -14,16 +18,6 @@ export type MessageEvent = {
   initialWrite?: RecordsWriteMessage
 };
 
-/**
- * The EventStream interface implements a pub/sub system based on Message filters.
- */
-export interface EventStream {
-  subscribe(tenant: string, id: string, listener: EventListener): Promise<EventSubscription>;
-  emit(tenant: string, event: MessageEvent, indexes: KeyValues): void;
-  open(): Promise<void>;
-  close(): Promise<void>;
-}
-
 export interface EventSubscription {
   id: string;
   close: () => Promise<void>;
@@ -32,3 +26,173 @@ export interface EventSubscription {
 export type SubscriptionReply = GenericMessageReply & {
   subscription?: MessageSubscription;
 };
+
+// ---------------------------------------------------------------------------
+// Subscription events — discriminated union for event + EOSE delivery
+// ---------------------------------------------------------------------------
+
+/**
+ * A regular subscription event carrying a message and its EventLog cursor.
+ */
+export type SubscriptionEvent = {
+  type : 'event';
+  /**
+   * Opaque cursor string assigned by the EventLog implementation. Clients should
+   * persist this value and pass it back to `subscribe()` or `read()` to resume
+   * from this point. The format is implementation-defined (e.g. numeric sequence
+   * for in-memory, Redis stream ID, NATS stream sequence, etc.).
+   */
+  cursor : string;
+  /** The event payload (message + optional initialWrite). */
+  event : MessageEvent;
+};
+
+/**
+ * End-of-Stored-Events marker. Sent after all catch-up events have been replayed
+ * from the EventLog. After EOSE, all subsequent events are live.
+ *
+ * Only delivered when a subscription is created with a `cursor`. Subscriptions
+ * without a cursor never receive EOSE.
+ */
+export type SubscriptionEose = {
+  type : 'eose';
+  /**
+   * Opaque cursor string of the last stored event that was replayed.
+   * Echoes the input cursor when no stored events matched (i.e. already caught up).
+   */
+  cursor : string;
+};
+
+/**
+ * Discriminated union of subscription event types delivered to
+ * {@link SubscriptionListener} callbacks.
+ */
+export type SubscriptionMessage = SubscriptionEvent | SubscriptionEose;
+
+/**
+ * Callback for {@link EventLog.subscribe}. Receives either a regular event
+ * (with cursor) or an EOSE marker indicating catch-up replay is complete.
+ */
+export type SubscriptionListener = (message: SubscriptionMessage) => void;
+
+/**
+ * Options for {@link EventLog.subscribe}.
+ */
+export type EventLogSubscribeOptions = {
+  /**
+   * Opaque cursor string to resume from (exclusive — events after this cursor
+   * are replayed). When provided, stored events are replayed first, followed by
+   * an EOSE marker, then live events. When omitted, only live events are delivered.
+   *
+   * Cursor values are implementation-defined and must be obtained from a prior
+   * interaction with the same EventLog instance (e.g. `SubscriptionEvent.cursor`,
+   * `EventLogReadResult.cursor`, or the return value of `emit()`).
+   */
+  cursor? : string;
+
+  /**
+   * Filters evaluated against event indexes. Events must match at least one
+   * filter (OR semantics). When omitted, all events are delivered.
+   */
+  filters? : Filter[];
+};
+
+// ---------------------------------------------------------------------------
+// EventLog — persistent, cursor-based event delivery
+// ---------------------------------------------------------------------------
+
+/**
+ * A single entry returned by {@link EventLog.read}.
+ */
+export type EventLogEntry = {
+  /** Monotonic sequence number scoped to (instance, tenant). */
+  seq: number;
+
+  /** The event payload. */
+  event: MessageEvent;
+
+  /** Indexes associated with the event (used for filter matching). */
+  indexes: KeyValues;
+};
+
+/**
+ * Options accepted by {@link EventLog.read}.
+ */
+export type EventLogReadOptions = {
+  /** Opaque cursor string to resume from (exclusive — returns events after this cursor). */
+  cursor? : string;
+
+  /** Maximum number of events to return. */
+  limit? : number;
+
+  /** Optional filters evaluated server-side. Events must match at least one filter (OR semantics). */
+  filters?: Filter[];
+};
+
+/**
+ * Result returned by {@link EventLog.read}.
+ */
+export type EventLogReadResult = {
+  /** Events matching the read request, ordered by ascending seq. */
+  events : EventLogEntry[];
+
+  /**
+   * Opaque cursor string for resuming subsequent reads or subscriptions.
+   *
+   * - When events are returned: cursor of the last event.
+   * - When no events are returned but a cursor was provided: the input cursor
+   *   (meaning "you are caught up, nothing new since this point").
+   * - When no events exist and no cursor was provided: `undefined`.
+   */
+  cursor? : string;
+};
+
+/**
+ * The EventLog interface provides persistent, ordered event storage with
+ * cursor-based reads and subscription support.
+ *
+ * It persists events before delivery, exposing opaque cursor strings
+ * that enable cursor-based resume after disconnects.
+ *
+ * The interface is intentionally transport-agnostic — implementations can be
+ * backed by LevelDB (embedded), SQL, NATS JetStream, Redis Streams, etc.
+ * Each implementation owns the catch-up + live transition strategy appropriate
+ * to its backend (e.g., NATS pull consumers, Redis XREAD, in-memory buffering).
+ */
+export interface EventLog {
+  /**
+   * Persist an event and notify in-process subscribers.
+   * @returns The opaque cursor string assigned to the event, or empty string on failure.
+   */
+  emit(tenant: string, event: MessageEvent, indexes: KeyValues): Promise<string>;
+
+  /**
+   * Read events from the log starting after `cursor`, optionally filtered.
+   */
+  read(tenant: string, options?: EventLogReadOptions): Promise<EventLogReadResult>;
+
+  /**
+   * Subscribe to events for a tenant.
+   *
+   * When `options.cursor` is provided, the implementation replays stored events
+   * from that cursor through the listener, delivers an EOSE marker, then
+   * continues with live events. The catch-up → live transition (including
+   * buffering and deduplication) is owned by the implementation.
+   *
+   * When `options.cursor` is omitted, only live events are delivered.
+   *
+   * @param tenant   The tenant DID to subscribe to.
+   * @param id       A unique subscription identifier (used for close/tracking).
+   * @param listener Callback that receives {@link SubscriptionMessage} events.
+   * @param options  Optional cursor and filters for catch-up replay.
+   */
+  subscribe(tenant: string, id: string, listener: SubscriptionListener, options?: EventLogSubscribeOptions): Promise<EventSubscription>;
+
+  /**
+   * Delete events older than the given sequence number or ISO-8601 timestamp.
+   */
+  trim(tenant: string, olderThan: number | string): Promise<void>;
+
+  open(): Promise<void>;
+  close(): Promise<void>;
+}

package/src/utils/hd-key.ts

@@ -6,17 +6,8 @@ import { X25519 } from '@enbox/crypto';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 
 export enum KeyDerivationScheme {
-  /**
-   * Key derivation using the `dataFormat` value for Flat-space records.
-   */
-  DataFormats = 'dataFormats',
   ProtocolContext = 'protocolContext',
   ProtocolPath = 'protocolPath',
-
-  /**
-   * Key derivation using the `schema` value for Flat-space records.
-   */
-  Schemas = 'schemas'
 }
 
 export type DerivedPrivateJwk = {

package/src/utils/messages.ts

@@ -1,10 +1,9 @@
+import type { CoreProtocolRegistry } from '../core/core-protocol.js';
 import type { Filter } from '../types/query-types.js';
 import type { MessagesFilter } from '../types/messages-types.js';
 
 import { FilterUtility } from './filter.js';
 import { normalizeProtocolUrl } from './url.js';
-import { PermissionsProtocol } from '../protocols/permissions.js';
-import { Records } from './records.js';
 import { isEmptyObject, removeUndefinedProperties } from './object.js';
 
 
@@ -42,25 +41,29 @@ export class Messages {
   /**
    *  Converts an incoming array of MessagesFilter into an array of Filter usable by MessageLog.
    *
+   * When a `CoreProtocolRegistry` is provided, each registered core protocol's
+   * `constructAdditionalMessageFilter` hook is invoked per filter. This replaces the previous
+   * hardcoded permission-records shadow filter with a generic loop over all core protocols.
+   *
    * @param filters An array of MessagesFilter
+   * @param coreProtocols Optional registry of core protocols whose additional filters are injected.
    * @returns {Filter[]} an array of generic Filter able to be used when querying.
    */
-  public static convertFilters(filters: MessagesFilter[]): Filter[] {
+  public static convertFilters(filters: MessagesFilter[], coreProtocols?: CoreProtocolRegistry): Filter[] {
 
     const messagesQueryFilters: Filter[] = [];
 
-    // convert each filter individually by the specific type of filter it is
-    // we must check for the type of filter in a specific order to make a reductive decision as to which filters need converting
-    // first we check for `MessagesRecordsFilter` fields for conversion
-    // otherwise it is `MessagesMessageFilter` fields for conversion
     for (const filter of filters) {
-      // extract the protocol tag filter from the incoming message record filter
-      // this filters for permission grants, requests and revocations associated with a targeted protocol
-      // since permissions are their own protocol, we added an additional tag index when writing the permission messages
-      // so that we can filter for permission records here
-      const permissionRecordsFilter = this.constructPermissionRecordsFilter(filter);
-      if (permissionRecordsFilter) {
-        messagesQueryFilters.push(permissionRecordsFilter);
+      // Ask each core protocol whether it needs an additional shadow filter for this query.
+      // For example, the Permissions protocol injects a filter for grants/requests/revocations
+      // tagged with the target protocol so they appear alongside that protocol's own records.
+      if (coreProtocols !== undefined) {
+        for (const coreProtocol of coreProtocols.all()) {
+          const additionalFilter = coreProtocol.constructAdditionalMessageFilter?.(filter);
+          if (additionalFilter !== undefined) {
+            messagesQueryFilters.push(additionalFilter);
+          }
+        }
       }
 
       messagesQueryFilters.push(this.convertFilter(filter));
@@ -69,29 +72,6 @@ export class Messages {
     return messagesQueryFilters;
   }
 
-  /**
-   * Constructs a filter that gets associated permission records if protocol is in the given filter.
-   */
-  private static constructPermissionRecordsFilter(filter: MessagesFilter): Filter | undefined {
-    const { protocol, messageTimestamp } = filter;
-    if (protocol !== undefined) {
-      const taggedFilter = {
-        protocol: PermissionsProtocol.uri,
-        ...Records.convertTagsFilter({ protocol })
-      } as Filter;
-
-      if (messageTimestamp != undefined) {
-        // if we filter by message timestamp, we also want to filter the permission messages by the same timestamp range
-        const messageTimestampFilter = FilterUtility.convertRangeCriterion(messageTimestamp);
-        if (messageTimestampFilter) {
-          taggedFilter.messageTimestamp = messageTimestampFilter;
-        }
-      }
-
-      return taggedFilter;
-    }
-  }
-
   /**
    * Converts an external-facing filter model into an internal-facing filer model used by data store.
    */

package/src/utils/protocols.ts

@@ -44,6 +44,14 @@ export function isCrossProtocolRef(ref: string): boolean {
   return ref.includes(':');
 }
 
+/**
+ * Extracts the last segment of a protocolPath — i.e. the type name.
+ * e.g. `'thread/comment'` → `'comment'`, `'note'` → `'note'`.
+ */
+export function getTypeName(protocolPath: string): string {
+  return protocolPath.split('/').slice(-1)[0];
+}
+
 /**
  * Gets the rule set at a given protocol path within a protocol definition's structure tree.
  * Returns `undefined` if the path does not exist.

package/src/utils/records.ts

@@ -139,32 +139,16 @@ export class Records {
     const contextId = recordsWriteMessage.contextId;
 
     let fullDerivationPath;
-    if (keyDerivationScheme === KeyDerivationScheme.DataFormats) {
-      fullDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(descriptor.dataFormat);
-    } else if (keyDerivationScheme === KeyDerivationScheme.ProtocolPath) {
+    if (keyDerivationScheme === KeyDerivationScheme.ProtocolPath) {
       fullDerivationPath = Records.constructKeyDerivationPathUsingProtocolPathScheme(descriptor);
-    } else if (keyDerivationScheme === KeyDerivationScheme.ProtocolContext) {
-      fullDerivationPath = Records.constructKeyDerivationPathUsingProtocolContextScheme(contextId);
     } else {
-      // `schemas` scheme
-      fullDerivationPath = Records.constructKeyDerivationPathUsingSchemasScheme(descriptor.schema);
+      // `protocolContext` scheme
+      fullDerivationPath = Records.constructKeyDerivationPathUsingProtocolContextScheme(contextId);
     }
 
     return fullDerivationPath;
   }
 
-  /**
-   * Constructs the full key derivation path using `dataFormats` scheme.
-   * The derivation path is always `["dataFormats", "<mime-type>"]` regardless of whether
-   * a schema is present. This matches the spec: keys are derived purely from the MIME type.
-   */
-  public static constructKeyDerivationPathUsingDataFormatsScheme(dataFormat: string): string[] {
-    return [
-      KeyDerivationScheme.DataFormats,
-      dataFormat
-    ];
-  }
-
   /**
    * Constructs the full key derivation path using `protocolPath` scheme.
    *
@@ -174,16 +158,7 @@ export class Records {
    * its children (composing protocol) use different protocol URIs and thus different key trees.
    */
   public static constructKeyDerivationPathUsingProtocolPathScheme(descriptor: RecordsWriteDescriptor): string[] {
-    // ensure `protocol` is defined
-    // NOTE: no need to check `protocolPath` and `contextId` because earlier code ensures that if `protocol` is defined, those are defined also
-    if (descriptor.protocol === undefined) {
-      throw new DwnError(
-        DwnErrorCode.RecordsProtocolPathDerivationSchemeMissingProtocol,
-        'Unable to construct key derivation path using `protocols` scheme because `protocol` is missing.'
-      );
-    }
-
-    const protocolPathSegments = descriptor.protocolPath!.split('/');
+    const protocolPathSegments = descriptor.protocolPath.split('/');
     const fullDerivationPath = [
       KeyDerivationScheme.ProtocolPath,
       descriptor.protocol,
@@ -203,15 +178,8 @@ export class Records {
    * a shared context (e.g., thread participants can decrypt messages from both the threads protocol
    * and composing protocols that attach to those threads).
    */
-  public static constructKeyDerivationPathUsingProtocolContextScheme(contextId: string | undefined): string[] {
-    if (contextId === undefined) {
-      throw new DwnError(
-        DwnErrorCode.RecordsProtocolContextDerivationSchemeMissingContextId,
-        'Unable to construct key derivation path using `protocolContext` scheme because `contextId` is missing.'
-      );
-    }
-
-    // TODO: issue #683 -Extend key derivation support to include the full contextId (https://github.com/enboxorg/enbox/issues/683)
+  public static constructKeyDerivationPathUsingProtocolContextScheme(contextId: string): string[] {
+    // TODO: Extend key derivation support to include the full contextId (https://github.com/enboxorg/enbox/issues/99)
     const firstContextSegment = contextId.split('/')[0];
 
     const fullDerivationPath = [
@@ -222,25 +190,6 @@ export class Records {
     return fullDerivationPath;
   }
 
-  /**
-   * Constructs the full key derivation path using `schemas` scheme.
-   */
-  public static constructKeyDerivationPathUsingSchemasScheme( schema: string | undefined ): string[] {
-    if (schema === undefined) {
-      throw new DwnError(
-        DwnErrorCode.RecordsSchemasDerivationSchemeMissingSchema,
-        'Unable to construct key derivation path using `schemas` scheme because `schema` is missing.'
-      );
-    }
-
-    const fullDerivationPath = [
-      KeyDerivationScheme.Schemas,
-      schema
-    ];
-
-    return fullDerivationPath;
-  }
-
   /**
    * Derives a descendant private key given an ancestor private key and the full absolute derivation path.
    * Uses X25519 keys for encryption key derivation.
@@ -456,7 +405,7 @@ export class Records {
     if (authorDelegatedGrantDefined) {
       const delegatedGrant = message.authorization!.authorDelegatedGrant!;
 
-      const permissionGrant = await PermissionGrant.parse(delegatedGrant);
+      const permissionGrant = PermissionGrant.parse(delegatedGrant);
       if (permissionGrant.delegated !== true) {
         throw new DwnError(
           DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant,
@@ -499,7 +448,7 @@ export class Records {
 
     if (ownerDelegatedGrantDefined) {
       const delegatedGrant = message.authorization!.ownerDelegatedGrant!;
-      const permissionGrant = await PermissionGrant.parse(delegatedGrant);
+      const permissionGrant = PermissionGrant.parse(delegatedGrant);
 
       if (permissionGrant.delegated !== true) {
         throw new DwnError(

package/dist/esm/src/event-stream/event-emitter-stream.js

@@ -1,60 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { EventEmitter } from 'events';
-import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
-const EVENTS_LISTENER_CHANNEL = 'events';
-;
-export class EventEmitterStream {
-    constructor(config = {}) {
-        this.isOpen = false;
-        /**
-         * we subscribe to the `EventEmitter` error handler with a provided handler or set one which logs the errors.
-         */
-        this.errorHandler = (error) => { console.error('event emitter error', error); };
-        // we capture the rejections and currently just log the errors that are produced
-        this.eventEmitter = new EventEmitter({ captureRejections: true });
-        // number of listeners per particular eventName before a warning is emitted
-        // we set to 0 which represents infinity.
-        // https://nodejs.org/api/events.html#emittersetmaxlistenersn
-        this.eventEmitter.setMaxListeners(0);
-        if (config.errorHandler) {
-            this.errorHandler = config.errorHandler;
-        }
-        this.eventEmitter.on('error', this.errorHandler);
-    }
-    subscribe(tenant, id, listener) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.eventEmitter.on(`${tenant}_${EVENTS_LISTENER_CHANNEL}`, listener);
-            return {
-                id,
-                close: () => __awaiter(this, void 0, void 0, function* () { this.eventEmitter.off(`${tenant}_${EVENTS_LISTENER_CHANNEL}`, listener); })
-            };
-        });
-    }
-    open() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.isOpen = true;
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.isOpen = false;
-            this.eventEmitter.removeAllListeners();
-        });
-    }
-    emit(tenant, event, indexes) {
-        if (!this.isOpen) {
-            this.errorHandler(new DwnError(DwnErrorCode.EventEmitterStreamNotOpenError, 'a message emitted when EventEmitterStream is closed'));
-            return;
-        }
-        this.eventEmitter.emit(`${tenant}_${EVENTS_LISTENER_CHANNEL}`, tenant, event, indexes);
-    }
-}
-//# sourceMappingURL=event-emitter-stream.js.map

package/dist/esm/src/event-stream/event-emitter-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-emitter-stream.js","sourceRoot":"","sources":["../../../../src/event-stream/event-emitter-stream.ts"],"names":[],"mappings":";;;;;;;;;AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,uBAAuB,GAAG,QAAQ,CAAC;AAQxC,CAAC;AAEF,MAAM,OAAO,kBAAkB;IAI7B,YAAY,SAAmC,EAAE;QAFzC,WAAM,GAAY,KAAK,CAAC;QAkBhC;;WAEG;QACK,iBAAY,GAAwB,CAAC,KAAK,EAAE,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAlBtG,gFAAgF;QAChF,IAAI,CAAC,YAAY,GAAG,IAAI,YAAY,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;QAElE,2EAA2E;QAC3E,yCAAyC;QACzC,6DAA6D;QAC7D,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAErC,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IACnD,CAAC;IAOK,SAAS,CAAC,MAAc,EAAE,EAAU,EAAE,QAAuB;;YACjE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,uBAAuB,EAAE,EAAE,QAAQ,CAAC,CAAC;YACvE,OAAO;gBACL,EAAE;gBACF,KAAK,EAAE,GAAwB,EAAE,gDAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI,uBAAuB,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;aAC/G,CAAC;QACJ,CAAC;KAAA;IAEK,IAAI;;YACR,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;KAAA;IAEK,KAAK;;YACT,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,CAAC;QACzC,CAAC;KAAA;IAED,IAAI,CAAC,MAAc,EAAE,KAAmB,EAAE,OAAkB;QAC1D,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,YAAY,CAAC,IAAI,QAAQ,CAC5B,YAAY,CAAC,8BAA8B,EAC3C,qDAAqD,CACtD,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,uBAAuB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACzF,CAAC;CACF"}