podverse-mq 5.0.0

package/README.md

@@ -0,0 +1,37 @@
+# podverse-mq
+
+A module for handling Podverse Queue (ActiveMQArtemis / AMQP) interactions.
+
+## Dev Setup
+
+### Environment Variables
+
+The environment variables for this module must be set within the app that consumes this module (ex. `podverse-api` or `podverse-workers`). See `podverse-mq/config/index.ts` for a list of the env vars expected.
+
+### Local Dev Workflow
+
+Podverse uses many modules that are maintained in separate repos, and they need to be linked and running for a local dev workflow. Please read the `podverse-ops/dev/local-dev-setup.md` file to set up the required dependencies and module linking.
+
+### Running Locally
+
+Install the node_modules:
+
+```
+npm install
+```
+
+Then to build:
+
+```
+npm run build
+```
+
+Or if you want the app to auto-build on saved changes:
+
+```
+npm run build:watch
+```
+
+## Publishing
+
+To publish your changes to npm, increment the version number is `package.json` then run `npm publish`.

package/dist/functions/queue/rss/add.d.ts

@@ -0,0 +1,9 @@
+import { ActiveMQArtemisService } from "@queue/services/activeMQArtemis";
+import { MQQueueConfig } from "podverse-helpers";
+type MQRSSAddOptions = MQQueueConfig & {
+    feedUrl: string;
+    podcastIndexId: number;
+};
+export declare const mqRSSAdd: (activeMQArtemisService: ActiveMQArtemisService, options: MQRSSAddOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=add.d.ts.map

package/dist/functions/queue/rss/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../src/functions/queue/rss/add.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,KAAK,eAAe,GAAG,aAAa,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAA;AAED,eAAO,MAAM,QAAQ,GACnB,wBAAwB,sBAAsB,EAC9C,SAAS,eAAe,kBAezB,CAAC"}

package/dist/functions/queue/rss/add.js

@@ -0,0 +1,26 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqRSSAdd = void 0;
+const mqRSSAdd = (activeMQArtemisService, options) => __awaiter(void 0, void 0, void 0, function* () {
+    yield activeMQArtemisService.initialize();
+    const message = {
+        url: options.feedUrl,
+        podcast_index_id: options.podcastIndexId
+    };
+    yield activeMQArtemisService.sendMessage({
+        queueName: options.queueName,
+        message,
+        priority: options.priority,
+        dedupeCacheTimeMS: options.dedupeCacheTimeMS
+    });
+});
+exports.mqRSSAdd = mqRSSAdd;

package/dist/functions/queue/rss/addAll.d.ts

@@ -0,0 +1,6 @@
+import { ActiveMQArtemisService } from "@queue/services/activeMQArtemis";
+import { MQQueueConfig } from "podverse-helpers";
+type MQRSSAddAllConfig = MQQueueConfig;
+export declare const mqRSSAddAll: (activeMQArtemisService: ActiveMQArtemisService, config: MQRSSAddAllConfig) => Promise<void>;
+export {};
+//# sourceMappingURL=addAll.d.ts.map

package/dist/functions/queue/rss/addAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addAll.d.ts","sourceRoot":"","sources":["../../../../src/functions/queue/rss/addAll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,KAAK,iBAAiB,GAAG,aAAa,CAAC;AAEvC,eAAO,MAAM,WAAW,GACtB,wBAAwB,sBAAsB,EAC9C,QAAQ,iBAAiB,kBAoB1B,CAAC"}

package/dist/functions/queue/rss/addAll.js

@@ -0,0 +1,31 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqRSSAddAll = void 0;
+const podverse_orm_1 = require("podverse-orm");
+const mqRSSAddAll = (activeMQArtemisService, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const feedService = new podverse_orm_1.FeedService();
+    const feeds = yield feedService.getAll();
+    yield activeMQArtemisService.initialize();
+    for (const feed of feeds) {
+        const message = {
+            url: feed.url,
+            podcast_index_id: feed.channel.podcast_index_id
+        };
+        yield activeMQArtemisService.sendMessage({
+            queueName: config.queueName,
+            message,
+            priority: config.priority,
+            dedupeCacheTimeMS: config.dedupeCacheTimeMS
+        });
+    }
+});
+exports.mqRSSAddAll = mqRSSAddAll;

