jsm-core/dist/app/managers/queue-manager/index.js

Core library for JSM project

"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
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.QueueManager = void 0;
const events_1 = require("events");
const jsm_logger_1 = __importStar(require("jsm-logger"));
const jsm_utilities_1 = require("jsm-utilities");
;
class QueueManager {
    constructor() {
        this.status = 'idle';
        this._queue = [];
        this._queue = [];
        this.status = 'idle';
        this.logger = (0, jsm_logger_1.default)(jsm_logger_1.LoggerContext.LOADER, this.constructor.name);
        this.queueEmitter = new events_1.EventEmitter();
        // Start listening for queue changes
        this.queueEmitter.on("itemAdded", () => {
            if (this.status === "idle") {
                this.process();
            }
        });
    }
    /**
     * Adds an item to the processing queue.
     * @param item The item to add to the queue.
     * @returns The ID of the added item.
     */
    addItem(item, processor, opt = {}) {
        const { retryCount, retryDelay, maxRetries, } = (0, jsm_utilities_1.defaults)(opt, {
            retryCount: 0,
            retryDelay: (retries) => Math.min(1000 * Math.pow(2, retries), 30000), // Exponential backoff with a max of 30 seconds
            maxRetries: 5,
        });
        const id = item.id || `item-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
        if (this._queue.some(existingItem => existingItem.id === id)) {
            this.logger.warn(`Item with id ${id} already exists in the queue. Skipping addition.`);
            return id;
        }
        this.logger.event(`Adding item to queue: ${id}`);
        this._queue.push(Object.assign(Object.assign({}, item), { createdAt: new Date(), updatedAt: new Date(), status: 'pending', id, retryCount: 0, maxRetries, retryDelay, processor }));
        this.logger.event(`Added item to queue: ${id}`);
        // Emit event to notify that a new item has been added
        this.queueEmitter.emit("itemAdded");
        return id;
    }
    /**
     * Removes an item from the processing queue by its ID.
     * @param itemId The ID of the item to remove.
     */
    removeItem(itemId) {
        const index = this._queue.findIndex(item => item.id === itemId);
        if (index !== -1) {
            this._queue.splice(index, 1);
            this.logger.event(`Removed item from queue: ${itemId}`);
        }
        else {
            this.logger.warn(`Item not found in queue: ${itemId}`);
        }
    }
    /**
     * Updates an item in the processing queue by its ID.
     * @param itemId The ID of the item to update.
     * @param updates The updates to apply to the item.
     */
    updateItem(itemId, updates) {
        const item = this._queue.find(i => i.id === itemId);
        if (item) {
            Object.assign(item, updates);
            item.updatedAt = new Date();
            this._queue = this._queue.map(i => i.id === itemId ? item : i); // Update the item in the queue
            this.logger.event(`Updated item in queue: ${itemId}`);
        }
        else {
            this.logger.warn(`Item not found in queue for update: ${itemId}`);
        }
    }
    /**
     * Retrieves items from the processing queue based on optional filters.
     * @param status Optional status to filter items by.
     * @param type Optional type to filter items by.
     * @param appId Optional app ID to filter items by.
     * @param storeId Optional store ID to filter items by.
     * @returns An array of matching TQueueItem objects.
     */
    getItems(status, type, appId, storeId) {
        return this._queue.filter(item => {
            var _a, _b, _c, _d, _e;
            const statusMatch = status ? (Array.isArray(status) ? status.includes(item.status) : item.status === status) : true;
            const typeMatch = type ? (Array.isArray(type) ? type.includes(item.type) : item.type === type) : true;
            const appIdMatch = appId ? ((_b = (_a = item.app) === null || _a === void 0 ? void 0 : _a.getConfig()) === null || _b === void 0 ? void 0 : _b._id) === appId : true;
            const storeIdMatch = storeId ? ((_e = (_d = (_c = item.app) === null || _c === void 0 ? void 0 : _c.getConfig()) === null || _d === void 0 ? void 0 : _d.attributes) === null || _e === void 0 ? void 0 : _e.store_id) === storeId : true;
            return statusMatch && typeMatch && appIdMatch && storeIdMatch;
        });
    }
    getStatus() {
        const status = {
            status: this.status,
            queueLength: this._queue.length,
            pendingItems: this._queue.filter(item => item.status === 'pending').length,
            processingItems: this._queue.filter(item => item.status === 'processing').length,
            completedItems: this._queue.filter(item => item.status === 'completed').length,
            retryingItems: this._queue.filter(item => item.status === 'retrying').length,
            failedItems: this._queue.filter(item => item.status === 'failed').length,
        };
        this.logger.tree(`Queue status: `, status);
        return status;
    }
    /**
     * Processes the queue, handling each item based on its type and status.
     * This method should be implemented in subclasses to define specific processing logic.
     */
    process() {
        return __awaiter(this, void 0, void 0, function* () {
            this.status = "running";
            while (this._queue.filter(item => item.status === 'pending').length > 0) {
                const itemIndex = this._queue.findIndex(item => item.status === 'pending');
                if (itemIndex === -1) {
                    this.logger.warn("Queue is empty or item is undefined.");
                    continue;
                }
                const item = this._queue[itemIndex];
                try {
                    this.logger.event(`Processing item: ${item.id}`);
                    this._queue[itemIndex].status = "processing";
                    this.logger.event(`Item marked as processing: ${item.id}`);
                    yield item.processor(Object.assign(Object.assign({}, item), { processor: undefined })); // Call the processor function with the item
                    item.status = "completed";
                    this.logger.success(`Item processed successfully: ${item.id}`);
                    this.logger.event(`Item marked as completed: ${item.id}`);
                }
                catch (error) {
                    item.error = error;
                    item.retryCount = (item.retryCount || 0) + 1;
                    this.logger.error(`Failed to process item: ${item.id}`, { error });
                    // Retry logic
                    if (item.retryCount < item.maxRetries) {
                        item.status = "retrying";
                        const retryDelay = item.retryDelay || (() => Math.min(1000 * Math.pow(2, item.retryCount), 30000)); // Exponential backoff with a max of 30 seconds
                        this.logger.event(`Retrying item ${item.id} in ${retryDelay(item.retryCount)}ms (attempt ${item.retryCount})`);
                        yield new Promise(resolve => setTimeout(resolve, retryDelay(item.retryCount)));
                        item.status = "pending"; // Reset status to pending for retry
                    }
                    else {
                        this.logger.error(`Max retries reached for item: ${item.id}. Marking as failed permanently.`);
                        item.status = "failed";
                    }
                }
                finally {
                    item.updatedAt = new Date();
                    // Mark completed items for debugging purposes
                    this.logger.event(`Item marked as completed for debug: ${item.id}`);
                    this._queue[itemIndex] = item; // Update the item in the queue
                }
            }
            this.status = "idle";
        });
    }
}
exports.QueueManager = QueueManager;