@azure/event-hubs 5.12.1-alpha.20240604.1 → 5.12.1

package/dist/browser/eventHubConsumerClientModels.d.ts

@@ -0,0 +1,218 @@
+import { CloseReason } from "./models/public.js";
+import { EventPosition } from "./eventPosition.js";
+import { LastEnqueuedEventProperties } from "./partitionReceiver.js";
+import { MessagingError } from "@azure/core-amqp";
+import { OperationTracingOptions } from "@azure/core-tracing";
+import { ReceivedEventData } from "./eventData.js";
+/**
+ * @internal
+ */
+export interface BasicPartitionProperties {
+    /**
+     * The fully qualified Event Hubs namespace. This is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     */
+    fullyQualifiedNamespace: string;
+    /**
+     * The event hub name.
+     */
+    eventHubName: string;
+    /**
+     * The consumer group name.
+     */
+    consumerGroup: string;
+    /**
+     * The identifier of the Event Hub partition.
+     */
+    partitionId: string;
+}
+/**
+ * Interface that describes the context passed to each of the functions that are a part
+ * of the `SubscriptionEventHandlers`. When implementing any of these functions, use
+ * the context object to get information about the partition as well as the
+ * ability to checkpoint.
+ */
+export interface PartitionContext {
+    /**
+     * The fully qualified Event Hubs namespace. This is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     */
+    readonly fullyQualifiedNamespace: string;
+    /**
+     * The event hub name.
+     */
+    readonly eventHubName: string;
+    /**
+     * The consumer group name.
+     */
+    readonly consumerGroup: string;
+    /**
+     * The identifier of the Event Hub partition.
+     */
+    readonly partitionId: string;
+    /**
+     * Information on the last enqueued event in the partition that is being processed.
+     * This property is only updated if the `trackLastEnqueuedEventProperties` option is set to true
+     * when creating an instance of EventProcessor.
+     * @readonly
+     */
+    readonly lastEnqueuedEventProperties?: LastEnqueuedEventProperties;
+    /**
+     * Updates the checkpoint using the event data.
+     *
+     * A checkpoint is meant to represent the last successfully processed event by the user from a particular
+     * partition of a consumer group in an Event Hub instance.
+     *
+     * @param eventData - The event that you want to update the checkpoint with.
+     */
+    updateCheckpoint(eventData: ReceivedEventData): Promise<void>;
+}
+/**
+ * Signature of the user provided function invoked by `EventHubConsumerClient` when a set of events is received.
+ */
+export type ProcessEventsHandler = (events: ReceivedEventData[], context: PartitionContext) => Promise<void>;
+/**
+ * Signature of the user provided function invoked by `EventHubConsumerClient` for errors that occur when
+ * receiving events or when executing any of the user provided functions passed to the `subscribe()` method.
+ */
+export type ProcessErrorHandler = (error: Error | MessagingError, context: PartitionContext) => Promise<void>;
+/**
+ * Signature of the user provided function invoked by `EventHubConsumerClient` just before starting to receive
+ * events from a partition.
+ */
+export type ProcessInitializeHandler = (context: PartitionContext) => Promise<void>;
+/**
+ * Signature of the user provided function invoked by `EventHubConsumerClient` just after stopping to receive
+ * events from a partition.
+ */
+export type ProcessCloseHandler = (reason: CloseReason, context: PartitionContext) => Promise<void>;
+/**
+ * Interface that describes the functions to be implemented by the user which are invoked by
+ * the `EventHubConsumerClient` when the `subscribe()` method is called to receive events
+ * from Event Hub.
+ */
+export interface SubscriptionEventHandlers {
+    /**
+     * The function invoked by `EventHubConsumerClient` when a set of events is received. The
+     * `PartitionContext` passed to this function can be used to determine which partition is being read from.
+     *
+     * The `updateCheckpoint()` method on the context can be used to update checkpoints in the `CheckpointStore`
+     * (if one was provided to the client). Use this in frequent intervals to mark events that have been processed
+     * so that the client can restart from such checkpoints in the event of a restart or error recovery.
+     *
+     * Note: It is possible for received events to be an empty array.
+     * This can happen if there are no new events to receive
+     * in the `maxWaitTimeInSeconds`, which is defaulted to 60 seconds.
+     * The `maxWaitTimeInSeconds` can be changed by setting
+     * it in the `options` passed to `subscribe()`.
+     */
+    processEvents: ProcessEventsHandler;
+    /**
+     * The function invoked by `EventHubConsumerClient` for errors that occur when receiving events
+     * or when executing any of the user provided functions passed to the `subscribe()` method.
+     *
+     * The `PartitionContext` passed to this function will indicate the partition that was being processed
+     * when the error was thrown. In cases where an error is thrown outside of processing events from a
+     * partition(e.g. failure to perform load balancing), the `partitionId` on the context will be an empty string.
+     *
+     * After the client completes executing this function, the `partitionClose` function is invoked.
+     */
+    processError: ProcessErrorHandler;
+    /**
+     * The function invoked by `EventHubConsumerClient` each time the subscription is about to begin
+     * reading from a partition. The `PartitionContext` passed to this function can be used to determine
+     * which partition is about to be read from.
+     *
+     * The client will start receiving events for the partition only after completing the execution of
+     * this function (if provided). Therefore, use this function to carry out any setup work including
+     * async tasks.
+     */
+    processInitialize?: ProcessInitializeHandler;
+    /**
+     * The function invoked by `EventHubConsumerClient` each time the subscription stops reading events from
+     * a partition. The information on this partition will be available on the `PartitionContext` passed to the
+     * function `processClose`.
+     *
+     * If the `CloseReason` passed to this function is `OwnershipLost`, then another subscription has taken over
+     * reading from the same partition using the same consumer group. This is expected if you have multiple
+     * instances of your application running and have passed the `CheckpointStore` to the client to load balance.
+     *
+     * If the `CloseReason` is `Shutdown`, this indicates that either `subscription.close()` was called, or an
+     * error occured. Unless the subscription was explicitly closed via `subscription.close()`, the subscription
+     * will attempt to resume reading events from the last checkpoint for the partition.
+     */
+    processClose?: ProcessCloseHandler;
+}
+/**
+ * Options to configure the `subscribe` method on the `EventHubConsumerClient`.
+ * For example, `{ maxBatchSize: 20, maxWaitTimeInSeconds: 120, startPosition: { sequenceNumber: 123 } }`
+ */
+export interface SubscribeOptions {
+    /**
+     * The number of events to request per batch
+     */
+    maxBatchSize?: number;
+    /**
+     * The maximum amount of time to wait to build up the requested message count before
+     * passing the data to user code for processing. If not provided, it defaults to 60 seconds.
+     */
+    maxWaitTimeInSeconds?: number;
+    /**
+     * The event position in a partition to start receiving events from if no checkpoint is found.
+     * Pass a map of partition id to position if you would like to use different starting
+     * position for each partition.
+     */
+    startPosition?: EventPosition | {
+        [partitionId: string]: EventPosition;
+    };
+    /**
+     * Indicates whether or not the consumer should request information on the last enqueued event on its
+     * associated partition, and track that information as events are received.
+  
+     * When information about the partition's last enqueued event is being tracked, each event received
+     * from the Event Hubs service will carry metadata about the partition that it otherwise would not. This results in a small amount of
+     * additional network bandwidth consumption that is generally a favorable trade-off when considered
+     * against periodically making requests for partition properties using the Event Hub client.
+     */
+    trackLastEnqueuedEventProperties?: boolean;
+    /**
+     * The owner level to use as this subscription subscribes to partitions.
+     */
+    ownerLevel?: number;
+    /**
+     * Options for configuring tracing.
+     */
+    tracingOptions?: OperationTracingOptions;
+    /**
+     * Option to disable the client from running JSON.parse() on the message body when receiving the message.
+     * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you
+     * prefer to work directly with the bytes present in the message body than have the client attempt to parse it.
+     */
+    skipParsingBodyAsJson?: boolean;
+    /**
+     * The count of events requested eagerly and queued without regard to whether a read was requested.
+     */
+    prefetchCount?: number;
+}
+/**
+ * Interface that describes the object returned by the `subscribe()` method on the `EventHubConsumerClient`.
+ */
+export interface Subscription {
+    /**
+     * Stops the subscription from receiving more messages.
+     *
+     * If a checkpoint store has been configured this will also mark this subscription's
+     * partitions as abandoned, freeing them up to be read by other consumers.
+     *
+     * @returns Promise<void>
+     * @throws Error if the underlying connection encounters an error while closing.
+     */
+    close(): Promise<void>;
+    /**
+     * Indicates whether the receiver is running.
+     * `true` - is running; `false` otherwise.
+     * @readonly
+     */
+    isRunning: boolean;
+}
+//# sourceMappingURL=eventHubConsumerClientModels.d.ts.map

