@azure/event-hubs 6.0.2-alpha.20251014.1 → 6.0.2-alpha.20251021.1

package/dist/react-native/partitionPump.js

@@ -0,0 +1,175 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { logErrorStackTrace, logger } from "./logger.js";
+import { CloseReason } from "./models/public.js";
+import { createReceiver } from "./partitionReceiver.js";
+import { toSpanOptions, tracingClient } from "./diagnostics/tracing.js";
+import { extractSpanContextFromEventData } from "./diagnostics/instrumentEventData.js";
+/**
+ * @internal
+ */
+export class PartitionPump {
+    _context;
+    _startPosition;
+    _partitionProcessor;
+    _processorOptions;
+    _receiver;
+    _isReceiving = false;
+    _isStopped = false;
+    _abortController;
+    constructor(_context, partitionProcessor, _startPosition, options) {
+        this._context = _context;
+        this._startPosition = _startPosition;
+        this._partitionProcessor = partitionProcessor;
+        this._processorOptions = options;
+        this._abortController = new AbortController();
+    }
+    get isReceiving() {
+        return this._isReceiving;
+    }
+    async start() {
+        this._isReceiving = true;
+        try {
+            await this._partitionProcessor.initialize();
+        }
+        catch (err) {
+            // swallow the error from the user-defined code
+            this._partitionProcessor.processError(err);
+        }
+        // this is intentionally not await'd - the _receiveEvents loop will continue to
+        // execute and can be stopped by calling .stop()
+        this._receiveEvents(this._partitionProcessor.partitionId);
+        logger.info(`Successfully started the receiver for partition "${this._partitionProcessor.partitionId}".`);
+    }
+    /**
+     * Creates a new `PartitionReceiver` and replaces any existing receiver.
+     * @param partitionId - The partition the receiver should read messages from.
+     * @param lastSeenSequenceNumber - The sequence number to begin receiving messages from (exclusive).
+     * If `-1`, then the PartitionPump's startPosition will be used instead.
+     */
+    _setOrReplaceReceiver(partitionId, lastSeenSequenceNumber) {
+        // Determine what the new EventPosition should be.
+        // If this PartitionPump has received events, we'll start from the last
+        // seen sequenceNumber (exclusive).
+        // Otherwise, use the `_startPosition`.
+        const currentEventPosition = lastSeenSequenceNumber >= 0
+            ? {
+                sequenceNumber: lastSeenSequenceNumber,
+                isInclusive: false,
+            }
+            : this._startPosition;
+        // Set or replace the PartitionPump's receiver.
+        this._receiver = createReceiver(this._context, this._partitionProcessor.consumerGroup, this._partitionProcessor.eventProcessorId, partitionId, currentEventPosition, {
+            ownerLevel: this._processorOptions.ownerLevel,
+            trackLastEnqueuedEventProperties: this._processorOptions.trackLastEnqueuedEventProperties,
+            retryOptions: this._processorOptions.retryOptions,
+            skipParsingBodyAsJson: this._processorOptions.skipParsingBodyAsJson,
+            prefetchCount: this._processorOptions.prefetchCount,
+        });
+        return this._receiver;
+    }
+    async _receiveEvents(partitionId) {
+        let lastSeenSequenceNumber = -1;
+        let receiver = this._setOrReplaceReceiver(partitionId, lastSeenSequenceNumber);
+        while (this._isReceiving) {
+            try {
+                // Check if the receiver was closed so we can recreate it.
+                if (receiver.isClosed) {
+                    receiver = this._setOrReplaceReceiver(partitionId, lastSeenSequenceNumber);
+                }
+                const receivedEvents = await receiver.receiveBatch(this._processorOptions.maxBatchSize, this._processorOptions.maxWaitTimeInSeconds, this._abortController.signal);
+                if (this._processorOptions.trackLastEnqueuedEventProperties &&
+                    receiver.lastEnqueuedEventProperties) {
+                    this._partitionProcessor.lastEnqueuedEventProperties =
+                        receiver.lastEnqueuedEventProperties;
+                }
+                // avoid calling user's processEvents handler if the pump was stopped while receiving events
+                if (!this._isReceiving) {
+                    return;
+                }
+                if (receivedEvents.length) {
+                    lastSeenSequenceNumber = receivedEvents[receivedEvents.length - 1].sequenceNumber;
+                }
+                await tracingClient.withSpan("PartitionPump.process", {}, () => this._partitionProcessor.processEvents(receivedEvents), toProcessingSpanOptions(receivedEvents, this._context.config));
+            }
+            catch (err) {
+                // check if this pump is still receiving
+                // it may not be if the EventProcessor was stopped during processEvents
+                if (!this._isReceiving) {
+                    // no longer receiving, so close was called from somewhere else
+                    return;
+                }
+                logger.warning(`An error was thrown while receiving or processing events on partition "${this._partitionProcessor.partitionId}"`);
+                logErrorStackTrace(err);
+                // forward error to user's processError and swallow errors they may throw
+                try {
+                    await this._partitionProcessor.processError(err);
+                }
+                catch (errorFromUser) {
+                    // Using verbose over warning because this error is swallowed.
+                    logger.verbose("An error was thrown by user's processError method: ", errorFromUser);
+                }
+                // close the partition processor if a non-retryable error was encountered
+                if (typeof err !== "object" || !err.retryable) {
+                    try {
+                        // If the exception indicates that the partition was stolen (i.e some other consumer with same ownerlevel
+                        // started consuming the partition), update the closeReason
+                        if (err.code === "ReceiverDisconnectedError") {
+                            return await this.stop(CloseReason.OwnershipLost);
+                        }
+                        // this will close the pump and will break us out of the while loop
+                        return await this.stop(CloseReason.Shutdown);
+                    }
+                    catch (errorFromStop) {
+                        // Using verbose over warning because this error is swallowed.
+                        logger.verbose(`An error occurred while closing the receiver with reason ${CloseReason.Shutdown}: `, errorFromStop);
+                    }
+                }
+            }
+        }
+    }
+    async stop(reason) {
+        if (this._isStopped) {
+            return;
+        }
+        this._isStopped = true;
+        this._isReceiving = false;
+        try {
+            // Trigger the cancellation before closing the receiver,
+            // otherwise the receiver will remove the listener on the abortSignal
+            // before it has a chance to be emitted.
+            this._abortController.abort();
+            await this._receiver?.close();
+            await this._partitionProcessor.close(reason);
+        }
+        catch (err) {
+            logger.warning(`An error occurred while closing the receiver: ${err?.name}: ${err?.message}`);
+            logErrorStackTrace(err);
+            this._partitionProcessor.processError(err);
+            throw err;
+        }
+    }
+}
+/**
+ * @internal
+ */
+export function toProcessingSpanOptions(receivedEvents, eventHubProperties) {
+    const spanLinks = [];
+    for (const receivedEvent of receivedEvents) {
+        const tracingContext = extractSpanContextFromEventData(receivedEvent);
+        if (tracingContext) {
+            spanLinks.push({
+                tracingContext,
+                attributes: {
+                    enqueuedTime: receivedEvent.enqueuedTimeUtc.getTime(),
+                },
+            });
+        }
+    }
+    return {
+        spanLinks,
+        spanKind: "consumer",
+        ...toSpanOptions(eventHubProperties, "process"),
+    };
+}
+//# sourceMappingURL=partitionPump.js.map

