vulpes/dist/migrations.js

Job management framework

"use strict";

var removeAllLegacyLogs = function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(service) {
        var logStream, results, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, logItem;

        return regeneratorRuntime.wrap(function _callee$(_context) {
            while (1) {
                switch (_context.prev = _context.next) {
                    case 0:
                        _context.next = 2;
                        return service.storage.streamItems();

                    case 2:
                        logStream = _context.sent;
                        results = [];

                        logStream.on("data", function (entry) {
                            if (entry[ITEM_TYPE] === ITEM_TYPE_LOG_ENTRY) {
                                results.push(entry);
                            }
                        });
                        _context.next = 7;
                        return new Promise(function (resolve, reject) {
                            return endOfStream(logStream, function (err) {
                                if (err) {
                                    return reject(err);
                                }
                                resolve();
                            });
                        });

                    case 7:
                        _iteratorNormalCompletion = true;
                        _didIteratorError = false;
                        _iteratorError = undefined;
                        _context.prev = 10;
                        _iterator = results[Symbol.iterator]();

                    case 12:
                        if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
                            _context.next = 19;
                            break;
                        }

                        logItem = _step.value;
                        _context.next = 16;
                        return service.storage.removeItem(logItem.id);

                    case 16:
                        _iteratorNormalCompletion = true;
                        _context.next = 12;
                        break;

                    case 19:
                        _context.next = 25;
                        break;

                    case 21:
                        _context.prev = 21;
                        _context.t0 = _context["catch"](10);
                        _didIteratorError = true;
                        _iteratorError = _context.t0;

                    case 25:
                        _context.prev = 25;
                        _context.prev = 26;

                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }

                    case 28:
                        _context.prev = 28;

                        if (!_didIteratorError) {
                            _context.next = 31;
                            break;
                        }

                        throw _iteratorError;

                    case 31:
                        return _context.finish(28);

                    case 32:
                        return _context.finish(25);

                    case 33:
                    case "end":
                        return _context.stop();
                }
            }
        }, _callee, this, [[10, 21, 25, 33], [26,, 28, 32]]);
    }));

    return function removeAllLegacyLogs(_x) {
        return _ref.apply(this, arguments);
    };
}();

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

var endOfStream = require("end-of-stream");

var _require = require("./symbols.js"),
    ITEM_TYPE = _require.ITEM_TYPE;

var ITEM_TYPE_LOG_ENTRY = "vulpes/logEntry";

module.exports = {
    removeAllLegacyLogs: removeAllLegacyLogs
};