package/dist/browser/eventHubConsumerClientModels.d.ts.map

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

package/dist/browser/eventHubConsumerClientModels.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=eventHubConsumerClientModels.js.map

package/dist/browser/eventHubConsumerClientModels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventHubConsumerClientModels.js","sourceRoot":"","sources":["../../src/eventHubConsumerClientModels.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { CloseReason } from \"./models/public.js\";\nimport { EventPosition } from \"./eventPosition.js\";\nimport { LastEnqueuedEventProperties } from \"./partitionReceiver.js\";\nimport { MessagingError } from \"@azure/core-amqp\";\nimport { OperationTracingOptions } from \"@azure/core-tracing\";\nimport { ReceivedEventData } from \"./eventData.js\";\n\n/**\n * @internal\n */\nexport interface BasicPartitionProperties {\n  /**\n   * The fully qualified Event Hubs namespace. This is likely to be similar to\n   * <yournamespace>.servicebus.windows.net\n   */\n  fullyQualifiedNamespace: string;\n  /**\n   * The event hub name.\n   */\n  eventHubName: string;\n  /**\n   * The consumer group name.\n   */\n  consumerGroup: string;\n  /**\n   * The identifier of the Event Hub partition.\n   */\n  partitionId: string;\n}\n\n/**\n * Interface that describes the context passed to each of the functions that are a part\n * of the `SubscriptionEventHandlers`. When implementing any of these functions, use\n * the context object to get information about the partition as well as the\n * ability to checkpoint.\n */\nexport interface PartitionContext {\n  /**\n   * The fully qualified Event Hubs namespace. This is likely to be similar to\n   * <yournamespace>.servicebus.windows.net\n   */\n  readonly fullyQualifiedNamespace: string;\n  /**\n   * The event hub name.\n   */\n  readonly eventHubName: string;\n  /**\n   * The consumer group name.\n   */\n  readonly consumerGroup: string;\n  /**\n   * The identifier of the Event Hub partition.\n   */\n  readonly partitionId: string;\n  /**\n   * Information on the last enqueued event in the partition that is being processed.\n   * This property is only updated if the `trackLastEnqueuedEventProperties` option is set to true\n   * when creating an instance of EventProcessor.\n   * @readonly\n   */\n  readonly lastEnqueuedEventProperties?: LastEnqueuedEventProperties;\n  /**\n   * Updates the checkpoint using the event data.\n   *\n   * A checkpoint is meant to represent the last successfully processed event by the user from a particular\n   * partition of a consumer group in an Event Hub instance.\n   *\n   * @param eventData - The event that you want to update the checkpoint with.\n   */\n  updateCheckpoint(eventData: ReceivedEventData): Promise<void>;\n}\n\n/**\n * Signature of the user provided function invoked by `EventHubConsumerClient` when a set of events is received.\n */\nexport type ProcessEventsHandler = (\n  events: ReceivedEventData[],\n  context: PartitionContext,\n) => Promise<void>;\n\n/**\n * Signature of the user provided function invoked by `EventHubConsumerClient` for errors that occur when\n * receiving events or when executing any of the user provided functions passed to the `subscribe()` method.\n */\nexport type ProcessErrorHandler = (\n  error: Error | MessagingError,\n  context: PartitionContext,\n) => Promise<void>;\n\n/**\n * Signature of the user provided function invoked by `EventHubConsumerClient` just before starting to receive\n * events from a partition.\n */\nexport type ProcessInitializeHandler = (context: PartitionContext) => Promise<void>;\n\n/**\n * Signature of the user provided function invoked by `EventHubConsumerClient` just after stopping to receive\n * events from a partition.\n */\nexport type ProcessCloseHandler = (reason: CloseReason, context: PartitionContext) => Promise<void>;\n\n/**\n * Interface that describes the functions to be implemented by the user which are invoked by\n * the `EventHubConsumerClient` when the `subscribe()` method is called to receive events\n * from Event Hub.\n */\nexport interface SubscriptionEventHandlers {\n  /**\n   * The function invoked by `EventHubConsumerClient` when a set of events is received. The\n   * `PartitionContext` passed to this function can be used to determine which partition is being read from.\n   *\n   * The `updateCheckpoint()` method on the context can be used to update checkpoints in the `CheckpointStore`\n   * (if one was provided to the client). Use this in frequent intervals to mark events that have been processed\n   * so that the client can restart from such checkpoints in the event of a restart or error recovery.\n   *\n   * Note: It is possible for received events to be an empty array.\n   * This can happen if there are no new events to receive\n   * in the `maxWaitTimeInSeconds`, which is defaulted to 60 seconds.\n   * The `maxWaitTimeInSeconds` can be changed by setting\n   * it in the `options` passed to `subscribe()`.\n   */\n  processEvents: ProcessEventsHandler;\n  /**\n   * The function invoked by `EventHubConsumerClient` for errors that occur when receiving events\n   * or when executing any of the user provided functions passed to the `subscribe()` method.\n   *\n   * The `PartitionContext` passed to this function will indicate the partition that was being processed\n   * when the error was thrown. In cases where an error is thrown outside of processing events from a\n   * partition(e.g. failure to perform load balancing), the `partitionId` on the context will be an empty string.\n   *\n   * After the client completes executing this function, the `partitionClose` function is invoked.\n   */\n  processError: ProcessErrorHandler;\n  /**\n   * The function invoked by `EventHubConsumerClient` each time the subscription is about to begin\n   * reading from a partition. The `PartitionContext` passed to this function can be used to determine\n   * which partition is about to be read from.\n   *\n   * The client will start receiving events for the partition only after completing the execution of\n   * this function (if provided). Therefore, use this function to carry out any setup work including\n   * async tasks.\n   */\n  processInitialize?: ProcessInitializeHandler;\n  /**\n   * The function invoked by `EventHubConsumerClient` each time the subscription stops reading events from\n   * a partition. The information on this partition will be available on the `PartitionContext` passed to the\n   * function `processClose`.\n   *\n   * If the `CloseReason` passed to this function is `OwnershipLost`, then another subscription has taken over\n   * reading from the same partition using the same consumer group. This is expected if you have multiple\n   * instances of your application running and have passed the `CheckpointStore` to the client to load balance.\n   *\n   * If the `CloseReason` is `Shutdown`, this indicates that either `subscription.close()` was called, or an\n   * error occured. Unless the subscription was explicitly closed via `subscription.close()`, the subscription\n   * will attempt to resume reading events from the last checkpoint for the partition.\n   */\n  processClose?: ProcessCloseHandler;\n}\n\n/**\n * Options to configure the `subscribe` method on the `EventHubConsumerClient`.\n * For example, `{ maxBatchSize: 20, maxWaitTimeInSeconds: 120, startPosition: { sequenceNumber: 123 } }`\n */\nexport interface SubscribeOptions {\n  /**\n   * The number of events to request per batch\n   */\n  maxBatchSize?: number;\n  /**\n   * The maximum amount of time to wait to build up the requested message count before\n   * passing the data to user code for processing. If not provided, it defaults to 60 seconds.\n   */\n  maxWaitTimeInSeconds?: number;\n  /**\n   * The event position in a partition to start receiving events from if no checkpoint is found.\n   * Pass a map of partition id to position if you would like to use different starting\n   * position for each partition.\n   */\n  startPosition?: EventPosition | { [partitionId: string]: EventPosition };\n  /**\n   * Indicates whether or not the consumer should request information on the last enqueued event on its\n   * associated partition, and track that information as events are received.\n\n   * When information about the partition's last enqueued event is being tracked, each event received\n   * from the Event Hubs service will carry metadata about the partition that it otherwise would not. This results in a small amount of\n   * additional network bandwidth consumption that is generally a favorable trade-off when considered\n   * against periodically making requests for partition properties using the Event Hub client.\n   */\n  trackLastEnqueuedEventProperties?: boolean;\n  /**\n   * The owner level to use as this subscription subscribes to partitions.\n   */\n  ownerLevel?: number;\n  /**\n   * Options for configuring tracing.\n   */\n  tracingOptions?: OperationTracingOptions;\n  /**\n   * Option to disable the client from running JSON.parse() on the message body when receiving the message.\n   * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you\n   * prefer to work directly with the bytes present in the message body than have the client attempt to parse it.\n   */\n  skipParsingBodyAsJson?: boolean;\n  /**\n   * The count of events requested eagerly and queued without regard to whether a read was requested.\n   */\n  prefetchCount?: number;\n}\n\n/**\n * Interface that describes the object returned by the `subscribe()` method on the `EventHubConsumerClient`.\n */\nexport interface Subscription {\n  /**\n   * Stops the subscription from receiving more messages.\n   *\n   * If a checkpoint store has been configured this will also mark this subscription's\n   * partitions as abandoned, freeing them up to be read by other consumers.\n   *\n   * @returns Promise<void>\n   * @throws Error if the underlying connection encounters an error while closing.\n   */\n  close(): Promise<void>;\n  /**\n   * Indicates whether the receiver is running.\n   * `true` - is running; `false` otherwise.\n   * @readonly\n   */\n  isRunning: boolean;\n}\n"]}

