@azure/service-bus 7.6.0-beta.2 → 7.6.0

package/dist/index.js

@@ -105,6 +105,11 @@ const receiverLogger = createServiceBusLogger("service-bus:receiver");
  * @internal
  */
 const senderLogger = createServiceBusLogger("service-bus:sender");
+/**
+ * Logging for ServiceBusRuleManagers
+ * @internal
+ */
+const ruleManagerLogger = createServiceBusLogger("service-bus:rulemanager");
 /**
  * Logging for connection management
  * @internal
@@ -176,7 +181,7 @@ function isError(err) {
  */
 const packageJsonInfo = {
     name: "@azure/service-bus",
-    version: "7.6.0-beta.2",
+    version: "7.6.0",
 };
 /**
  * @internal
@@ -5359,6 +5364,16 @@ const errorInvalidMessageTypeSingleOrArray = "Provided value for 'messages' must
 const errorInvalidMessageTypeSingle = "Provided value for 'message' must be of type: ServiceBusMessage or AmqpAnnotatedMessage.";
 
 // Copyright (c) Microsoft Corporation.
+/**
+ * @internal
+ */
+const sqlRuleProperties = ["sqlExpression"];
+function isSqlRuleFilter(obj) {
+    if (obj) {
+        return sqlRuleProperties.some((validProperty) => isObjectWithProperties(obj, [validProperty]));
+    }
+    return false;
+}
 /**
  * @internal
  */
@@ -5373,6 +5388,12 @@ const correlationProperties = [
     "contentType",
     "applicationProperties",
 ];
+function isCorrelationRuleFilter(obj) {
+    if (obj) {
+        return correlationProperties.some((validProperty) => isObjectWithProperties(obj, [validProperty]));
+    }
+    return false;
+}
 /**
  * @internal
  * Describes the ServiceBus Management Client that talks
@@ -5458,6 +5479,18 @@ class ManagementClient extends LinkEntity {
             ? data[index].value
             : undefined;
     }
+    _decodeApplicationPropertiesMap(obj) {
+        if (!rheaPromise.types.is_map(obj)) {
+            throw new Error("object to decode is not of Map types");
+        }
+        const array = obj.value;
+        const result = {};
+        for (let i = 0; i < array.length; i += 2) {
+            const key = array[i].value;
+            result[key] = array[i + 1].value;
+        }
+        return result;
+    }
     async _makeManagementRequest(request, internalLogger, sendRequestOptions = {}) {
         var _a;
         if (request.message_id === undefined) {
@@ -5531,10 +5564,11 @@ class ManagementClient extends LinkEntity {
      * also fetch even Deferred messages (but not Deadlettered message).
      *
      * @param messageCount - The number of messages to retrieve. Default value `1`.
+     * @param omitMessageBody - Whether to omit message body when peeking. Default value `false`.
      */
