@diia-inhouse/diia-queue 13.3.4 → 14.0.11

package/dist/interfaces/providers/rabbitmq/amqpConnection.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmqpConnectionEventNames = exports.ConnectionStatus = void 0;
-var ConnectionStatus;
-(function (ConnectionStatus) {
-    ConnectionStatus["Init"] = "init";
-    ConnectionStatus["Connecting"] = "connecting";
-    ConnectionStatus["Connected"] = "connected";
-    ConnectionStatus["Reconnecting"] = "reconnecting";
-    ConnectionStatus["Closing"] = "closing";
-    ConnectionStatus["Closed"] = "closed";
-    ConnectionStatus["Down"] = "down";
-})(ConnectionStatus || (exports.ConnectionStatus = ConnectionStatus = {}));
-exports.AmqpConnectionEventNames = {
-    Ready: 'ready',
-};
-//# sourceMappingURL=amqpConnection.js.map
+//#region src/interfaces/providers/rabbitmq/amqpConnection.ts
+let ConnectionStatus = /* @__PURE__ */ function(ConnectionStatus) {
+	ConnectionStatus["Init"] = "init";
+	ConnectionStatus["Connecting"] = "connecting";
+	ConnectionStatus["Connected"] = "connected";
+	ConnectionStatus["Reconnecting"] = "reconnecting";
+	ConnectionStatus["Closing"] = "closing";
+	ConnectionStatus["Closed"] = "closed";
+	ConnectionStatus["Down"] = "down";
+	return ConnectionStatus;
+}({});
+const AmqpConnectionEventNames = { Ready: "ready" };
+//#endregion
+export { AmqpConnectionEventNames, ConnectionStatus };

package/dist/interfaces/providers/rabbitmq/amqpPublisher.d.ts

@@ -0,0 +1,20 @@
+import { Headers } from "./index.js";
+import { MessagePropertyHeaders } from "amqplib/properties";
+
+//#region src/interfaces/providers/rabbitmq/amqpPublisher.d.ts
+type MessagePayload = unknown;
+interface MessageHeaders {
+  traceId: string;
+  serviceCode?: string;
+  "x-delay"?: number;
+}
+interface DirectResponseHeaders extends MessagePropertyHeaders {
+  [Headers.handledBy]?: string;
+}
+interface DirectResponse<T = unknown> extends MessagePropertyHeaders {
+  body: T;
+  headers: DirectResponseHeaders;
+}
+type PublishingResult = void;
+//#endregion
+export { DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult };

package/dist/interfaces/providers/rabbitmq/index.d.ts

