steam-family-bot-core/lib/api/helper.js

一个用于新版 Steam 家庭的库存监控 Bot 插件

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createProxiedAPIService = exports.APIHelper = void 0;
const interface_1 = require("./interface");
const utils_1 = require("../utils");
class APIHelper {
    constructor() { }
    retryTime = 1;
    _wrapper = false;
    _onRetry = () => { };
    withRetry(times = 1, onRetry) {
        this.retryTime = times;
        this._onRetry = onRetry;
        return this;
    }
    onRetry(func) {
        this._onRetry = func;
        return this;
    }
    async call(block) {
        let result;
        let times = Math.min(this.retryTime, 3);
        let retryTime = 0;
        const wrap = this._wrapper;
        while (times > 0) {
            try {
                result = await block();
                if (wrap) {
                    return interface_1.NetReqResult.success(result);
                }
                return result;
            }
            catch (e) {
                retryTime += 1;
                if (times-- > 1) {
                    this._onRetry?.(retryTime, e);
                    continue;
                }
                await (0, utils_1.sleep)(300);
                if (wrap) {
                    return interface_1.NetReqResult.failed(`retry times reached, ${e}`);
                }
                throw Error('retry times reached', e);
            }
        }
        if (result) {
            return (wrap ? interface_1.NetReqResult.success(result) : result);
        }
        if (wrap) {
            return interface_1.NetReqResult.failed('unknown error');
        }
        throw Error('unknown error');
    }
    wrapperResult() {
        this._wrapper = true;
        return this;
    }
}
exports.APIHelper = APIHelper;
function createProxiedAPIService(instance) {
    ;
    instance.helper = new APIHelper();
    return new Proxy(instance, {
        get(target, prop, receiver) {
            const method = target[prop];
            // target func
            if (typeof method === 'function') {
                return async function (...args) {
                    const result = await target.helper.call(() => method.apply(this, args));
                    return result;
                };
            }
            if (prop in target) {
                return Reflect.get(target, prop, receiver);
            }
            // helper func
            if (prop in target.helper) {
                const v = Reflect.get(target.helper, prop);
                if (typeof v === 'function') {
                    return v;
                }
                return v;
            }
            return undefined;
        },
        set(target, property, value, receiver) {
            if (property in target) {
                return Reflect.set(target, property, value, receiver);
            }
            if (property in target.helper) {
                return Reflect.set(target.helper, property, value);
            }
            return false;
        },
    });
}
exports.createProxiedAPIService = createProxiedAPIService;
//# sourceMappingURL=helper.js.map