@signiant/media-shuttle-sdk/dist/esm/src/internal/transfer/OrderedTransferUpdateManager.js

The SDK for supporting file transfer to and from Media Shuttle

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 (_) 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 };
    }
};
import * as fastq from 'fastq';
/**
 * There is a single line and requests are processed 1 at a time in the order they were added.
 */
var CONCURRENCY = 1;
/**
 * We have seen instances where transfer requests reach their final destination out of order. Even assuming
 * the events are dispatched from the App in the correct order and are processed in the correct order then nature
 * of async/await behaviour means that when we are waiting for the results of 1 request (Request A) we could concurrently
 * be making another request (Request B). Under these circumstances Request A would typically begin first but
 * Request B "catches up" and surpasses resulting in out of order processing.
 *
 * This class exists to bring (more?) order to the chaos by allowing callers to queue up requests but only allow
 * processing of 1 element on the queue at a time. Since we only have 1 outbound request going to PAPI at a time
 * this should remove the possibility of race conditions between concurrent requests at the cost of slightly
 * delayed updates.
 *
 * We could write our own queue implementation but multiple pre-existing queue implementations exist with "safe"
 * libraries. "fastq" was chosen for its overwhelming popularity:
 * https://npmtrends.com/better-queue-vs-fastq-vs-js-queue-vs-queue
 *
 * Note, in testing both unit and manual (more clear before the debug logs were removed) we will see cases where a
 * second item is added to the queue before the first finishes processing but critically the second item does not
 * begin processing until the first is complete. This is the queue functioning as intended.
 *
 * Lastly, research suggests it is technically possible for a fastq to garbage collected before it is fully drained.
 * The chain of references here between the calling application and this queue are complicated. In principle if we
 * have a chain of awaits from where event processing begins it should be impossible to garbage collect before the
 * promises have concluded. The situation becomes less clear if callers are using then, etc. on the promise. Premature
 * garbage collection has not been seen in practice in testing to date.
 */
var OrderedTransferUpdateManager = /** @class */ (function () {
    function OrderedTransferUpdateManager(params) {
        this._queue = fastq.promise(function (options) {
            return params.platformService.updateTransfer(options);
        }, CONCURRENCY);
    }
    OrderedTransferUpdateManager.prototype.updateTransfer = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this._queue.push(options)];
                    case 1: return [2 /*return*/, (_a.sent())];
                }
            });
        });
    };
    return OrderedTransferUpdateManager;
}());
export default OrderedTransferUpdateManager;