package/dist/functions/queue/rss/addRecentlyUpdatedFeedsFromPodcastIndex.d.ts

@@ -0,0 +1,9 @@
+import { PodcastIndexService } from 'podverse-external-services';
+import { MQQueueConfig } from 'podverse-helpers';
+import { ActiveMQArtemisService } from "@queue/services/activeMQArtemis";
+type MQRSSAddAllRecentlyUpdatedFeedsOptions = MQQueueConfig & {
+    sinceRange: number;
+};
+export declare const mqRSSAddRecentlyUpdatedFeedsFromPodcastIndex: (activeMQArtemisService: ActiveMQArtemisService, podcastIndexService: PodcastIndexService, options: MQRSSAddAllRecentlyUpdatedFeedsOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=addRecentlyUpdatedFeedsFromPodcastIndex.d.ts.map

package/dist/functions/queue/rss/addRecentlyUpdatedFeedsFromPodcastIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addRecentlyUpdatedFeedsFromPodcastIndex.d.ts","sourceRoot":"","sources":["../../../../src/functions/queue/rss/addRecentlyUpdatedFeedsFromPodcastIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAGzE,KAAK,sCAAsC,GAAG,aAAa,GAAG;IAC5D,UAAU,EAAE,MAAM,CAAC;CACpB,CAAA;AAED,eAAO,MAAM,4CAA4C,GACvD,wBAAwB,sBAAsB,EAC9C,qBAAqB,mBAAmB,EACxC,SAAS,sCAAsC,kBA0BhD,CAAC"}

package/dist/functions/queue/rss/addRecentlyUpdatedFeedsFromPodcastIndex.js

@@ -0,0 +1,36 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqRSSAddRecentlyUpdatedFeedsFromPodcastIndex = void 0;
+const podverse_orm_1 = require("podverse-orm");
+const mqRSSAddRecentlyUpdatedFeedsFromPodcastIndex = (activeMQArtemisService, podcastIndexService, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const sinceRange = options.sinceRange;
+    const recentlyUpdatedFeeds = yield podcastIndexService.recentGetData(sinceRange);
+    yield activeMQArtemisService.initialize();
+    for (const feed of recentlyUpdatedFeeds) {
+        const feedService = new podverse_orm_1.FeedService();
+        const dbFeed = yield feedService.getByPodcastIndexId({ podcast_index_id: feed.feedId });
+        const shouldAddToQueue = !!dbFeed;
+        if (shouldAddToQueue) {
+            const message = {
+                url: feed.feedUrl,
+                podcast_index_id: feed.feedId
+            };
+            yield activeMQArtemisService.sendMessage({
+                queueName: options.queueName,
+                message,
+                priority: options.priority,
+                dedupeCacheTimeMS: options.dedupeCacheTimeMS
+            });
+        }
+    }
+});
+exports.mqRSSAddRecentlyUpdatedFeedsFromPodcastIndex = mqRSSAddRecentlyUpdatedFeedsFromPodcastIndex;

package/dist/functions/queue/rss/addTrendingPodcastsFromPodcastIndex.d.ts

