zcatalyst-cli/lib/api-timer.js

Command Line Tool for CATALYST

"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 });
const events_1 = __importDefault(require("events"));
const error_1 = __importDefault(require("./error"));
class APITimer extends events_1.default {
    constructor(apiFn, frequency, errorTolerance) {
        super();
        this.apiFn = apiFn;
        this.frequency = frequency || 5000;
        this.interval = null;
        this.execCount = 0;
        this.maxErrors = errorTolerance || 10;
        this.errorCount = 0;
        this.ended = false;
    }
    emit(eventName, ...args) {
        if (this.ended || this.listenerCount(eventName) <= 0) {
            return false;
        }
        return super.emit(eventName, ...args);
    }
    waitForEnd() {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((res, rej) => {
                this.on('end', (e, data) => {
                    if (e) {
                        rej(e);
                        return;
                    }
                    res(data);
                });
            });
        });
    }
    fire() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.ended) {
                this.end();
            }
            try {
                const data = yield this.apiFn();
                this.emit('data', data, ++this.execCount);
            }
            catch (e) {
                this.emit('error', e, ++this.errorCount);
                const err = error_1.default.getErrorInstance(e);
                if (this.errorCount >= this.maxErrors) {
                    this.end(err);
                }
            }
        });
    }
    start() {
        this.fire();
        this.interval = setInterval(this.fire.bind(this), this.frequency);
        return this;
    }
    end(e, data) {
        if (this.interval) {
            clearInterval(this.interval);
            this.execCount = 0;
            this.errorCount = 0;
            this.interval = null;
        }
        this.emit('end', e, data);
        this.ended = true;
    }
}
exports.default = APITimer;