package/dist/react-native/partitionPump.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionPump.js","sourceRoot":"","sources":["../../src/partitionPump.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { TracingSpanOptions, TracingSpanLink } from \"@azure/core-tracing\";\nimport { logErrorStackTrace, logger } from \"./logger.js\";\nimport { CloseReason } from \"./models/public.js\";\nimport type { CommonEventProcessorOptions } from \"./models/private.js\";\nimport type { ConnectionContext } from \"./connectionContext.js\";\nimport type { EventHubConnectionConfig } from \"./eventhubConnectionConfig.js\";\nimport type { PartitionReceiver } from \"./partitionReceiver.js\";\nimport { createReceiver } from \"./partitionReceiver.js\";\nimport type { EventPosition } from \"./eventPosition.js\";\nimport type { MessagingError } from \"@azure/core-amqp\";\nimport type { PartitionProcessor } from \"./partitionProcessor.js\";\nimport type { ReceivedEventData } from \"./eventData.js\";\nimport { toSpanOptions, tracingClient } from \"./diagnostics/tracing.js\";\nimport { extractSpanContextFromEventData } from \"./diagnostics/instrumentEventData.js\";\n\n/**\n * @internal\n */\nexport class PartitionPump {\n  private _partitionProcessor: PartitionProcessor;\n  private _processorOptions: CommonEventProcessorOptions;\n  private _receiver: PartitionReceiver | undefined;\n  private _isReceiving: boolean = false;\n  private _isStopped: boolean = false;\n  private _abortController: AbortController;\n  constructor(\n    private _context: ConnectionContext,\n    partitionProcessor: PartitionProcessor,\n    private readonly _startPosition: EventPosition,\n    options: CommonEventProcessorOptions,\n  ) {\n    this._partitionProcessor = partitionProcessor;\n    this._processorOptions = options;\n    this._abortController = new AbortController();\n  }\n\n  public get isReceiving(): boolean {\n    return this._isReceiving;\n  }\n\n  async start(): Promise<void> {\n    this._isReceiving = true;\n    try {\n      await this._partitionProcessor.initialize();\n    } catch (err) {\n      // swallow the error from the user-defined code\n      this._partitionProcessor.processError(err as Error);\n    }\n\n    // this is intentionally not await'd - the _receiveEvents loop will continue to\n    // execute and can be stopped by calling .stop()\n    this._receiveEvents(this._partitionProcessor.partitionId);\n    logger.info(\n      `Successfully started the receiver for partition \"${this._partitionProcessor.partitionId}\".`,\n    );\n  }\n\n  /**\n   * Creates a new `PartitionReceiver` and replaces any existing receiver.\n   * @param partitionId - The partition the receiver should read messages from.\n   * @param lastSeenSequenceNumber - The sequence number to begin receiving messages from (exclusive).\n   * If `-1`, then the PartitionPump's startPosition will be used instead.\n   */\n  private _setOrReplaceReceiver(\n    partitionId: string,\n    lastSeenSequenceNumber: number,\n  ): PartitionReceiver {\n    // Determine what the new EventPosition should be.\n    // If this PartitionPump has received events, we'll start from the last\n    // seen sequenceNumber (exclusive).\n    // Otherwise, use the `_startPosition`.\n    const currentEventPosition: EventPosition =\n      lastSeenSequenceNumber >= 0\n        ? {\n            sequenceNumber: lastSeenSequenceNumber,\n            isInclusive: false,\n          }\n        : this._startPosition;\n\n    // Set or replace the PartitionPump's receiver.\n    this._receiver = createReceiver(\n      this._context,\n      this._partitionProcessor.consumerGroup,\n      this._partitionProcessor.eventProcessorId,\n      partitionId,\n      currentEventPosition,\n      {\n        ownerLevel: this._processorOptions.ownerLevel,\n        trackLastEnqueuedEventProperties: this._processorOptions.trackLastEnqueuedEventProperties,\n        retryOptions: this._processorOptions.retryOptions,\n        skipParsingBodyAsJson: this._processorOptions.skipParsingBodyAsJson,\n        prefetchCount: this._processorOptions.prefetchCount,\n      },\n    );\n\n    return this._receiver;\n  }\n\n  private async _receiveEvents(partitionId: string): Promise<void> {\n    let lastSeenSequenceNumber = -1;\n    let receiver = this._setOrReplaceReceiver(partitionId, lastSeenSequenceNumber);\n\n    while (this._isReceiving) {\n      try {\n        // Check if the receiver was closed so we can recreate it.\n        if (receiver.isClosed) {\n          receiver = this._setOrReplaceReceiver(partitionId, lastSeenSequenceNumber);\n        }\n\n        const receivedEvents = await receiver.receiveBatch(\n          this._processorOptions.maxBatchSize,\n          this._processorOptions.maxWaitTimeInSeconds,\n          this._abortController.signal,\n        );\n\n        if (\n          this._processorOptions.trackLastEnqueuedEventProperties &&\n          receiver.lastEnqueuedEventProperties\n        ) {\n          this._partitionProcessor.lastEnqueuedEventProperties =\n            receiver.lastEnqueuedEventProperties;\n        }\n        // avoid calling user's processEvents handler if the pump was stopped while receiving events\n        if (!this._isReceiving) {\n          return;\n        }\n\n        if (receivedEvents.length) {\n          lastSeenSequenceNumber = receivedEvents[receivedEvents.length - 1].sequenceNumber;\n        }\n\n        await tracingClient.withSpan(\n          \"PartitionPump.process\",\n          {},\n          () => this._partitionProcessor.processEvents(receivedEvents),\n          toProcessingSpanOptions(receivedEvents, this._context.config),\n        );\n      } catch (err: any) {\n        // check if this pump is still receiving\n        // it may not be if the EventProcessor was stopped during processEvents\n        if (!this._isReceiving) {\n          // no longer receiving, so close was called from somewhere else\n          return;\n        }\n\n        logger.warning(\n          `An error was thrown while receiving or processing events on partition \"${this._partitionProcessor.partitionId}\"`,\n        );\n        logErrorStackTrace(err);\n        // forward error to user's processError and swallow errors they may throw\n        try {\n          await this._partitionProcessor.processError(err as Error);\n        } catch (errorFromUser) {\n          // Using verbose over warning because this error is swallowed.\n          logger.verbose(\"An error was thrown by user's processError method: \", errorFromUser);\n        }\n\n        // close the partition processor if a non-retryable error was encountered\n        if (typeof err !== \"object\" || !(err as MessagingError).retryable) {\n          try {\n            // If the exception indicates that the partition was stolen (i.e some other consumer with same ownerlevel\n            // started consuming the partition), update the closeReason\n            if (err.code === \"ReceiverDisconnectedError\") {\n              return await this.stop(CloseReason.OwnershipLost);\n            }\n            // this will close the pump and will break us out of the while loop\n            return await this.stop(CloseReason.Shutdown);\n          } catch (errorFromStop) {\n            // Using verbose over warning because this error is swallowed.\n            logger.verbose(\n              `An error occurred while closing the receiver with reason ${CloseReason.Shutdown}: `,\n              errorFromStop,\n            );\n          }\n        }\n      }\n    }\n  }\n\n  async stop(reason: CloseReason): Promise<void> {\n    if (this._isStopped) {\n      return;\n    }\n    this._isStopped = true;\n    this._isReceiving = false;\n    try {\n      // Trigger the cancellation before closing the receiver,\n      // otherwise the receiver will remove the listener on the abortSignal\n      // before it has a chance to be emitted.\n      this._abortController.abort();\n      await this._receiver?.close();\n      await this._partitionProcessor.close(reason);\n    } catch (err: any) {\n      logger.warning(`An error occurred while closing the receiver: ${err?.name}: ${err?.message}`);\n      logErrorStackTrace(err);\n      this._partitionProcessor.processError(err);\n      throw err;\n    }\n  }\n}\n\n/**\n * @internal\n */\nexport function toProcessingSpanOptions(\n  receivedEvents: ReceivedEventData[],\n  eventHubProperties: Pick<EventHubConnectionConfig, \"entityPath\" | \"host\">,\n): TracingSpanOptions {\n  const spanLinks: TracingSpanLink[] = [];\n  for (const receivedEvent of receivedEvents) {\n    const tracingContext = extractSpanContextFromEventData(receivedEvent);\n    if (tracingContext) {\n      spanLinks.push({\n        tracingContext,\n        attributes: {\n          enqueuedTime: receivedEvent.enqueuedTimeUtc.getTime(),\n        },\n      });\n    }\n  }\n  return {\n    spanLinks,\n    spanKind: \"consumer\",\n    ...toSpanOptions(eventHubProperties, \"process\"),\n  };\n}\n"]}