package/dist/browser/eventHubProducerClient.d.ts

@@ -0,0 +1,266 @@
+import { CreateBatchOptions, EventHubClientOptions, GetEventHubPropertiesOptions, GetPartitionIdsOptions, GetPartitionPropertiesOptions, SendBatchOptions } from "./models/public.js";
+import { EventDataBatch } from "./eventDataBatch.js";
+import { EventHubProperties, PartitionProperties } from "./managementClient.js";
+import { NamedKeyCredential, SASCredential, TokenCredential } from "@azure/core-auth";
+import { AmqpAnnotatedMessage } from "@azure/core-amqp";
+import { EventData } from "./eventData.js";
+import { OperationOptions } from "./util/operationOptions.js";
+/**
+ * The `EventHubProducerClient` class is used to send events to an Event Hub.
+ *
+ * There are multiple ways to create an `EventHubProducerClient`
+ * - Use the connection string from the SAS policy created for your Event Hub instance.
+ * - Use the connection string from the SAS policy created for your Event Hub namespace,
+ * and the name of the Event Hub instance
+ * - Use the full namespace like `<yournamespace>.servicebus.windows.net`, and a credentials object.
+ *
+ * Optionally, you can also pass an options bag to configure the retry policy or proxy settings.
+ *
+ */
+export declare class EventHubProducerClient {
+    /**
+     * Describes the amqp connection context for the client.
+     */
+    private _context;
+    /**
+     * The options passed by the user when creating the EventHubClient instance.
+     */
+    private _clientOptions;
+    /**
+     * Map of partitionId to senders
+     */
+    private _sendersMap;
+    /**
+     * Indicates whether or not the EventHubProducerClient should enable idempotent publishing to Event Hub partitions.
+     * If enabled, the producer will only be able to publish directly to partitions;
+     * it will not be able to publish to the Event Hubs gateway for automatic partition routing
+     * nor will it be able to use a partition key.
+     * Default: false
+     */
+    private _enableIdempotentRetries?;
+    /**
+     * The set of options that can be specified to influence publishing behavior specific to the configured Event Hub partition.
+     * These options are not necessary in the majority of scenarios and are intended for use with specialized scenarios,
+     * such as when recovering the state used for idempotent publishing.
+     */
+    private _partitionOptions?;
+    /**
+     * @readonly
+     * The name of the Event Hub instance for which this client is created.
+     */
+    get eventHubName(): string;
+    /**
+     * @readonly
+     * The fully qualified namespace of the Event Hub instance for which this client is created.
+     * This is likely to be similar to <yournamespace>.servicebus.windows.net.
+     */
+    get fullyQualifiedNamespace(): string;
+    /**
+     * The name used to identify this EventHubProducerClient.
+     * If not specified or empty, a random unique one will be generated.
+     */
+    readonly identifier: string;
+    /**
+     * The `EventHubProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param connectionString - The connection string to use for connecting to the Event Hub instance.
+     * It is expected that the shared key properties and the Event Hub path are contained in this connection string.
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name'.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(connectionString: string, options?: EventHubClientOptions);
+    /**
+     * The `EventHubProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param connectionString - The connection string to use for connecting to the Event Hubs namespace.
+     * It is expected that the shared key properties are contained in this connection string, but not the Event Hub path,
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;'.
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(connectionString: string, eventHubName: string, options?: EventHubClientOptions);
+    /**
+     * The `EventHubProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param fullyQualifiedNamespace - The full namespace which is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param credential - An credential object used by the client to get the token to authenticate the connection
+     * with the Azure Event Hubs service.
+     * See &commat;azure/identity for creating credentials that support AAD auth.
+     * Use the `AzureNamedKeyCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessKeyName`
+     * and `SharedAccessKey` without using a connection string. These fields map to the `name` and `key` field respectively
+     * in `AzureNamedKeyCredential`.
+     * Use the `AzureSASCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessSignature`
+     * without using a connection string. This field maps to `signature` in `AzureSASCredential`.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(fullyQualifiedNamespace: string, eventHubName: string, credential: TokenCredential | NamedKeyCredential | SASCredential, options?: EventHubClientOptions);
+    /**
+     * Creates an instance of `EventDataBatch` to which one can add events until the maximum supported size is reached.
+     * The batch can be passed to the {@link sendBatch} method of the `EventHubProducerClient` to be sent to Azure Event Hubs.
+     *
+     * Events with different values for partitionKey or partitionId will need to be put into different batches.
+     * To simplify such batch management across partitions or to have the client automatically batch events
+     * and send them in specific intervals, use `EventHubBufferedProducerClient` instead.
+     *
+     * The below example assumes you have an array of events at hand to be batched safely.
+     * If you have events coming in one by one, `EventHubBufferedProducerClient` is recommended instead
+     * for effecient management of batches.
+     *
+     * Example usage:
+     * ```ts
+     * const client = new EventHubProducerClient(connectionString);
+     * let batch = await client.createBatch();
+     * for (let i = 0; i < messages.length; i++) {
+     *  if (!batch.tryAdd(messages[i])) {
+     *    await client.sendBatch(batch);
+     *    batch = await client.createBatch();
+     *    if (!batch.tryAdd(messages[i])) {
+     *      throw new Error("Message too big to fit")
+     *    }
+     *    if (i === messages.length - 1) {
+     *      await client.sendBatch(batch);
+     *    }
+     *   }
+     * }
+     * ```
+     *
+     * @param options -  Configures the behavior of the batch.
+     * - `partitionKey`  : A value that is hashed and used by the Azure Event Hubs service to determine the partition to which
+     * the events need to be sent.
+     * - `partitionId`   : Id of the partition to which the batch of events need to be sent.
+     * - `maxSizeInBytes`: The upper limit for the size of batch. The `tryAdd` function will return `false` after this limit is reached.
+     * - `abortSignal`   : A signal the request to cancel the operation.
+     * @returns Promise<EventDataBatch>
+     * @throws Error if both `partitionId` and `partitionKey` are set in the options.
+     * @throws Error if the underlying connection has been closed, create a new EventHubProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal in the options.
+     */
+    createBatch(options?: CreateBatchOptions): Promise<EventDataBatch>;
+    /**
+     * Get the information about the state of publishing for a partition as observed by the `EventHubProducerClient`.
+     * This data can always be read, but will only be populated with information relevant to the active features
+     * for the producer client.
+     *
+     * @param partitionId - Id of the partition from which to retrieve publishing properties.
+     * @param options - The set of options to apply to the operation call.
+     * - `abortSignal`  : A signal the request to cancel the send operation.
+     * @returns Promise<void>
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    private getPartitionPublishingProperties;
+    /**
+     * Sends an array of events as a batch to the associated Event Hub.
+     *
+     * Azure Event Hubs has a limit on the size of the batch that can be sent which if exceeded
+     * will result in an error with code `MessageTooLargeError`.
+     * To safely send within batch size limits, use `EventHubProducerClient.createBatch()` or
+     * `EventHubBufferedProducerClient` instead.
+     *
+     * Example usage:
+     * ```ts
+     * const client = new EventHubProducerClient(connectionString);
+     * await client.sendBatch(messages);
+     * ```
+     *
+     * @param batch - An array of {@link EventData} or `AmqpAnnotatedMessage`.
+     * @param options - A set of options that can be specified to influence the way in which
+     * events are sent to the associated Event Hub.
+     * - `abortSignal`  : A signal the request to cancel the send operation.
+     * - `partitionId`  : The partition this batch will be sent to. If set, `partitionKey` can not be set.
+     * - `partitionKey` : A value that is hashed to produce a partition assignment. If set, `partitionId` can not be set.
+     *
+     * @returns Promise<void>
+     * @throws MessageTooLargeError if all the events in the input array cannot be fit into a batch.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     * @throws MessagingError if an error is encountered while sending a message.
+     * @throws Error if the underlying connection or sender has been closed.
+     */
+    sendBatch(batch: EventData[] | AmqpAnnotatedMessage[], options?: SendBatchOptions): Promise<void>;
+    /**
+     * Sends a batch of events created using `EventHubProducerClient.createBatch()` to the associated Event Hub.
+     *
+     * Events with different values for partitionKey or partitionId will need to be put into different batches.
+     * To simplify such batch management across partitions or to have the client automatically batch events
+     * and send them in specific intervals, use `EventHubBufferedProducerClient` instead.
+     *
+     * The below example assumes you have an array of events at hand to be batched safely.
+     * If you have events coming in one by one, `EventHubBufferedProducerClient` is recommended instead
+     * for effecient management of batches.
+     *
+     * Example usage:
+     * ```ts
+     * const client = new EventHubProducerClient(connectionString);
+     * let batch = await client.createBatch();
+     * for (let i = 0; i < messages.length; i++) {
+     *  if (!batch.tryAdd(messages[i])) {
+     *    await client.sendBatch(batch);
+     *    batch = await client.createBatch();
+     *    if (!batch.tryAdd(messages[i])) {
+     *      throw new Error("Message too big to fit")
+     *    }
+     *    if (i === messages.length - 1) {
+     *      await client.sendBatch(batch);
+     *    }
+     *   }
+     * }
+     * ```
+     * @param batch - A batch of events that you can create using the {@link createBatch} method.
+     * @param options - A set of options that can be specified to influence the way in which
+     * events are sent to the associated Event Hub.
+     * - `abortSignal`  : A signal the request to cancel the send operation.
+     *
+     * @returns Promise<void>
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     * @throws MessagingError if an error is encountered while sending a message.
+     * @throws Error if the underlying connection or sender has been closed.
+     */
+    sendBatch(batch: EventDataBatch, options?: OperationOptions): Promise<void>;
+    /**
+     * Closes the AMQP connection to the Event Hub instance,
+     * returning a promise that will be resolved when disconnection is completed.
+     * @returns Promise<void>
+     * @throws Error if the underlying connection encounters an error while closing.
+     */
+    close(): Promise<void>;
+    /**
+     * Provides the Event Hub runtime information.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the Event Hub instance.
+     * @throws Error if the underlying connection has been closed, create a new EventHubProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getEventHubProperties(options?: GetEventHubPropertiesOptions): Promise<EventHubProperties>;
+    /**
+     * Provides the id for each partition associated with the Event Hub.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with an Array of strings representing the id for
+     * each partition associated with the Event Hub.
+     * @throws Error if the underlying connection has been closed, create a new EventHubProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionIds(options?: GetPartitionIdsOptions): Promise<Array<string>>;
+    /**
+     * Provides information about the state of the specified partition.
+     * @param partitionId - The id of the partition for which information is required.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the state of the partition .
+     * @throws Error if the underlying connection has been closed, create a new EventHubProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionProperties(partitionId: string, options?: GetPartitionPropertiesOptions): Promise<PartitionProperties>;
+}
+//# sourceMappingURL=eventHubProducerClient.d.ts.map

package/dist/browser/eventHubProducerClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventHubProducerClient.d.ts","sourceRoot":"","sources":["../../src/eventHubProducerClient.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,6BAA6B,EAC7B,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,cAAc,EAAwC,MAAM,qBAAqB,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAWtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAqB,SAAS,EAAqB,MAAM,gBAAgB,CAAC;AAEjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAK9D;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAsB;IACjC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAoB;IAEpC;;OAEG;IACH,OAAO,CAAC,cAAc,CAAwB;IAC9C;;OAEG;IACH,OAAO,CAAC,WAAW,CAA8B;IACjD;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB,CAAC,CAAU;IAC3C;;;;OAIG;IACH,OAAO,CAAC,iBAAiB,CAAC,CAA6C;IACvE;;;OAGG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;OAIG;IACH,IAAI,uBAAuB,IAAI,MAAM,CAEpC;IAED;;;OAGG;IACH,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC;;;;;;;;;;;OAWG;gBACS,gBAAgB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IACrE;;;;;;;;;;;;OAYG;gBACS,gBAAgB,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAC3F;;;;;;;;;;;;;;;;;;;OAmBG;gBAED,uBAAuB,EAAE,MAAM,EAC/B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,eAAe,GAAG,kBAAkB,GAAG,aAAa,EAChE,OAAO,CAAC,EAAE,qBAAqB;IA6BjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,cAAc,CAAC;IAiD5E;;;;;;;;;;OAUG;YAGW,gCAAgC;IA2B9C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,SAAS,CACb,KAAK,EAAE,SAAS,EAAE,GAAG,oBAAoB,EAAE,EAC3C,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,IAAI,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8FjF;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;;;;OAMG;IACH,qBAAqB,CAAC,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAO9F;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAW7E;;;;;;;OAOG;IACH,sBAAsB,CACpB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,mBAAmB,CAAC;CAMhC"}

package/{dist-esm/src → dist/browser}/eventHubProducerClient.js

@@ -1,15 +1,16 @@
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-import { createConnectionContext } from "./connectionContext";
-import { EventDataBatchImpl, isEventDataBatch } from "./eventDataBatch";
+// Licensed under the MIT License.
+import { createConnectionContext } from "./connectionContext.js";
+import { EventDataBatchImpl, isEventDataBatch } from "./eventDataBatch.js";
 import { isDefined } from "@azure/core-util";
-import { isCredential } from "./util/typeGuards";
-import { logErrorStackTrace, logger } from "./logger";
-import { idempotentAlreadyPublished, idempotentSomeAlreadyPublished, throwErrorIfConnectionClosed, throwTypeErrorIfParameterMissing, validateProducerPartitionSettings, } from "./util/error";
-import { EventHubSender } from "./eventHubSender";
-import { toSpanOptions, tracingClient } from "./diagnostics/tracing";
-import { instrumentEventData } from "./diagnostics/instrumentEventData";
-import { getRandomName } from "./util/utils";
+import { isCredential } from "./util/typeGuards.js";
+import { logErrorStackTrace, logger } from "./logger.js";
+import { idempotentAlreadyPublished, idempotentSomeAlreadyPublished, throwErrorIfConnectionClosed, throwTypeErrorIfParameterMissing, validateProducerPartitionSettings, } from "./util/error.js";
+import { assertIsEventData } from "./eventData.js";
+import { EventHubSender } from "./eventHubSender.js";
+import { toSpanOptions, tracingClient } from "./diagnostics/tracing.js";
+import { instrumentEventData } from "./diagnostics/instrumentEventData.js";
+import { getRandomName } from "./util/utils.js";
 /**
  * The `EventHubProducerClient` class is used to send events to an Event Hub.
  *
@@ -188,6 +189,7 @@ export class EventHubProducerClient {
             if (!Array.isArray(batch)) {
                 batch = [batch];
             }
+            batch.forEach(assertIsEventData);
             if (batch.some((event) => isDefined(event._publishedSequenceNumber))) {
                 throw new Error(idempotentSomeAlreadyPublished);
             }