@@ -0,0 +1,9 @@
+import { PodcastIndexService } from 'podverse-external-services';
+import { MQQueueConfig } from 'podverse-helpers';
+import { ActiveMQArtemisService } from '@queue/services/activeMQArtemis';
+type AddTrendingPodcastsOptions = MQQueueConfig & {
+    maxFeeds?: number;
+};
+export declare const mqRSSAddTrendingPodcastsFromPodcastIndex: (activeMQArtemisService: ActiveMQArtemisService, podcastIndexService: PodcastIndexService, options: AddTrendingPodcastsOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=addTrendingPodcastsFromPodcastIndex.d.ts.map

package/dist/functions/queue/rss/addTrendingPodcastsFromPodcastIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addTrendingPodcastsFromPodcastIndex.d.ts","sourceRoot":"","sources":["../../../../src/functions/queue/rss/addTrendingPodcastsFromPodcastIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAGzE,KAAK,0BAA0B,GAAG,aAAa,GAAG;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,wBAAwB,sBAAsB,EAC9C,qBAAqB,mBAAmB,EACxC,SAAS,0BAA0B,KAClC,OAAO,CAAC,IAAI,CAyBd,CAAC"}

package/dist/functions/queue/rss/addTrendingPodcastsFromPodcastIndex.js

@@ -0,0 +1,36 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqRSSAddTrendingPodcastsFromPodcastIndex = void 0;
+const mqRSSAddTrendingPodcastsFromPodcastIndex = (activeMQArtemisService, podcastIndexService, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { queueName, maxFeeds = 1000 } = options;
+    try {
+        const { feeds } = yield podcastIndexService.trendingGetPodcasts(maxFeeds);
+        yield activeMQArtemisService.initialize();
+        for (const feed of feeds) {
+            const message = {
+                url: feed.url,
+                podcast_index_id: feed.id
+            };
+            yield activeMQArtemisService.sendMessage({
+                queueName,
+                message,
+                priority: options.priority,
+                dedupeCacheTimeMS: options.dedupeCacheTimeMS
+            });
+        }
+    }
+    catch (error) {
+        console.error('[mqRSSAddTrendingPodcastsFromPodcastIndex] Error adding trending podcasts:', error);
+        throw error;
+    }
+});
+exports.mqRSSAddTrendingPodcastsFromPodcastIndex = mqRSSAddTrendingPodcastsFromPodcastIndex;

package/dist/functions/queue/rss/runParser.d.ts

@@ -0,0 +1,3 @@
+import { MQQueueName, ActiveMQArtemisService } from "@queue/services/activeMQArtemis";
+export declare const mqRSSRunParser: (activeMQArtemisService: ActiveMQArtemisService, queueName: MQQueueName) => Promise<void>;
+//# sourceMappingURL=runParser.d.ts.map

package/dist/functions/queue/rss/runParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runParser.d.ts","sourceRoot":"","sources":["../../../../src/functions/queue/rss/runParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEtF,eAAO,MAAM,cAAc,GACzB,wBAAwB,sBAAsB,EAC9C,WAAW,WAAW,kBAmBvB,CAAC"}

package/dist/functions/queue/rss/runParser.js

@@ -0,0 +1,33 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqRSSRunParser = void 0;
+const podverse_parser_1 = require("podverse-parser");
+const mqRSSRunParser = (activeMQArtemisService, queueName) => __awaiter(void 0, void 0, void 0, function* () {
+    yield activeMQArtemisService.initialize();
+    yield activeMQArtemisService.consumeMessages(queueName, (message) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const receivedMessageString = message.content.toString();
+            const receivedMessage = JSON.parse(receivedMessageString);
+            const { url, podcast_index_id } = receivedMessage;
+            if (url || podcast_index_id) {
+                yield (0, podverse_parser_1.parseRSSFeedAndSaveToDatabase)(url, podcast_index_id);
+            }
+            else {
+                throw new Error(`mqRSSRunParser: url or podcast_index_id not found in message ${receivedMessage === null || receivedMessage === void 0 ? void 0 : receivedMessage.toString()}`);
+            }
+        }
+        catch (error) {
+            console.error('Error processing message', error);
+        }
+    }));
+});
+exports.mqRSSRunParser = mqRSSRunParser;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import './module-alias-config';
+export { mqRSSAdd } from './functions/queue/rss/add';
+export { mqRSSAddAll } from './functions/queue/rss/addAll';
+export { mqRSSRunParser } from './functions/queue/rss/runParser';
+export { ActiveMQArtemisService, ActiveMQArtemisServiceParams } from './services/activeMQArtemis';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,uBAAuB,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveMQArtemisService = exports.mqRSSRunParser = exports.mqRSSAddAll = exports.mqRSSAdd = void 0;
+require("./module-alias-config");
+var add_1 = require("./functions/queue/rss/add");
+Object.defineProperty(exports, "mqRSSAdd", { enumerable: true, get: function () { return add_1.mqRSSAdd; } });
+var addAll_1 = require("./functions/queue/rss/addAll");
+Object.defineProperty(exports, "mqRSSAddAll", { enumerable: true, get: function () { return addAll_1.mqRSSAddAll; } });
+var runParser_1 = require("./functions/queue/rss/runParser");
+Object.defineProperty(exports, "mqRSSRunParser", { enumerable: true, get: function () { return runParser_1.mqRSSRunParser; } });
+var activeMQArtemis_1 = require("./services/activeMQArtemis");
+Object.defineProperty(exports, "ActiveMQArtemisService", { enumerable: true, get: function () { return activeMQArtemis_1.ActiveMQArtemisService; } });