package/dist/react-native/partitionReceiver.d.ts

@@ -0,0 +1,82 @@
+import type { AbortSignalLike } from "@azure/abort-controller";
+import type { MessagingError } from "@azure/core-amqp";
+import type { ReceivedEventData } from "./eventData.js";
+import type { EventPosition } from "./eventPosition.js";
+import type { ConnectionContext } from "./connectionContext.js";
+import type { PartitionReceiverOptions } from "./models/private.js";
+type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/** @internal */
+export type WritableReceiver = Writable<PartitionReceiver>;
+/**
+ * A set of information about the last enqueued event of a partition, as observed by the consumer as
+ * events are received from the Event Hubs service
+ */
+export interface LastEnqueuedEventProperties {
+    /**
+     * The sequence number of the event that was last enqueued into the Event Hub partition from which
+     * this event was received.
+     */
+    sequenceNumber?: number;
+    /**
+     * The date and time, in UTC, that the last event was enqueued into the Event Hub partition from
+     * which this event was received.
+     */
+    enqueuedOn?: Date;
+    /**
+     * The offset of the event that was last enqueued into the Event Hub partition from which
+     * this event was received.
+     */
+    offset?: string;
+    /**
+     * The date and time, in UTC, that the last event was retrieved from the Event Hub partition.
+     */
+    retrievedOn?: Date;
+}
+/** @internal */
+export interface PartitionReceiver {
+    readonly checkpoint: number;
+    readonly lastEnqueuedEventProperties: LastEnqueuedEventProperties;
+    readonly isClosed: boolean;
+    readonly close: () => Promise<void>;
+    readonly abort: () => Promise<void>;
+    readonly isOpen: () => boolean;
+    readonly receiveBatch: (maxMessageCount: number, maxWaitTimeInSeconds?: number, abortSignal?: AbortSignalLike) => Promise<ReceivedEventData[]>;
+    /** Needed for tests only */
+    readonly _onError?: (error: MessagingError | Error) => void;
+    readonly connect: (options: ConnectOptions) => Promise<void>;
+}
+interface ConnectOptions {
+    abortSignal: AbortSignalLike | undefined;
+    timeoutInMs: number;
+}
+/** @internal */
+export declare function createReceiver(ctx: ConnectionContext, consumerGroup: string, consumerId: string, partitionId: string, eventPosition: EventPosition, options?: PartitionReceiverOptions): PartitionReceiver;
+/**
+ * @internal
+ */
+export declare function checkOnInterval(waitTimeInMs: number, check: () => boolean, options?: {
+    abortSignal?: AbortSignalLike;
+    cleanupBeforeAbort?: () => void;
+    abortErrorMsg?: string;
+}): Promise<void>;
+/**
+ * Returns a promise that will resolve when it is time to read from the queue
+ * @param maxEventCount - The maximum number of events to receive.
+ * @param maxWaitTimeInMs - The maximum time to wait in ms for the queue to contain any events.
+ * @param readIntervalWaitTimeInMs - The time interval to wait in ms before checking the queue.
+ * @param queue - The queue to read from.
+ * @param options - The options bag.
+ * @returns a promise that will resolve when it is time to read from the queue
+ * @internal
+ */
+export declare function waitForEvents(maxEventCount: number, maxWaitTimeInMs: number, readIntervalWaitTimeInMs: number, queue: unknown[], options?: {
+    abortSignal?: AbortSignalLike;
+    cleanupBeforeAbort?: () => void;
+    receivedAfterWait?: () => void;
+    receivedAlready?: () => void;
+    receivedNone?: () => void;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=partitionReceiver.d.ts.map

package/dist/react-native/partitionReceiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionReceiver.d.ts","sourceRoot":"","sources":["../../src/partitionReceiver.ts"],"names":[],"mappings":"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"}

package/dist/react-native/partitionReceiver.js

@@ -0,0 +1,335 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { AbortError } from "@azure/abort-controller";
+import { Constants, RetryOperationType, StandardAbortMessage, retry, translate, } from "@azure/core-amqp";
+import { types } from "rhea-promise";
+import { fromRheaMessage } from "./eventData.js";
+import { getEventPositionFilter } from "./eventPosition.js";
+import { createSimpleLogger, logErrorStackTrace, logObj, logger as azureLogger, createReceiverLogPrefix, } from "./logger.js";
+import { getRetryAttemptTimeoutInMs } from "./util/retries.js";
+import { createAbortablePromise } from "@azure/core-util";
+import { getRandomName } from "./util/utils.js";
+import { withAuth } from "./withAuth.js";
+import { geoReplication, receiverIdPropertyName } from "./util/constants.js";
+const abortLogMessage = "operation has been cancelled by the user";
+/** The time to wait in ms before attempting to read from the queue */
+const qReadIntervalInMs = 20;
+/** @internal */
+export function createReceiver(ctx, consumerGroup, consumerId, partitionId, eventPosition, options = {}) {
+    const address = ctx.config.getReceiverAddress(partitionId, consumerGroup);
+    const name = getRandomName(address);
+    const audience = ctx.config.getReceiverAudience(partitionId, consumerGroup);
+    const logPrefix = createReceiverLogPrefix(consumerId, ctx.connectionId, partitionId);
+    const logger = createSimpleLogger(azureLogger, logPrefix);
+    const queue = [];
+    const state = {
+        isConnecting: false,
+    };
+    const obj = {
+        _onError: undefined,
+        checkpoint: -1,
+        lastEnqueuedEventProperties: {},
+        isClosed: false,
+        close: async () => {
+            clearHandlers(obj);
+            delete ctx.receivers[name];
+            logger.verbose("deleted the receiver from the client cache");
+            state.authLoop?.stop();
+            return state.link
+                ?.close()
+                .catch((err) => {
+                logger.warning(`an error occurred while closing: ${err?.name}: ${err?.message}`);
+                logErrorStackTrace(err);
+                throw err;
+            })
+                .finally(() => {
+                obj.isClosed = true;
+                logger.verbose("is closed");
+                state.link = undefined;
+                state.authLoop = undefined;
+            });
+        },
+        abort: () => {
+            obj._onError?.(new AbortError(StandardAbortMessage));
+            logger.info(abortLogMessage);
+            return obj.close();
+        },
+        isOpen: () => {
+            const isOpen = !!state.link?.isOpen();
+            logger.verbose(`is open? -> ${isOpen}`);
+            return isOpen;
+        },
+        async connect({ abortSignal, timeoutInMs }) {
+            if (state.isConnecting || obj.isOpen()) {
+                return;
+            }
+            state.isConnecting = true;
+            logger.verbose("is trying to connect");
+            try {
+                await ctx.readyToOpenLink({ abortSignal });
+                state.authLoop = await withAuth(() => setupLink(consumerId, ctx, name, address, obj, state, queue, eventPosition, logger, options, abortSignal), ctx, audience, timeoutInMs, logger, {
+                    abortSignal,
+                });
+            }
+            catch (err) {
+                state.isConnecting = false;
+                const error = translate(err);
+                logger.error(`an error occurred while creating the receiver: ${error?.name}: ${error?.message}`);
+                logErrorStackTrace(err);
+                throw error;
+            }
+        },
+        receiveBatch: (maxMessageCount, maxWaitTimeInSeconds = 60, abortSignal) => {
+            const prefetchCount = options.prefetchCount ?? maxMessageCount * 3;
+            const cleanupBeforeAbort = () => {
+                logger.info(abortLogMessage);
+                return obj.close();
+            };
+            const retrieveEvents = () => {
+                const eventsToRetrieveCount = Math.max(maxMessageCount - queue.length, 0);
+                logger.verbose(`already has ${queue.length} events and wants to receive ${eventsToRetrieveCount} more events`);
+                if (abortSignal?.aborted) {
+                    cleanupBeforeAbort();
+                    return Promise.reject(new AbortError(StandardAbortMessage));
+                }
+                return obj.isClosed || ctx.wasConnectionCloseCalled || eventsToRetrieveCount === 0
+                    ? Promise.resolve(queue.splice(0, maxMessageCount))
+                    : new Promise((resolve, reject) => {
+                        obj._onError = reject;
+                        obj // eslint-disable-line promise/catch-or-return
+                            .connect({
+                            abortSignal,
+                            timeoutInMs: getRetryAttemptTimeoutInMs(options.retryOptions),
+                        })
+                            .then(() => {
+                            addCredits(state.link, Math.max(prefetchCount, maxMessageCount) - queue.length);
+                            logger.verbose(`setting the max wait time to ${maxWaitTimeInSeconds} seconds`);
+                            return waitForEvents(maxMessageCount, maxWaitTimeInSeconds * 1000, qReadIntervalInMs, queue, {
+                                abortSignal,
+                                cleanupBeforeAbort,
+                                receivedAfterWait: () => logger.info(`${Math.min(maxMessageCount, queue.length)} messages received within ${maxWaitTimeInSeconds} seconds`),
+                                receivedAlready: () => logger.info(`${maxMessageCount} messages already received`),
+                                receivedNone: () => logger.info(`no messages received when max wait time in seconds ${maxWaitTimeInSeconds} is over`),
+                            });
+                        })
+                            .catch(reject)
+                            .then(resolve);
+                    })
+                        .then(() => queue.splice(0, maxMessageCount))
+                        .finally(() => clearHandlers(obj));
+            };
+            return retry(Object.defineProperties({
+                operation: retrieveEvents,
+                operationType: RetryOperationType.receiveMessage,
+                abortSignal: abortSignal,
+                retryOptions: options.retryOptions ?? {},
+            }, {
+                connectionId: {
+                    enumerable: true,
+                    get: () => ctx.connectionId,
+                },
+                connectionHost: {
+                    enumerable: true,
+                    get: () => ctx.config.host,
+                },
+            }));
+        },
+    };
+    return obj;
+}
+function delay(waitTimeInMs, options) {
+    let token;
+    return createAbortablePromise((resolve) => {
+        token = setTimeout(resolve, waitTimeInMs);
+    }, options).finally(() => clearTimeout(token));
+}
+/**
+ * @internal
+ */
+export function checkOnInterval(waitTimeInMs, check, options) {
+    let token;
+    return createAbortablePromise((resolve) => {
+        token = setInterval(() => {
+            if (check()) {
+                resolve();
+            }
+        }, waitTimeInMs);
+    }, options).finally(() => clearInterval(token));
+}
+/**
+ * Returns a promise that will resolve when it is time to read from the queue
+ * @param maxEventCount - The maximum number of events to receive.
+ * @param maxWaitTimeInMs - The maximum time to wait in ms for the queue to contain any events.
+ * @param readIntervalWaitTimeInMs - The time interval to wait in ms before checking the queue.
+ * @param queue - The queue to read from.
+ * @param options - The options bag.
+ * @returns a promise that will resolve when it is time to read from the queue
+ * @internal
+ */
+export function waitForEvents(maxEventCount, maxWaitTimeInMs, readIntervalWaitTimeInMs, queue, options = {}) {
+    const { abortSignal: clientAbortSignal, cleanupBeforeAbort, receivedNone, receivedAfterWait, receivedAlready, } = options;
+    if (queue.length >= maxEventCount) {
+        return Promise.resolve().then(receivedAlready);
+    }
+    const aborter = new AbortController();
+    const abortListener = () => {
+        aborter.abort();
+    };
+    clientAbortSignal?.addEventListener("abort", abortListener);
+    let cleanupBeforeAbortCalled = false;
+    const updatedOptions = {
+        abortSignal: aborter.signal,
+        abortErrorMsg: StandardAbortMessage,
+        cleanupBeforeAbort: () => {
+            if (clientAbortSignal?.aborted && !cleanupBeforeAbortCalled) {
+                cleanupBeforeAbort?.();
+                cleanupBeforeAbortCalled = true;
+            }
+        },
+    };
+    return Promise.race([
+        checkOnInterval(readIntervalWaitTimeInMs, () => queue.length > 0, updatedOptions)
+            .then(() => delay(readIntervalWaitTimeInMs, updatedOptions))
+            .then(receivedAfterWait),
+        delay(maxWaitTimeInMs, updatedOptions).then(receivedNone),
+    ]).finally(() => {
+        aborter.abort();
+        clientAbortSignal?.removeEventListener("abort", abortListener);
+    });
+}
+function convertAMQPMesage(data) {
+    const rawMessage = data.getRawAmqpMessage();
+    const receivedEventData = {
+        body: data.body,
+        properties: data.properties,
+        offset: data.offset,
+        sequenceNumber: data.sequenceNumber,
+        enqueuedTimeUtc: data.enqueuedTimeUtc,
+        partitionKey: data.partitionKey,
+        systemProperties: data.systemProperties,
+        getRawAmqpMessage() {
+            return rawMessage;
+        },
+    };
+    if (data.correlationId != null) {
+        receivedEventData.correlationId = data.correlationId;
+    }
+    if (data.contentType != null) {
+        receivedEventData.contentType = data.contentType;
+    }
+    if (data.messageId != null) {
+        receivedEventData.messageId = data.messageId;
+    }
+    return receivedEventData;
+}
+function setEventProps(eventProps, data) {
+    eventProps.sequenceNumber = data.lastSequenceNumber;
+    eventProps.enqueuedOn = data.lastEnqueuedTime;
+    eventProps.offset = data.lastEnqueuedOffset;
+    eventProps.retrievedOn = data.retrievalTime;
+}
+function clearHandlers(obj) {
+    obj._onError = undefined;
+}
+function onMessage(context, obj, queue, options) {
+    if (!context.message) {
+        return;
+    }
+    const data = fromRheaMessage(context.message, !!options.skipParsingBodyAsJson);
+    const receivedEventData = convertAMQPMesage(data);
+    obj.checkpoint = receivedEventData.sequenceNumber;
+    if (options.trackLastEnqueuedEventProperties) {
+        setEventProps(obj.lastEnqueuedEventProperties, data);
+    }
+    queue.push(receivedEventData);
+}
+function onError(context, obj, receiver, logger) {
+    const rheaReceiver = receiver || context.receiver;
+    const amqpError = rheaReceiver?.error;
+    logger.verbose(`'receiver_error' event occurred: ${logObj(amqpError)}`);
+    if (obj._onError && amqpError) {
+        const error = translate(amqpError);
+        logErrorStackTrace(error);
+        obj._onError(error);
+    }
+}
+function onSessionError(context, obj, logger) {
+    const sessionError = context.session?.error;
+    logger.verbose(`'session_error' event occurred: ${logObj(sessionError)}`);
+    if (obj._onError && sessionError) {
+        const error = translate(sessionError);
+        logErrorStackTrace(error);
+        obj._onError(error);
+    }
+}
+function onClose(context, state, logger) {
+    const rheaReceiver = state.link || context.receiver;
+    logger.verbose(`'receiver_close' event occurred. Value for isItselfClosed on the receiver is: '${rheaReceiver
+        ?.isItselfClosed()
+        .toString()}' Value for isConnecting on the session is: '${state.isConnecting}'`);
+    if (rheaReceiver && !state.isConnecting) {
+        rheaReceiver.close().catch((err) => {
+            logger.verbose(`error when closing after 'receiver_close' event: ${logObj(err)}`);
+        });
+    }
+}
+function onSessionClose(context, state, logger) {
+    const rheaReceiver = state.link || context.receiver;
+    logger.verbose(`'session_close' event occurred. Value for isSessionItselfClosed on the session is: '${rheaReceiver
+        ?.isSessionItselfClosed()
+        .toString()}' Value for isConnecting on the session is: '${state.isConnecting}'`);
+    if (rheaReceiver && !state.isConnecting) {
+        rheaReceiver.close().catch((err) => {
+            logger.verbose(`error when closing after 'session_close' event: ${logObj(err)}`);
+        });
+    }
+}
+function createRheaOptions(consumerId, name, address, obj, state, queue, eventPosition, logger, options) {
+    const rheaOptions = {
+        name,
+        autoaccept: true,
+        target: consumerId,
+        source: {
+            address,
+        },
+        credit_window: 0,
+        properties: {
+            [receiverIdPropertyName]: consumerId,
+        },
+        onClose: (context) => onClose(context, state, logger),
+        onSessionClose: (context) => onSessionClose(context, state, logger),
+        onError: (context) => onError(context, obj, state.link, logger),
+        onMessage: (context) => onMessage(context, obj, queue, options),
+        onSessionError: (context) => onSessionError(context, obj, logger),
+    };
+    const ownerLevel = options.ownerLevel;
+    if (typeof ownerLevel === "number") {
+        rheaOptions.properties[Constants.attachEpoch] = types.wrap_long(ownerLevel);
+    }
+    rheaOptions.desired_capabilities = [geoReplication];
+    if (options.trackLastEnqueuedEventProperties) {
+        rheaOptions.desired_capabilities.push(Constants.enableReceiverRuntimeMetricName);
+    }
+    const filterClause = getEventPositionFilter(obj.checkpoint > -1 ? { sequenceNumber: obj.checkpoint } : eventPosition);
+    rheaOptions.source.filter = {
+        "apache.org:selector-filter:string": types.wrap_described(filterClause, 0x468c00000004),
+    };
+    return rheaOptions;
+}
+async function setupLink(consumerId, ctx, name, address, obj, state, queue, eventPosition, logger, options, abortSignal) {
+    const rheaOptions = createRheaOptions(consumerId, name, address, obj, state, queue, eventPosition, logger, options);
+    logger.verbose(`trying to be created with options ${logObj(rheaOptions)}`);
+    state.link = await ctx.connection.createReceiver({
+        ...rheaOptions,
+        abortSignal,
+    });
+    state.isConnecting = false;
+    logger.verbose("is created successfully");
+    ctx.receivers[name] = obj;
+}
+function addCredits(receiver, creditsToAdd) {
+    if (creditsToAdd > 0) {
+        receiver?.addCredit(creditsToAdd);
+    }
+}
+//# sourceMappingURL=partitionReceiver.js.map