@@ -0,0 +1,107 @@
+import { BaseQueueOptions } from "../../messageBrokerServiceConfig.js";
+import { ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from "./amqpConnection.js";
+import { AmqpConnection } from "../../../providers/rabbitmq/amqpConnection.js";
+import { ListenerOptions } from "../../options.js";
+import { EventName, QueueConfigByQueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from "../../queueConfig/configs.js";
+import { ErrorData } from "@diia-inhouse/errors";
+import * as amqp from "amqplib";
+
+//#region src/interfaces/providers/rabbitmq/index.d.ts
+interface RabbitMQConfigCustomParams {
+  responseRoutingKeyPrefix?: string;
+}
+interface DeclareOptions {
+  assertQueues?: boolean;
+  assertExchanges?: boolean;
+  queuesOptions?: BaseQueueOptions;
+}
+interface RabbitMQConfig {
+  connection: ConnectOptions;
+  socketOptions?: SocketOptions;
+  reconnectOptions?: ReconnectOptions;
+  custom?: RabbitMQConfigCustomParams;
+  listenerOptions: ListenerOptions;
+  declareOptions?: DeclareOptions;
+  /**
+  * Whether to create consumer (listener) connections. When `false`, only publisher
+  * and asserter connections are established. Defaults to `true`.
+  */
+  consumerEnabled?: boolean;
+}
+declare enum ConnectionClientType {
+  Listener = "listener",
+  Asserter = "asserter",
+  Publisher = "publisher"
+}
+type ConnectionList = { [k in ConnectionClientType]: {
+  lock?: Promise<AmqpConnection>;
+} };
+interface QueueMessageMetaData {
+  date: Date;
+  xid?: string;
+  responseRoutingKey?: string;
+  ignoreCache?: boolean;
+  registryApiVersion?: string;
+}
+interface QueueMessageError {
+  data: ErrorData;
+  message: string;
+  http_code: number;
+}
+interface QueueMessageData<T = any> {
+  event: EventName;
+  payload: T;
+  meta: QueueMessageMetaData;
+}
+type MessageData = Pick<QueueMessageData, "payload" | "event">;
+declare class Message<T = unknown> {
+  data: QueueMessageData<T>;
+  constructor(data: QueueMessageData<T>);
+}
+type MessageProperties = amqp.MessageProperties;
+interface QueueMessage {
+  id?: unknown;
+  data: QueueMessageData;
+  properties: MessageProperties;
+  done: (data?: QueueMessageData) => void;
+  reject: (nackOptions: NackOptions) => void;
+}
+interface RabbitMQStatus {
+  listener?: ConnectionStatus;
+  publisher: ConnectionStatus;
+}
+interface ExportConfig {
+  queues: QueueConfigByQueueName;
+  rabbit: RabbitMQConfig;
+  topics: TopicConfigByConfigType;
+  service: ServiceConfigByConfigType;
+  portalEvents: EventName[];
+}
+declare const Headers: {
+  readonly sentFrom: "sent-from";
+  readonly handledBy: "handled-by";
+};
+declare class NackOptions {
+  /**
+  * If requeue is truthy, the server will try to put the message or messages back on the queue or queues from which they came.
+  * Defaults to true if not given, so if you want to make sure messages are dead-lettered or discarded, supply false here.
+  */
+  readonly requeue: boolean;
+  /**
+  * If allUpTo is truthy, all outstanding messages prior to and including the given message are rejected. Defaults to false.
+  */
+  readonly allUpTo: boolean;
+  constructor(requeue?: boolean, allUpTo?: boolean);
+}
+declare const Arguments: {
+  readonly queueType: "x-queue-type";
+  /**
+  * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
+  */
+  readonly delayedType: "x-delayed-type";
+  readonly deliveryLimit: "x-delivery-limit";
+  readonly deadLetterExchange: "x-dead-letter-exchange";
+  readonly deadLetterExchangeRoutingKey: "x-dead-letter-routing-key";
+};
+//#endregion
+export { Arguments, ConnectionClientType, ConnectionList, DeclareOptions, ExportConfig, Headers, Message, MessageData, MessageProperties, NackOptions, QueueMessage, QueueMessageData, QueueMessageError, QueueMessageMetaData, RabbitMQConfig, RabbitMQConfigCustomParams, RabbitMQStatus };

package/dist/interfaces/providers/rabbitmq/index.js

@@ -1,49 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Arguments = exports.NackOptions = exports.Headers = exports.Message = exports.ConnectionClientType = void 0;
-var ConnectionClientType;
-(function (ConnectionClientType) {
-    ConnectionClientType["Listener"] = "listener";
-    ConnectionClientType["Asserter"] = "asserter";
-    ConnectionClientType["Publisher"] = "publisher";
-})(ConnectionClientType || (exports.ConnectionClientType = ConnectionClientType = {}));
-class Message {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-}
-exports.Message = Message;
-exports.Headers = {
-    sentFrom: 'sent-from',
-    handledBy: 'handled-by',
+//#region src/interfaces/providers/rabbitmq/index.ts
+let ConnectionClientType = /* @__PURE__ */ function(ConnectionClientType) {
+	ConnectionClientType["Listener"] = "listener";
+	ConnectionClientType["Asserter"] = "asserter";
+	ConnectionClientType["Publisher"] = "publisher";
+	return ConnectionClientType;
+}({});
+var Message = class {
+	data;
+	constructor(data) {
+		this.data = data;
+	}
 };
-class NackOptions {
-    requeue;
-    allUpTo;
-    constructor(
-    /**
-     * If requeue is truthy, the server will try to put the message or messages back on the queue or queues from which they came.
-     * Defaults to true if not given, so if you want to make sure messages are dead-lettered or discarded, supply false here.
-     */
-    requeue = true, 
-    /**
-     * If allUpTo is truthy, all outstanding messages prior to and including the given message are rejected. Defaults to false.
-     */
-    allUpTo = false) {
-        this.requeue = requeue;
-        this.allUpTo = allUpTo;
-    }
-}
-exports.NackOptions = NackOptions;
-exports.Arguments = {
-    queueType: 'x-queue-type',
-    /**
-     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
-     */
-    delayedType: 'x-delayed-type',
-    deliveryLimit: 'x-delivery-limit',
-    deadLetterExchange: 'x-dead-letter-exchange',
-    deadLetterExchangeRoutingKey: 'x-dead-letter-routing-key',
+const Headers = {
+	sentFrom: "sent-from",
+	handledBy: "handled-by"
 };
-//# sourceMappingURL=index.js.map
+var NackOptions = class {
+	requeue;
+	allUpTo;
+	constructor(requeue = true, allUpTo = false) {
+		this.requeue = requeue;
+		this.allUpTo = allUpTo;
+	}
+};
+const Arguments = {
+	queueType: "x-queue-type",
+	/**
+	* @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
+	*/
+	delayedType: "x-delayed-type",
+	deliveryLimit: "x-delivery-limit",
+	deadLetterExchange: "x-dead-letter-exchange",
+	deadLetterExchangeRoutingKey: "x-dead-letter-routing-key"
+};
+//#endregion
+export { Arguments, ConnectionClientType, Headers, Message, NackOptions };

package/dist/interfaces/queueConfig/configs.d.ts

@@ -0,0 +1,47 @@
+import { ExchangeName, MessageBrokerServicesConfig } from "../messageBrokerServiceConfig.js";
+
+//#region src/interfaces/queueConfig/configs.d.ts
+type EventName = string;
+type QueueName = string;
+declare enum QueueConfigType {
+  Internal = "internal",
+  External = "external"
+}
+interface InternalServiceConfig {
+  subscribe?: QueueName[];
+  publish?: ExchangeName[];
+}
+interface ExternalServiceConfig {
+  /**
+  * add an event to this field only in cases when you don't need to await a response to an event;
+  * in other cases, use the *receiveDirect* mechanism
+  * */
+  publish?: EventName[];
+  subscribe: EventName[];
+}
+type ServiceConfigByConfigType = InternalServiceConfig | ExternalServiceConfig;
+interface ServiceConfig {
+  /**
+  * @deprecated no need to set the internal service queues config, because it is used nowhere.
+  * it should be deleted from a service config
+  * */
+  [QueueConfigType.Internal]?: InternalServiceConfig;
+  [QueueConfigType.External]?: ExternalServiceConfig;
+}
+type QueueConfigByQueueName = { [k in QueueName]: {
+  topics: ExchangeName[];
+} };
+type QueueConfig = Record<QueueConfigType.Internal, QueueConfigByQueueName>;
+type TopicConfigByConfigType = { [k in ExchangeName]: {
+  events: EventName[];
+} };
+type TopicConfig = Record<QueueConfigType, TopicConfigByConfigType>;
+type ServiceRulesConfig = {
+  topicsConfig: TopicConfig;
+  queuesConfig: QueueConfig;
+  portalEvents?: EventName[];
+  servicesConfig?: ServiceConfig;
+  messageBrokerServices?: MessageBrokerServicesConfig;
+};
+//#endregion
+export { EventName, ExternalServiceConfig, InternalServiceConfig, QueueConfig, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, TopicConfig, TopicConfigByConfigType };

package/dist/interfaces/queueConfig/configs.js

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueConfigType = void 0;
-var QueueConfigType;
-(function (QueueConfigType) {
-    QueueConfigType["Internal"] = "internal";
-    QueueConfigType["External"] = "external";
-})(QueueConfigType || (exports.QueueConfigType = QueueConfigType = {}));
-//# sourceMappingURL=configs.js.map
+//#region src/interfaces/queueConfig/configs.ts
+let QueueConfigType = /* @__PURE__ */ function(QueueConfigType) {
+	QueueConfigType["Internal"] = "internal";
+	QueueConfigType["External"] = "external";
+	return QueueConfigType;
+}({});
+//#endregion
+export { QueueConfigType };

package/dist/interfaces/queueConfig/index.d.ts

@@ -0,0 +1 @@
+import { EventName, ExternalServiceConfig, InternalServiceConfig, QueueConfig, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, TopicConfig, TopicConfigByConfigType } from "./configs.js";

package/dist/interfaces/queueContext.d.ts

@@ -0,0 +1,8 @@
+import { LogData } from "@diia-inhouse/types";
+
+//#region src/interfaces/queueContext.d.ts
+interface QueueContext {
+  logData?: LogData;
+}
+//#endregion
+export { QueueContext };

package/dist/interfaces/queueStatus.d.ts

@@ -0,0 +1,15 @@
+import { MessageBrokerServiceType } from "./messageBrokerServiceConfig.js";
+import { RabbitMQStatus } from "./providers/rabbitmq/index.js";
+
+//#region src/interfaces/queueStatus.d.ts
+declare enum QueueConnectionType {
+  Internal = "internal",
+  External = "external"
+}
+type MessageBrokerServicesStatus = Partial<Record<MessageBrokerServiceType, RabbitMQStatus>>;
+type QueueStatusByType = Partial<Record<QueueConnectionType, MessageBrokerServicesStatus>>;
+type QueueStatus = {
+  rabbit: QueueStatusByType;
+};
+//#endregion
+export { MessageBrokerServicesStatus, QueueConnectionType, QueueStatus, QueueStatusByType };

package/dist/interfaces/queueStatus.js

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueConnectionType = void 0;
-var QueueConnectionType;
-(function (QueueConnectionType) {
-    QueueConnectionType["Internal"] = "internal";
-    QueueConnectionType["External"] = "external";
-})(QueueConnectionType || (exports.QueueConnectionType = QueueConnectionType = {}));
-//# sourceMappingURL=queueStatus.js.map
+//#region src/interfaces/queueStatus.ts
+let QueueConnectionType = /* @__PURE__ */ function(QueueConnectionType) {
+	QueueConnectionType["Internal"] = "internal";
+	QueueConnectionType["External"] = "external";
+	return QueueConnectionType;
+}({});
+//#endregion
+export { QueueConnectionType };

package/dist/metrics/index.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.totalListenerChannelErrorsMetric = void 0;
-const diia_metrics_1 = require("@diia-inhouse/diia-metrics");
-exports.totalListenerChannelErrorsMetric = new diia_metrics_1.Counter('listener_channel_errors_total', [
-    'queueName',
-]);
-//# sourceMappingURL=index.js.map
+import { Counter } from "@diia-inhouse/diia-metrics";
+//#region src/metrics/index.ts
+const totalListenerChannelErrorsMetric = new Counter("listener_channel_errors_total", ["queueName"]);
+//#endregion
+export { totalListenerChannelErrorsMetric };

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+import { AmqpConnection } from "./rabbitmq/amqpConnection.js";
+import { AmqpAsserter } from "./rabbitmq/amqpAsserter.js";
+import { AmqpListener } from "./rabbitmq/amqpListener.js";
+import { AmqpPublisher } from "./rabbitmq/amqpPublisher.js";
+import { RabbitMQProvider } from "./rabbitmq/index.js";

package/dist/providers/index.js

@@ -1,22 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./rabbitmq"), exports);
-__exportStar(require("./rabbitmq/amqpListener"), exports);
-__exportStar(require("./rabbitmq/amqpAsserter"), exports);
-__exportStar(require("./rabbitmq/amqpPublisher"), exports);
-__exportStar(require("./rabbitmq/amqpConnection"), exports);
-//# sourceMappingURL=index.js.map
+import "./rabbitmq/amqpAsserter.js";
+import "./rabbitmq/amqpConnection.js";
+import "./rabbitmq/amqpListener.js";
+import "./rabbitmq/amqpPublisher.js";
+import "./rabbitmq/index.js";
+export {};

package/dist/providers/rabbitmq/amqpAsserter.d.ts

@@ -0,0 +1,53 @@
+import { BindOptions, ExchangeName, ExchangeOptions, QueueOptions, UnbindOptions } from "../../interfaces/messageBrokerServiceConfig.js";
+import { AmqpConnection } from "./amqpConnection.js";
+import { QueueName } from "../../interfaces/queueConfig/configs.js";
+import { DeclareOptions } from "../../interfaces/providers/rabbitmq/index.js";
+import { Logger } from "@diia-inhouse/types";
+import { Replies } from "amqplib";
+
+//#region src/providers/rabbitmq/amqpAsserter.d.ts
+declare class AmqpAsserter {
+  private readonly connection;
+  private readonly logger;
+  private readonly declareOptions;
+  static PrefixAlternate: string;
+  private readonly defaultExchangeType;
+  private readonly defaultQueueOptions;
+  private readonly defaultExchangeOptions;
+  private readonly defaultDeclareOptions;
+  private channel?;
+  private readonly channelName;
+  constructor(connection: AmqpConnection, logger: Logger, declareOptions?: DeclareOptions);
+  init(exchangesOptions?: ExchangeOptions[], queuesOptions?: QueueOptions[]): Promise<void>;
+  declareQueuesByJSON(declarationConfigPath: string): Promise<void>;
+  declareQueues(queuesOptions?: QueueOptions[], exchangesOptions?: ExchangeOptions[]): Promise<void>;
+  redeclareQueue(queueOptions: QueueOptions, exchangesOptions: ExchangeOptions[]): Promise<boolean>;
+  transferMessageBetweenQueues(sourceQueueName: QueueName, destinationQueueName: QueueName): Promise<void>;
+  deleteExchanges(exchangesOptions: ExchangeOptions[]): Promise<Record<ExchangeName, Replies.Empty | undefined>>;
+  deleteExchange(exchangeName: string): Promise<Replies.Empty | undefined>;
+  deleteQueues(queueNames: QueueName[]): Promise<Record<QueueName, Replies.DeleteQueue | undefined>>;
+  deleteQueue(queueName: QueueName): Promise<Replies.DeleteQueue | undefined>;
+  assertQueues(queueOptions: QueueOptions[]): Promise<Record<QueueName, Replies.AssertQueue | undefined>>;
+  assertQueue(queueOptions: QueueOptions): Promise<Replies.AssertQueue | undefined>;
+  assertExchanges(exchangeOptions: ExchangeOptions[]): Promise<Record<QueueName, Replies.AssertExchange | undefined>>;
+  assertExchange(exchangeOptions: ExchangeOptions): Promise<Replies.AssertExchange | undefined>;
+  unbindQueueFromExchanges(queueOptions: QueueOptions): Promise<undefined>;
+  bindQueueToExchange(queueName: QueueName, bindOptions: BindOptions): Promise<Replies.Empty | undefined>;
+  bindExchangeToExchanges(exchangeName: ExchangeName, bindTo: BindOptions[]): Promise<undefined>;
+  bindExchangeToExchange(exchangeName: ExchangeName, bindOptions: BindOptions): Promise<Replies.Empty | undefined>;
+  unbindQueueFromExchange(queueName: QueueName, unbindOptions: UnbindOptions): Promise<Replies.Empty | undefined>;
+  disconnect(): Promise<void>;
+  private initChannel;
+  private readConfig;
+  private assertTemporaryQueue;
+  private assertAlternateExchanges;
+  private assertAlternateQueue;
+  private prepareRedeclareQueueOptions;
+  private prepareTemporaryQueueOptions;
+  private prepareAlternateExchangesOptions;
+  private prepareAlternateExchangeOptions;
+  private prepareAlternateQueueOptions;
+  private prepareAlternateBindToQueueOption;
+}
+//#endregion
+export { AmqpAsserter };