@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/AMQP/EventSourcing/synchronization.d.ts

@@ -0,0 +1,39 @@
+export interface ITimestamp {
+    /**
+     * The date represented as timestamp in milliseconds, when the command was processed and all emitted events was created.
+     * More events emitted by the same command will have the same receivedAt timestamp. To determine order of event, see secondaryIndex.
+     * It uses javascript date in ISO8601 format (with Z - zero hour offset always). The only important information is UNIX timestamp in ms.
+     * Timezone offset is overlooked every time because of bad design of JS Date object.
+     */
+    receivedAt: Date;
+    /**
+     * This value differentiate more events created by same command (they have same receivedAt timestamp).
+     * Using this index, you can determine the right order of events in the event store.
+     * Index beginning from 0 and is increased by one for every following event.
+     */
+    secondaryIndex: number;
+}
+/**
+ * @link https://gitlab.com/signageos/services/command-handler/-/blob/master/docs/lock-management-and-event-synchronization.md#lastevents-synchronization-system
+ */
+export interface LastSynchronizationEvents {
+    /**
+     * Last event created by successfully processed command.
+     * The key is the event type, the value is the timestamp and lock keys used for synchronization.
+     * The timestamp can be used to detect synchronization status of consumers.
+     * When event type is missing, it means that no event of that type was created by the command.
+     */
+    [eventType: string]: {
+        /**
+         * Timestamp of the last event created by successfully processed command.
+         * This timestamp can be used to detect synchronization status of consumers.
+         */
+        timestamp: ITimestamp;
+        /**
+         * List of lock keys which are used to lock the event store and event consumers
+         * for the command processing.
+         */
+        lockKeys: string[];
+    };
+}
+export declare function getAllLockKeys(lastEvents: LastSynchronizationEvents): string[];

package/dist/AMQP/EventSourcing/synchronization.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllLockKeys = getAllLockKeys;
+function getAllLockKeys(lastEvents) {
+    var allLockKeys = [];
+    for (var eventType in lastEvents) {
+        var event_1 = lastEvents[eventType];
+        allLockKeys.push.apply(allLockKeys, event_1.lockKeys);
+    }
+    return allLockKeys;
+}
+//# sourceMappingURL=synchronization.js.map

package/dist/AMQP/EventSourcing/synchronization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronization.js","sourceRoot":"","sources":["../../../src/AMQP/EventSourcing/synchronization.ts"],"names":[],"mappings":";;AAwCA,wCAOC;AAPD,SAAgB,cAAc,CAAC,UAAqC;IACnE,IAAM,WAAW,GAAa,EAAE,CAAC;IACjC,KAAK,IAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,IAAM,OAAK,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;QACpC,WAAW,CAAC,IAAI,OAAhB,WAAW,EAAS,OAAK,CAAC,QAAQ,EAAE;IACrC,CAAC;IACD,OAAO,WAAW,CAAC;AACpB,CAAC"}

package/dist/AMQP/Exchange.d.ts

@@ -0,0 +1 @@
+export type ExchangeType = 'fanout' | 'direct' | 'topic' | 'headers';

package/dist/AMQP/Exchange.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Exchange.js.map

package/dist/AMQP/Exchange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Exchange.js","sourceRoot":"","sources":["../../src/AMQP/Exchange.ts"],"names":[],"mappings":""}

package/dist/AMQP/IAMQPPool.d.ts

@@ -0,0 +1,5 @@
+import { Connection } from 'amqplib';
+import IBasePool from '../Pool/IBasePool';
+export default IAMQPPool;
+interface IAMQPPool extends IBasePool<Connection> {
+}

package/dist/AMQP/IAMQPPool.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAMQPPool.js.map

package/dist/AMQP/IAMQPPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAMQPPool.js","sourceRoot":"","sources":["../../src/AMQP/IAMQPPool.ts"],"names":[],"mappings":""}

package/dist/AMQP/IAsyncGotMessage.d.ts

@@ -0,0 +1,15 @@
+import { AmqplibConsumeFields } from './IChannel';
+import INackOptions from './INackOptions';
+/**
+ * An asynchronously acknowledgeable message received from a queue.
+ * The message can be acknowledged (ack) or negatively acknowledged (nack) asynchronously.
+ * Unlike IGotMessage, the ack and nack methods return Promises that resolve when the operation is complete.
+ * The reason is that it can do some cleanup after ack/nack, like closing the channel if no more messages are pending.
+ */
+export interface IAsyncGotMessage<TMessage> {
+    message: TMessage;
+    headers: object;
+    fields: AmqplibConsumeFields;
+    ack: () => Promise<void>;
+    nack: (nackOptions?: INackOptions) => Promise<void>;
+}