-    async peek(messageCount, options) {
+    async peek(messageCount, omitMessageBody, options) {
         throwErrorIfConnectionClosed(this._context);
-        return this.peekBySequenceNumber(this._lastPeekedSequenceNumber.add(1), messageCount, undefined, options);
+        return this.peekBySequenceNumber(this._lastPeekedSequenceNumber.add(1), messageCount, undefined, omitMessageBody, options);
     }
     /**
      * Fetches the next batch of active messages in the current MessageSession. The first call to
@@ -5547,10 +5581,11 @@ class ManagementClient extends LinkEntity {
      *
      * @param sessionId - The sessionId from which messages need to be peeked.
      * @param messageCount - The number of messages to retrieve. Default value `1`.
+     * @param omitMessageBody - Whether to omit message body when peeking Default value `false`.
      */
-    async peekMessagesBySession(sessionId, messageCount, options) {
+    async peekMessagesBySession(sessionId, messageCount, omitMessageBody, options) {
         throwErrorIfConnectionClosed(this._context);
-        return this.peekBySequenceNumber(this._lastPeekedSequenceNumber.add(1), messageCount, sessionId, options);
+        return this.peekBySequenceNumber(this._lastPeekedSequenceNumber.add(1), messageCount, sessionId, omitMessageBody, options);
     }
     /**
      * Peeks the desired number of messages from the specified sequence number.
@@ -5558,8 +5593,9 @@ class ManagementClient extends LinkEntity {
      * @param fromSequenceNumber - The sequence number from where to read the message.
      * @param messageCount - The number of messages to retrieve. Default value `1`.
      * @param sessionId - The sessionId from which messages need to be peeked.
+     * @param omitMessageBody - Whether to omit message body when peeking. Default value `false`.
      */
-    async peekBySequenceNumber(fromSequenceNumber, maxMessageCount, sessionId, options) {
+    async peekBySequenceNumber(fromSequenceNumber, maxMessageCount, sessionId, omitMessageBody, options) {
         var _a;
         throwErrorIfConnectionClosed(this._context);
         const connId = this._context.connectionId;
@@ -5580,6 +5616,10 @@ class ManagementClient extends LinkEntity {
             if (isDefined(sessionId)) {
                 messageBody[coreAmqp.Constants.sessionIdMapKey] = sessionId;
             }
+            if (isDefined(omitMessageBody)) {
+                const omitMessageBodyKey = "omit-message-body"; // TODO: Service Bus specific. Put it somewhere
+                messageBody[omitMessageBodyKey] = rheaPromise.types.wrap_boolean(omitMessageBody);
+            }
             const request = {
                 body: messageBody,
                 reply_to: this.replyTo,
@@ -6063,8 +6103,10 @@ class ManagementClient extends LinkEntity {
         try {
             const request = {
                 body: {
-                    top: rheaPromise.types.wrap_int(max32BitNumber),
-                    skip: rheaPromise.types.wrap_int(0),
+                    top: (options === null || options === void 0 ? void 0 : options.maxCount)
+                        ? rheaPromise.types.wrap_int(options.maxCount)
+                        : rheaPromise.types.wrap_int(max32BitNumber),
+                    skip: (options === null || options === void 0 ? void 0 : options.skip) ? rheaPromise.types.wrap_int(options.skip) : rheaPromise.types.wrap_int(0),
                 },
                 reply_to: this.replyTo,
                 application_properties: {
@@ -6084,6 +6126,7 @@ class ManagementClient extends LinkEntity {
             const rules = [];
             result.forEach((x) => {
                 const ruleDescriptor = x["rule-description"];
+                let filter;
                 // We use the first three elements of the `ruleDescriptor.value` to get filter, action, name
                 if (!ruleDescriptor ||
                     !ruleDescriptor.descriptor ||
@@ -6094,21 +6137,35 @@ class ManagementClient extends LinkEntity {
                 }
                 const filtersRawData = ruleDescriptor.value[0];
                 const actionsRawData = ruleDescriptor.value[1];
-                const rule = {
-                    name: ruleDescriptor.value[2].value,
-                };
+                let sqlRuleAction;
+                if (actionsRawData.descriptor.value === coreAmqp.Constants.descriptorCodes.sqlRuleActionList &&
+                    Array.isArray(actionsRawData.value) &&
+                    actionsRawData.value.length) {
+                    sqlRuleAction = {
+                        sqlExpression: this._safelyGetTypedValueFromArray(actionsRawData.value, 0),
+                    };
+                }
+                else {
+                    sqlRuleAction = {};
+                }
                 switch (filtersRawData.descriptor.value) {
                     case coreAmqp.Constants.descriptorCodes.trueFilterList:
-                        rule.filter = "1=1";
+                        filter = {
+                            sqlExpression: "1=1",
+                        };
                         break;
                     case coreAmqp.Constants.descriptorCodes.falseFilterList:
-                        rule.filter = "1=0";
+                        filter = {
+                            sqlExpression: "1=0",
+                        };
                         break;
                     case coreAmqp.Constants.descriptorCodes.sqlFilterList:
-                        rule.filter = this._safelyGetTypedValueFromArray(filtersRawData.value, 0);
+                        filter = {
+                            sqlExpression: this._safelyGetTypedValueFromArray(filtersRawData.value, 0),
+                        };
                         break;
                     case coreAmqp.Constants.descriptorCodes.correlationFilterList:
-                        rule.filter = {
+                        filter = {
                             correlationId: this._safelyGetTypedValueFromArray(filtersRawData.value, 0),
                             messageId: this._safelyGetTypedValueFromArray(filtersRawData.value, 1),
                             to: this._safelyGetTypedValueFromArray(filtersRawData.value, 2),
@@ -6117,18 +6174,21 @@ class ManagementClient extends LinkEntity {
                             sessionId: this._safelyGetTypedValueFromArray(filtersRawData.value, 5),
                             replyToSessionId: this._safelyGetTypedValueFromArray(filtersRawData.value, 6),
                             contentType: this._safelyGetTypedValueFromArray(filtersRawData.value, 7),
-                            applicationProperties: this._safelyGetTypedValueFromArray(filtersRawData.value, 8),
+                            applicationProperties: Array.isArray(filtersRawData.value) &&
+                                filtersRawData.value.length > 8 &&
+                                filtersRawData.value[8]
+                                ? this._decodeApplicationPropertiesMap(filtersRawData.value[8])
+                                : undefined,
                         };
                         break;
                     default:
-                        managementClientLogger.warning(`${this.logPrefix} Found unexpected descriptor code for the filter: ${filtersRawData.descriptor.value}`);
-                        break;
-                }
-                if (actionsRawData.descriptor.value === coreAmqp.Constants.descriptorCodes.sqlRuleActionList &&
-                    Array.isArray(actionsRawData.value) &&
-                    actionsRawData.value.length) {
-                    rule.action = this._safelyGetTypedValueFromArray(actionsRawData.value, 0);
+                        throw new Error(`${this.logPrefix} Found unexpected descriptor code for the filter: ${filtersRawData.descriptor.value}`);
                 }
+                const rule = {
+                    name: ruleDescriptor.value[2].value,
+                    filter,
+                    action: sqlRuleAction,
+                };
                 rules.push(rule);
             });
             return rules;
@@ -6179,37 +6239,28 @@ class ManagementClient extends LinkEntity {
         ruleName = String(ruleName);
         throwTypeErrorIfParameterIsEmptyString(this._context.connectionId, "ruleName", ruleName);
         throwTypeErrorIfParameterMissing(this._context.connectionId, "filter", filter);
-        if (typeof filter !== "boolean" &&
-            typeof filter !== "string" &&
-            !correlationProperties.some((validProperty) => isObjectWithProperties(filter, [validProperty]))) {
-            throw new TypeError(`The parameter "filter" should be either a boolean, string or implement the CorrelationRuleFilter interface.`);
+        if (!isSqlRuleFilter(filter) && !isCorrelationRuleFilter(filter)) {
+            throw new TypeError(`The parameter "filter" should implement either the SqlRuleFilter or the CorrelationRuleFilter interface.`);
         }
         try {
             const ruleDescription = {};
-            switch (typeof filter) {
-                case "boolean":
-                    ruleDescription["sql-filter"] = {
-                        expression: filter ? "1=1" : "1=0",
-                    };
-                    break;
-                case "string":
-                    ruleDescription["sql-filter"] = {
-                        expression: filter,
-                    };
-                    break;
-                default:
-                    ruleDescription["correlation-filter"] = {
-                        "correlation-id": filter.correlationId,
-                        "message-id": filter.messageId,
-                        to: filter.to,
-                        "reply-to": filter.replyTo,
-                        subject: filter.subject,
-                        "session-id": filter.sessionId,
-                        "reply-to-session-id": filter.replyToSessionId,
-                        "content-type": filter.contentType,
-                        applicationProperties: filter.applicationProperties,
-                    };
-                    break;
+            if (isSqlRuleFilter(filter)) {
+                ruleDescription["sql-filter"] = {
+                    expression: filter.sqlExpression,
+                };
+            }
+            else {
+                ruleDescription["correlation-filter"] = {
+                    "correlation-id": filter.correlationId,
+                    "message-id": filter.messageId,
+                    to: filter.to,
+                    "reply-to": filter.replyTo,
+                    label: filter.subject,
+                    "session-id": filter.sessionId,
+                    "reply-to-session-id": filter.replyToSessionId,
+                    "content-type": filter.contentType,
+                    properties: filter.applicationProperties,
+                };
             }
             if (sqlRuleActionExpression !== undefined) {
                 ruleDescription["sql-rule-action"] = {
@@ -8432,12 +8483,12 @@ class ServiceBusReceiverImpl {
             if (options.fromSequenceNumber) {
                 return this._context
                     .getManagementClient(this.entityPath)
-                    .peekBySequenceNumber(options.fromSequenceNumber, maxMessageCount, undefined, managementRequestOptions);
+                    .peekBySequenceNumber(options.fromSequenceNumber, maxMessageCount, undefined, options.omitMessageBody, managementRequestOptions);
             }
             else {
                 return this._context
                     .getManagementClient(this.entityPath)
-                    .peek(maxMessageCount, managementRequestOptions);
+                    .peek(maxMessageCount, options.omitMessageBody, managementRequestOptions);
             }
         };
         const config = {
@@ -8740,12 +8791,12 @@ class ServiceBusSessionReceiverImpl {
             if (options.fromSequenceNumber) {
                 return this._context
                     .getManagementClient(this.entityPath)
-                    .peekBySequenceNumber(options.fromSequenceNumber, maxMessageCount, this.sessionId, managementRequestOptions);
+                    .peekBySequenceNumber(options.fromSequenceNumber, maxMessageCount, this.sessionId, options.omitMessageBody, managementRequestOptions);
             }
             else {
                 return this._context
                     .getManagementClient(this.entityPath)
-                    .peekMessagesBySession(this.sessionId, maxMessageCount, managementRequestOptions);
+                    .peekMessagesBySession(this.sessionId, maxMessageCount, options.omitMessageBody, managementRequestOptions);
             }
         };
         const config = {
@@ -8915,6 +8966,208 @@ class ServiceBusSessionReceiverImpl {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * @internal
+ */
+class ServiceBusRuleManagerImpl {
+    /**
+     * @internal
+     * @throws Error if the underlying connection is closed.
+     */
+    constructor(_context, _entityPath, _retryOptions = {}) {
+        this._context = _context;
+        this._entityPath = _entityPath;
+        this._retryOptions = _retryOptions;
+        /**
+         * Denotes if close() was called on this sender
+         */
+        this._isClosed = false;
+        throwErrorIfConnectionClosed(_context);
+        this.entityPath = _entityPath;
+        this.name = getUniqueName("ruleManager");
+    }
+    get isClosed() {
+        return this._isClosed || this._context.wasConnectionCloseCalled;
+    }
+    async createRule(ruleName, filter, ruleActionOrOperationOptions, options) {
+        let sqlRuleAction = undefined;
+        let operOptions;
+        if (ruleActionOrOperationOptions) {
+            if (isSqlRuleAction(ruleActionOrOperationOptions)) {
+                // Overload#2 - where the sqlExpression in the ruleAction is defined
+                sqlRuleAction = ruleActionOrOperationOptions;
+                operOptions = options;
+            }
+            else {
+                // Overload#1 - where the sqlExpression in the ruleAction is undefined
+                operOptions = Object.assign(Object.assign({}, ruleActionOrOperationOptions), options);
+            }
+        }
+        const { span } = createServiceBusSpan("ServiceBusRuleManager.createRule", operOptions, this.entityPath, this._context.config.host, {
+            kind: coreTracing.SpanKind.CLIENT,
+        });
+        try {
+            const addRuleOperationPromise = async () => {
+                return this._context
+                    .getManagementClient(this._entityPath)
+                    .addRule(ruleName, filter, sqlRuleAction === null || sqlRuleAction === void 0 ? void 0 : sqlRuleAction.sqlExpression, Object.assign(Object.assign({}, operOptions), { associatedLinkName: this.name, requestName: "addRule", timeoutInMs: this._retryOptions.timeoutInMs }));
+            };
+            const config = {
+                operation: addRuleOperationPromise,
+                connectionId: this._context.connectionId,
+                operationType: coreAmqp.RetryOperationType.management,
+                retryOptions: this._retryOptions,
+                abortSignal: operOptions === null || operOptions === void 0 ? void 0 : operOptions.abortSignal,
+            };
+            const result = coreAmqp.retry(config);
+            span.setStatus({ code: coreTracing.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: coreTracing.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Get all rules associated with the subscription.
+     */
+    async getRules(options) {
+        const { span } = createServiceBusSpan("ServiceBusRuleManager.getRules", options, this.entityPath, this._context.config.host, {
+            kind: coreTracing.SpanKind.CLIENT,
+        });
+        try {
+            const getRulesOperationPromise = async () => {
+                return this._context.getManagementClient(this._entityPath).getRules(Object.assign(Object.assign({}, options), { associatedLinkName: this.name, requestName: "getRules", timeoutInMs: this._retryOptions.timeoutInMs }));
+            };
+            const config = {
+                operation: getRulesOperationPromise,
+                connectionId: this._context.connectionId,
+                operationType: coreAmqp.RetryOperationType.management,
+                retryOptions: this._retryOptions,
+                abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,
+            };
+            const result = coreAmqp.retry(config);
+            span.setStatus({ code: coreTracing.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: coreTracing.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    listRulesPage(marker, options = {}) {
+        var _a;
+        return tslib.__asyncGenerator(this, arguments, function* listRulesPage_1() {
+            do {
+                const rules = yield tslib.__await(this.getRules(Object.assign({ skip: Number(marker), maxCount: (_a = options.maxPageSize) !== null && _a !== void 0 ? _a : 100 }, options)));
+                if (rules.length > 0) {
+                    yield yield tslib.__await(rules);
+                    marker = String(Number(marker !== null && marker !== void 0 ? marker : 0) + rules.length);
+                }
+                else {
+                    break;
+                }
+            } while (marker);
+        });
+    }
+    listRulesAll(options = {}) {
+        return tslib.__asyncGenerator(this, arguments, function* listRulesAll_1() {
+            var e_1, _a;
+            let marker;
+            try {
+                for (var _b = tslib.__asyncValues(this.listRulesPage(marker, options)), _c; _c = yield tslib.__await(_b.next()), !_c.done;) {
+                    const segment = _c.value;
+                    yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(segment)));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield tslib.__await(_a.call(_b));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    /**
+     * Returns an async iterable iterator to list all the rules
+     * under the specified subscription.
+     *
+     * .byPage() returns an async iterable iterator to list the rules in pages.
+     *
+     * @returns An asyncIterableIterator that supports paging.
+     */
+    listRules(
+    // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+    options) {
+        ruleManagerLogger.verbose(`Performing operation - listRules() with options: %j`, options);
+        const iter = this.listRulesAll(options);
+        return {
+            /**
+             */
+            next() {
+                return iter.next();
+            },
+            /**
+             */
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            /**
+             */
+            byPage: (settings = {}) => {
+                return this.listRulesPage(undefined, Object.assign({ maxPageSize: settings.maxPageSize }, options));
+            },
+        };
+    }
+    /**
+     * Deletes a rule.
+     */
+    async deleteRule(ruleName, options) {
+        const { span } = createServiceBusSpan("ServiceBusRuleManager.deleteRule", options, this.entityPath, this._context.config.host, {
+            kind: coreTracing.SpanKind.CLIENT,
+        });
+        try {
+            const removeRuleOperationPromise = async () => {
+                return this._context.getManagementClient(this._entityPath).removeRule(ruleName, Object.assign(Object.assign({}, options), { associatedLinkName: this.name, requestName: "removeRule", timeoutInMs: this._retryOptions.timeoutInMs }));
+            };
+            const config = {
+                operation: removeRuleOperationPromise,
+                connectionId: this._context.connectionId,
+                operationType: coreAmqp.RetryOperationType.management,
+                retryOptions: this._retryOptions,
+                abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,
+            };
+            const result = coreAmqp.retry(config);
+            span.setStatus({ code: coreTracing.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: coreTracing.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * @internal
@@ -10132,6 +10385,19 @@ class ServiceBusClient {
             : 5 * 60 * 1000;
         return new ServiceBusReceiverImpl(this._connectionContext, entityPathWithSubQueue, receiveMode, maxLockAutoRenewDurationInMs, (_a = options === null || options === void 0 ? void 0 : options.skipParsingBodyAsJson) !== null && _a !== void 0 ? _a : false, this._clientOptions.retryOptions);
     }
+    /**
+     * Creates an instance of {@link ServiceBusRuleManager} that is used to manage
+     * the rules for a subscription.
+     *
+     * @param topicName - the topic to create {@link ServiceBusRuleManager}
+     * @param subscriptionName - the subscription specific to the specified topic to create a {@link ServiceBusRuleManager} for.
+     * @returns a {@link ServiceBusRuleManager} scoped to the specified subscription and topic.
+     */
+    createRuleManager(topicName, subscriptionName) {
+        validateEntityPath(this._connectionContext.config, topicName);
+        const { entityPath } = extractReceiverArguments(topicName, subscriptionName);
+        return new ServiceBusRuleManagerImpl(this._connectionContext, entityPath, this._clientOptions.retryOptions);
+    }
     async acceptSession(queueOrTopicName1, optionsOrSubscriptionNameOrSessionId2, optionsOrSessionId3, 
     // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
     options4) {