package/dist/module-alias-config.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module-alias-config.d.ts.map

package/dist/module-alias-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-alias-config.d.ts","sourceRoot":"","sources":["../src/module-alias-config.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC"}

package/dist/module-alias-config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const moduleAlias = require('module-alias');
+const path = require('path');
+moduleAlias.addAliases({
+    '@queue': path.join(__dirname, '')
+});

package/dist/services/activeMQArtemis/index.d.ts

@@ -0,0 +1,44 @@
+import { Delivery } from 'rhea';
+import { LoggerService } from 'podverse-helpers/dist/lib/backend/logger';
+export type MQQueueName = 'rss-normal' | 'rss-on-demand' | 'rss-live';
+type MQRSSMessage = {
+    url: string;
+    podcast_index_id: number | null;
+};
+type Message = MQRSSMessage;
+type SendMessageParams = {
+    queueName: MQQueueName;
+    message: Message;
+    priority: 'normal' | 'slow';
+    dedupeCacheTimeMS: number | null;
+};
+export interface ActiveMQArtemisServiceParams {
+    protocol: string;
+    host: string;
+    username: string;
+    password: string;
+    port: number;
+}
+export declare class ActiveMQArtemisService {
+    private connection;
+    private senders;
+    private receivers;
+    private params;
+    private logger;
+    private connecting;
+    constructor(params: ActiveMQArtemisServiceParams, logger: LoggerService);
+    initialize(): Promise<void>;
+    private connect;
+    private ensureSender;
+    private ensureReceiver;
+    private computeDuplicateId;
+    sendMessage(params: SendMessageParams): Promise<void>;
+    getMessage(queueName: MQQueueName): Promise<Message | null>;
+    consumeMessages(queueName: MQQueueName, processMessage: (msg: {
+        content: Buffer;
+        raw: Delivery;
+        queue: MQQueueName;
+    }) => Promise<void> | void): Promise<void>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/services/activeMQArtemis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/activeMQArtemis/index.ts"],"names":[],"mappings":"AACA,OAAO,EAA8C,QAAQ,EAAE,MAAM,MAAM,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAIzE,MAAM,MAAM,WAAW,GAAG,YAAY,GAAI,eAAe,GAAG,UAAU,CAAC;AAEvE,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,KAAK,OAAO,GAAG,YAAY,CAAC;AAE5B,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,WAAW,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAA;IAC3B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CACjC,CAAA;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,4BAA4B,EAAE,MAAM,EAAE,aAAa;IAKjE,UAAU;YASF,OAAO;YAwDP,YAAY;YAaZ,cAAc;IAa5B,OAAO,CAAC,kBAAkB;IAQpB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAyCrD,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IA8B3D,eAAe,CAAC,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;CA2BpJ"}

package/dist/services/activeMQArtemis/index.js

@@ -0,0 +1,230 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveMQArtemisService = void 0;
+const rhea_1 = __importDefault(require("rhea"));
+const crypto_1 = __importDefault(require("crypto"));
+class ActiveMQArtemisService {
+    constructor(params, logger) {
+        this.connection = null;
+        this.senders = new Map();
+        this.receivers = new Map();
+        this.connecting = false;
+        this.params = params;
+        this.logger = logger;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Queues are assumed to be pre-created externally (e.g. via provisioning script or broker config).
+            try {
+                yield this.connect();
+            }
+            catch (error) {
+                this.logger.logError('Failed to initialize Artemis connection', error);
+            }
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connection || this.connecting)
+                return;
+            this.connecting = true;
+            return new Promise((resolve, reject) => {
+                // Debug info about imported rhea module
+                try {
+                    const rheaLike = rhea_1.default;
+                    // Log a minimal snapshot of the rhea import for troubleshooting
+                    if (typeof rheaLike.connect !== 'function') {
+                        const err = new TypeError('rhea.connect is not a function – possible ESM/CJS import mismatch');
+                        this.logger.logError('Artemis connect failed early', err);
+                        this.connecting = false; // allow retry attempts later
+                        return reject(err);
+                    }
+                    const connection = rheaLike.connect({
+                        host: this.params.host,
+                        port: this.params.port,
+                        username: this.params.username,
+                        password: this.params.password,
+                        reconnect: true,
+                        reconnect_limit: -1
+                    });
+                    connection.on('connection_open', () => {
+                        this.logger.info('Artemis AMQP connection established');
+                        this.connection = connection;
+                        this.connecting = false;
+                        resolve();
+                    });
+                    connection.on('connection_error', (context) => {
+                        this.logger.logError('Artemis connection error', context.error);
+                    });
+                    connection.on('disconnected', () => {
+                        this.logger.info('Artemis connection disconnected – will attempt reconnect');
+                        this.connection = null;
+                    });
+                }
+                catch (err) {
+                    this.logger.logError('Artemis connect threw synchronously', err);
+                    this.connecting = false; // reset so future retries can occur
+                    reject(err);
+                }
+            });
+        });
+    }
+    ensureSender(queueName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.senders.has(queueName))
+                return this.senders.get(queueName);
+            if (!this.connection)
+                yield this.connect();
+            const sender = this.connection.open_sender({ target: { address: queueName } });
+            return new Promise((resolve) => {
+                sender.on('sender_open', () => {
+                    this.logger.info(`Sender ready for queue ${queueName}`);
+                    this.senders.set(queueName, sender);
+                    resolve(sender);
+                });
+            });
+        });
+    }
+    ensureReceiver(queueName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.receivers.has(queueName))
+                return this.receivers.get(queueName);
+            if (!this.connection)
+                yield this.connect();
+            const receiver = this.connection.open_receiver({ source: { address: queueName }, credit_window: 0 });
+            return new Promise((resolve) => {
+                receiver.on('receiver_open', () => {
+                    this.logger.info(`Receiver ready for queue ${queueName}`);
+                    this.receivers.set(queueName, receiver);
+                    resolve(receiver);
+                });
+            });
+        });
+    }
+    computeDuplicateId(queueName, message, dedupeCacheTimeMS) {
+        if (!dedupeCacheTimeMS || dedupeCacheTimeMS <= 0)
+            return null;
+        const baseHash = crypto_1.default.createHash('sha256').update(JSON.stringify(message)).digest('hex');
+        const now = Date.now();
+        const bucketStart = Math.floor(now / dedupeCacheTimeMS) * dedupeCacheTimeMS;
+        return `${queueName}:${bucketStart}:${baseHash}`;
+    }
+    sendMessage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { queueName, message, priority, dedupeCacheTimeMS } = params;
+            try {
+                const sender = yield this.ensureSender(queueName);
+                const bodyString = JSON.stringify(message);
+                const duplicateId = this.computeDuplicateId(queueName, message, dedupeCacheTimeMS);
+                const priorityValue = !priority || priority === 'normal' ? 5 : 1;
+                yield new Promise((resolve, reject) => {
+                    const delivery = sender.send(Object.assign({ body: bodyString, durable: true, priority: priorityValue, content_type: 'application/json' }, (duplicateId
+                        ? { application_properties: { _AMQ_DUPL_ID: duplicateId } }
+                        : {}) // omit property when no dedupe
+                    ));
+                    const onAccepted = (context) => {
+                        if (context.delivery === delivery) {
+                            this.logger.info(`Message sent to queue ${queueName}: ${bodyString}`);
+                            sender.removeListener('accepted', onAccepted);
+                            sender.removeListener('rejected', onRejected);
+                            resolve();
+                        }
+                    };
+                    const onRejected = (context) => {
+                        if (context.delivery === delivery) {
+                            this.logger.logError(`sendMessage: Rejected by broker ${queueName}: ${bodyString}`);
+                            sender.removeListener('accepted', onAccepted);
+                            sender.removeListener('rejected', onRejected);
+                            reject(new Error('Message rejected'));
+                        }
+                    };
+                    sender.on('accepted', onAccepted);
+                    sender.on('rejected', onRejected);
+                });
+            }
+            catch (error) {
+                this.logger.logError(`sendMessage: Error sending message to queue ${queueName}`, error);
+            }
+        });
+    }
+    getMessage(queueName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const receiver = yield this.ensureReceiver(queueName);
+                // Request one message (credit 1)
+                receiver.add_credit(1);
+                return yield new Promise((resolve) => {
+                    const onMessage = (context) => {
+                        var _a, _b;
+                        if (context.receiver === receiver) {
+                            const body = (_a = context.message) === null || _a === void 0 ? void 0 : _a.body;
+                            const parsed = JSON.parse(body);
+                            this.logger.info(`Message received from queue ${queueName}: ${body}`);
+                            (_b = context.delivery) === null || _b === void 0 ? void 0 : _b.accept();
+                            receiver.removeListener('message', onMessage);
+                            resolve(parsed);
+                        }
+                    };
+                    const onNoMessageTimeout = () => {
+                        receiver.removeListener('message', onMessage);
+                        resolve(null);
+                    };
+                    receiver.on('message', onMessage);
+                    // Timeout after 1 second if none
+                    setTimeout(onNoMessageTimeout, 1000);
+                });
+            }
+            catch (error) {
+                this.logger.logError('getMessage: Error receiving message', error);
+                return null;
+            }
+        });
+    }
+    consumeMessages(queueName, processMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const receiver = yield this.ensureReceiver(queueName);
+                const handleMessage = (context) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (context.receiver !== receiver)
+                        return;
+                    try {
+                        const body = (_a = context.message) === null || _a === void 0 ? void 0 : _a.body;
+                        this.logger.info(`Received message from queue ${queueName}: ${body}`);
+                        const delivery = context.delivery;
+                        const buffer = Buffer.from(body);
+                        yield processMessage({ content: buffer, raw: delivery, queue: queueName });
+                        delivery.accept();
+                    }
+                    catch (err) {
+                        this.logger.logError('Error processing message', err);
+                        (_b = context.delivery) === null || _b === void 0 ? void 0 : _b.reject();
+                    }
+                    finally {
+                        // Request next message (one at a time for FIFO semantics)
+                        receiver.add_credit(1);
+                    }
+                });
+                receiver.on('message', handleMessage);
+                receiver.add_credit(1); // Start consumption
+                this.logger.info(`Consumer is set up for queue ${queueName}`);
+            }
+            catch (error) {
+                this.logger.logError('consumeMessages: Failed to set consumer', error);
+            }
+        });
+    }
+}
+exports.ActiveMQArtemisService = ActiveMQArtemisService;

package/dist/services/activeMQArtemis/requestService.d.ts

@@ -0,0 +1,11 @@
+import { ActiveMQArtemisServiceParams } from '.';
+export declare class ActiveMQArtemisRequestService {
+    private protocol;
+    private host;
+    private username;
+    private password;
+    private port;
+    constructor({ protocol, host, username, password, port }: ActiveMQArtemisServiceParams);
+    request<T>(path: string): Promise<T>;
+}
+//# sourceMappingURL=requestService.d.ts.map

package/dist/services/activeMQArtemis/requestService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestService.d.ts","sourceRoot":"","sources":["../../../src/services/activeMQArtemis/requestService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,4BAA4B,EAAE,MAAM,GAAG,CAAC;AAEjD,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAS;gBAET,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,4BAA4B;IAQhF,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;CAmB3C"}