package/dist/AMQP/IAsyncGotMessage.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAsyncGotMessage.js.map

package/dist/AMQP/IAsyncGotMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAsyncGotMessage.js","sourceRoot":"","sources":["../../src/AMQP/IAsyncGotMessage.ts"],"names":[],"mappings":""}

package/dist/AMQP/IChannel.d.ts

@@ -0,0 +1,43 @@
+import { Options as AmqplibOptions } from 'amqplib';
+import IMessageOptions from './IMessageOptions';
+import IConsumeOptions from './IConsumeOptions';
+import { ExchangeType } from './Exchange';
+import INackOptions from './INackOptions';
+export type ICancelConsumption = () => Promise<void>;
+export interface AmqplibConsumeFields {
+    redelivered?: boolean;
+}
+export interface IBinding {
+    exchangeName: string;
+    /** persistent=false means that binding is removed when consumption is canceled */
+    persistent: boolean;
+    routingKey?: string;
+    routingHeaders?: {
+        'x-match': 'all' | 'any';
+        [key: string]: any;
+    };
+}
+export interface IGotMessage<TMessage> {
+    message: TMessage;
+    headers: object;
+    fields: AmqplibConsumeFields;
+    ack: () => void;
+    nack: (nackOptions?: INackOptions) => void;
+}
+export default IChannel;
+interface IChannel<TMessage> {
+    assertExchange(exchangeName: string, type: ExchangeType, exchangeOptions?: AmqplibOptions.AssertExchange): Promise<void>;
+    send(message: TMessage, messageOptions: IMessageOptions, headers: object, exchangeName: string, routingKey: string): Promise<void>;
+    sendBatch(messages: TMessage[], messageOptions: IMessageOptions, headers: object, getExchangeName: (message: TMessage) => string, getRoutingKey: (message: TMessage) => string, onMessagePublished: (message: TMessage) => void, batchSize: number): Promise<void>;
+    sendExpectingResponse<TResponseMessage>(message: TMessage, messageOptions: IMessageOptions, headers: object, exchangeName: string, routingKey: string, responseTimeout?: number): Promise<TResponseMessage>;
+    assertRejectableQueue(queueName: string, consumeOptions?: IConsumeOptions): Promise<{
+        messageCount: number;
+    }>;
+    consumeSimple<TResponseMessage>(queueName: string, bindings: IBinding[], onMessage: (message: any, headers: object) => Promise<TResponseMessage>, consumeOptions?: IConsumeOptions, onEnded?: () => void): Promise<ICancelConsumption>;
+    consume<TResponseMessage>(queueName: string, bindings: IBinding[], onMessage: (message: any, headers: object, ack: () => void, nack: () => void, fields: AmqplibConsumeFields) => Promise<TResponseMessage>, consumeOptions?: IConsumeOptions, onEnded?: () => void): Promise<ICancelConsumption>;
+    unbind(queueName: string, binding: IBinding): Promise<void>;
+    get<TPayload>(queueName: string): Promise<IGotMessage<TPayload> | null>;
+    purge(queueName: string): Promise<void>;
+    delete(queueName: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/AMQP/IChannel.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IChannel.js.map

package/dist/AMQP/IChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IChannel.js","sourceRoot":"","sources":["../../src/AMQP/IChannel.ts"],"names":[],"mappings":""}

package/dist/AMQP/IConsumeOptions.d.ts

@@ -0,0 +1,106 @@
+export type QueueType = 'quorum' | 'classic';
+type IAutoDeleteDeadLetterOptions = {
+    /**
+     * Queue is auto deleted when consumption is canceled
+     * For sure, queue is set as x-expires=
+     * This is proprietary option, not amqp or rabbit native
+     */
+    autoDeleteDeadLetter: true;
+    /** Imply true because if consumption is not exclusive it cannot detect no consumer and auto rejecting messages */
+    exclusiveConsumption: true;
+    /**
+     * Cannot be autoDelete because is deleted by application after consumption is canceled after messages are dead-lettered
+     * But all bindings should be persistent=false to make it work properly
+     */
+    autoDelete: false;
+    /** Cannot be exclusive because is deleted by application after consumption is canceled after messages are dead-lettered */
+    exclusive: false;
+    /** Has to have at least deadLetterExchange because otherwise, it can be used just standard amqp autoDelete */
+    deadLetterExchange: string;
+    deadLetterRoutingKey: string;
+    /**
+     * Has to be set to allow delete queue even when amqp connection is closed before application can dead-letter all messages.
+     * Messages have to have shorter expiration than queueExpiresMs to make it work properly
+     */
+    queueExpiresMs: number;
+};
+type IBasicConsumeOptions = {
+    /** Auto delete queue when number of consumers decreased to zero */
+    autoDelete?: boolean;
+    /** Only one consumer can be for queue, after consumption canceled, queue is deleted */
+    exclusive?: boolean;
+    /** Queue is deleted when rabbitmq is restarted (keeps schema in memory only) */
+    durable?: boolean;
+    exclusiveConsumption?: boolean;
+    deadLetterExchange?: string;
+    deadLetterRoutingKey?: string;
+    /**
+     * When message was already nacked (requeue: true), then next consumption will be delayed by number of milliseconds
+     * @deprecated Use messageExpiresMs in dead-letter queue instead. This option is misused and should not exists.
+     */
+    redeliverDelayMs?: number;
+    /**
+     * Whether first simple consumption error should not be thrown (just nacked for next redeliver)
+     * @deprecated Use deadLetterIfErred instead. The suppressFirstError is misused and should not exists.
+     */
+    suppressFirstError?: boolean;
+    /**
+     * If flag is set, the message will be rejected with requeue=false in case
+     * the message was redelivered already and now the error was thrown
+     * @deprecated Use deadLetterIfErred instead. The suppressFirstError is misused and should not exists.
+     */
+    deadLetterIfRedeliveredAndErred?: boolean;
+    /**
+     * It will immediately dead-letter the message if the error is thrown during the consumption
+     * Unlike deadLetterIfRedeliveredAndErred, it does not care about redelivered flag and dead-letters immediately
+     */
+    deadLetterIfErred?: boolean;
+    /** If respond is set, the consumption will reply response message if replyTo parameter is set in coming message. Default false */
+    respond?: boolean;
+    /** Define how long the queue will exists without consumer until is automatically deleted (RabbitMQ feature only) */
+    queueExpiresMs?: number;
+    /**
+     * Define how long can be the messages in the queue until they are automatically rejected (dead-lettered).
+     * Internally used header 'x-message-ttl'.
+     * It can be set also as 'expiration' attribute of every message. See IMessageOptions.
+     */
+    messageExpiresMs?: number;
+    /**
+     * Defines if a queue is allowed to be consumed by only one single consumer at the same time (RabbitMQ 3.8+ feature only)
+     * https://www.rabbitmq.com/consumers.html#single-active-consumer
+     */
+    singleActiveConsumer?: boolean;
+    /**
+     * Detect whether the queue is the quorum type or classic.
+     * Quorum is better option for consistency of message of durable queue.
+     * Default is classic.
+     */
+    queueType?: QueueType;
+    /**
+     * When is true, all messages are acknowledged immediately after client populate them.
+     * There is not need to call ack() method on message.
+     */
+    noAck?: boolean;
+    /**
+     * Limit the number of messages in the queue.
+     * When the limit is reached, the oldest messages are handled by the overflow policy.
+     * If overflow is not set, the default policy is to drop the oldest messages.
+     */
+    maxLength?: number;
+    /**
+     * Internally used header 'x-overflow'.
+     * Sets the strategy for handling messages when the queue reaches its maximum length @see `maxLength`.
+     * The default policy is to drop the oldest messages.
+     * The other options are:
+     * - `reject-publish`: Reject the message and do not publish it to the queue.
+     * - `reject-publish-dlx`: Reject the message and publish it to the dead-letter exchange.
+     * - `drop-head`: Drop the oldest message in the queue.
+     */
+    overflow?: 'reject-publish' | 'reject-publish-dlx' | 'drop-head';
+};
+type IQuorumOptions = IBasicConsumeOptions & {
+    durable: true;
+    queueType: 'quorum';
+};
+type IConsumeOptions = IBasicConsumeOptions | IQuorumOptions | (IBasicConsumeOptions & IAutoDeleteDeadLetterOptions) | (IQuorumOptions & IAutoDeleteDeadLetterOptions);
+export default IConsumeOptions;

package/dist/AMQP/IConsumeOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IConsumeOptions.js.map

package/dist/AMQP/IConsumeOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IConsumeOptions.js","sourceRoot":"","sources":["../../src/AMQP/IConsumeOptions.ts"],"names":[],"mappings":""}

package/dist/AMQP/IMessageOptions.d.ts

@@ -0,0 +1,6 @@
+interface IMessageOptions {
+    priority?: number;
+    expiration?: number;
+    persistent?: boolean;
+}
+export default IMessageOptions;

package/dist/AMQP/IMessageOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IMessageOptions.js.map

package/dist/AMQP/IMessageOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMessageOptions.js","sourceRoot":"","sources":["../../src/AMQP/IMessageOptions.ts"],"names":[],"mappings":""}

package/dist/AMQP/INackOptions.d.ts

@@ -0,0 +1,4 @@
+export default INackOptions;
+interface INackOptions {
+    requeue: boolean;
+}

package/dist/AMQP/INackOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=INackOptions.js.map

package/dist/AMQP/INackOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INackOptions.js","sourceRoot":"","sources":["../../src/AMQP/INackOptions.ts"],"names":[],"mappings":""}

package/dist/AMQP/IQueueOptions.d.ts

@@ -0,0 +1,8 @@
+export default IQueueOptions;
+interface IQueueOptions {
+    confirmable?: boolean;
+    /** Default value for all messages when it's not specified on message, default false */
+    persistent?: boolean;
+    prefetchCount?: number;
+    maxPriority?: number;
+}

package/dist/AMQP/IQueueOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IQueueOptions.js.map

package/dist/AMQP/IQueueOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IQueueOptions.js","sourceRoot":"","sources":["../../src/AMQP/IQueueOptions.ts"],"names":[],"mappings":""}

package/dist/AMQP/Logging/IDeviceLog.d.ts

@@ -0,0 +1,15 @@
+export declare enum DeviceLogType {
+    ACTION_FROM_DEVICE = "action_from_device",
+    ACTION_TO_DEVICE = "action_to_device",
+    PLATFORM = "platform"
+}
+export interface IDeviceLog<TPayload extends {
+    type: string;
+} = {
+    type: string;
+}> {
+    type: DeviceLogType;
+    deviceUid: string;
+    receivedAt: Date;
+    payload: TPayload;
+}

package/dist/AMQP/Logging/IDeviceLog.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceLogType = void 0;
+var DeviceLogType;
+(function (DeviceLogType) {
+    DeviceLogType["ACTION_FROM_DEVICE"] = "action_from_device";
+    DeviceLogType["ACTION_TO_DEVICE"] = "action_to_device";
+    DeviceLogType["PLATFORM"] = "platform";
+})(DeviceLogType || (exports.DeviceLogType = DeviceLogType = {}));
+//# sourceMappingURL=IDeviceLog.js.map

package/dist/AMQP/Logging/IDeviceLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IDeviceLog.js","sourceRoot":"","sources":["../../../src/AMQP/Logging/IDeviceLog.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAIX;AAJD,WAAY,aAAa;IACxB,0DAAyC,CAAA;IACzC,sDAAqC,CAAA;IACrC,sCAAqB,CAAA;AACtB,CAAC,EAJW,aAAa,6BAAb,aAAa,QAIxB"}

package/dist/AMQP/Logging/logDeviceQueue.d.ts

@@ -0,0 +1,12 @@
+import { IAMQPConnection } from '../amqpConnectionFactory';
+import { IDeviceLog } from './IDeviceLog';
+export declare function enqueue<TPayload extends {
+    type: string;
+} = {
+    type: string;
+}>(amqpConnection: IAMQPConnection, deviceLog: IDeviceLog<TPayload>): Promise<void>;
+export declare function bindAll<TPayload extends {
+    type: string;
+} = {
+    type: string;
+}>(amqpConnection: IAMQPConnection, onDeviceLog: (deviceLog: IDeviceLog<TPayload>) => Promise<void>): Promise<import("../QueueSubscriber").ICancelConsumption>;

package/dist/AMQP/Logging/logDeviceQueue.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueue = enqueue;
+exports.bindAll = bindAll;
+var QUEUE_NAME = 'device_logs';
+var OPTIONS = {
+    persistent: false,
+    confirmable: false,
+    prefetchCount: 300,
+};
+function enqueue(amqpConnection, deviceLog) {
+    return __awaiter(this, void 0, void 0, function () {
+        var createChannel;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    createChannel = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var channel;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, amqpConnection.channelProvider.getChannel(QUEUE_NAME, OPTIONS)];
+                                case 1:
+                                    channel = _a.sent();
+                                    return [4 /*yield*/, channel.assertExchange(QUEUE_NAME, 'fanout')];
+                                case 2:
+                                    _a.sent();
+                                    return [2 /*return*/, channel];
+                            }
+                        });
+                    }); };
+                    return [4 /*yield*/, amqpConnection.queuePublisher.enqueue(createChannel, deviceLog, undefined, QUEUE_NAME, QUEUE_NAME, { persistent: false })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function bindAll(amqpConnection, onDeviceLog) {
+    return __awaiter(this, void 0, void 0, function () {
+        var createChannel;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    createChannel = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var channel;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, amqpConnection.channelProvider.getChannel(QUEUE_NAME, OPTIONS)];
+                                case 1:
+                                    channel = _a.sent();
+                                    return [4 /*yield*/, channel.assertExchange(QUEUE_NAME, 'fanout')];
+                                case 2:
+                                    _a.sent();
+                                    return [2 /*return*/, channel];
+                            }
+                        });
+                    }); };
+                    return [4 /*yield*/, amqpConnection.queueSubscriber.subscribeRepeatable(createChannel, QUEUE_NAME, [{ exchangeName: QUEUE_NAME, routingKey: QUEUE_NAME, persistent: true }], onDeviceLog, {
+                            queueType: 'classic',
+                            autoDelete: false,
+                            durable: true,
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+//# sourceMappingURL=logDeviceQueue.js.map

package/dist/AMQP/Logging/logDeviceQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logDeviceQueue.js","sourceRoot":"","sources":["../../../src/AMQP/Logging/logDeviceQueue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,0BAkBC;AAED,0BAqBC;AAhDD,IAAM,UAAU,GAAG,aAAa,CAAC;AACjC,IAAM,OAAO,GAAkB;IAC9B,UAAU,EAAE,KAAK;IACjB,WAAW,EAAE,KAAK;IAClB,aAAa,EAAE,GAAG;CAClB,CAAC;AAEF,SAAsB,OAAO,CAC5B,cAA+B,EAC/B,SAA+B;;;;;;;oBAEzB,aAAa,GAAG;;;;wCACL,qBAAM,cAAc,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,EAAA;;oCAA9E,OAAO,GAAG,SAAoE;oCACpF,qBAAM,OAAO,CAAC,cAAc,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAA;;oCAAlD,SAAkD,CAAC;oCACnD,sBAAO,OAAO,EAAC;;;yBACf,CAAC;oBAEF,qBAAM,cAAc,CAAC,cAAc,CAAC,OAAO,CAC1C,aAAa,EACb,SAAS,EACT,SAAS,EACT,UAAU,EACV,UAAU,EACV,EAAE,UAAU,EAAE,KAAK,EAAE,CACrB,EAAA;;oBAPD,SAOC,CAAC;;;;;CACF;AAED,SAAsB,OAAO,CAC5B,cAA+B,EAC/B,WAA+D;;;;;;;oBAEzD,aAAa,GAAG;;;;wCACL,qBAAM,cAAc,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,EAAA;;oCAA9E,OAAO,GAAG,SAAoE;oCACpF,qBAAM,OAAO,CAAC,cAAc,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAA;;oCAAlD,SAAkD,CAAC;oCACnD,sBAAO,OAAO,EAAC;;;yBACf,CAAC;oBAEK,qBAAM,cAAc,CAAC,eAAe,CAAC,mBAAmB,CAC9D,aAAa,EACb,UAAU,EACV,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,EACxE,WAAW,EACX;4BACC,SAAS,EAAE,SAAS;4BACpB,UAAU,EAAE,KAAK;4BACjB,OAAO,EAAE,IAAI;yBACb,CACD,EAAA;wBAVD,sBAAO,SAUN,EAAC;;;;CACF"}

package/dist/AMQP/QueueFetcher.d.ts

@@ -0,0 +1,13 @@
+import IChannel from './IChannel';
+import { IAsyncGotMessage } from './IAsyncGotMessage';
+/**
+ * Abstraction layer for fetching messages from a queue.
+ * It does all the channel management and provides messages that can be acknowledged asynchronously.
+ * The messages can be acked/nacked asynchronously, and the channel will be closed once all messages are processed.
+ */
+export default class QueueFetcher {
+    /**
+     * Fetches up to maxMessages from the specified queue.
+     */
+    fetchBatch<TMessage>(createChannel: () => Promise<IChannel<TMessage>>, queueName: string, maxMessages?: number): Promise<IAsyncGotMessage<TMessage>[]>;
+}