koishi-plugin-beatsaber-bot/lib/service/api/index.js

一个 用于 BeatSaber 的 koishi Bot 插件

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.APIService = void 0;
const beatleader_1 = require("./composed/beatleader");
const base_1 = require("./base");
const beatsaver_1 = require("./composed/beatsaver");
const scoresaber_1 = require("./composed/scoresaber");
const aiosaber_1 = require("./composed/aiosaber");
const netResult_1 = require("./netResult");
const sleep_1 = require("../../utils/sleep");
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;
        }
    });
}
class APIService {
    constructor(ctx, cfg) {
        const bsClient = (0, base_1.bsRequest)(ctx, cfg);
        const blClient = (0, base_1.blRequest)(ctx, cfg);
        const scClient = (0, base_1.scRequest)(ctx, cfg);
        const aioClient = (0, base_1.aioRequest)(ctx, cfg);
        this.BeatLeader = new beatleader_1.BeatLeaderService(bsClient, blClient);
        this.BeatSaver = new beatsaver_1.BeatSaverService(bsClient);
        this.ScoreSaber = new scoresaber_1.ScoreSaberService(bsClient, scClient);
        this.AIOSaber = new aiosaber_1.AIOSaberService(aioClient);
    }
    static create(ctx, cfg) {
        let ins = new APIService(ctx, cfg);
        const proxied = new Proxy(ins, {
            get(target, prop, receiver) {
                const member = target[prop];
                if (member) {
                    return createProxiedAPIService(member);
                }
                return undefined;
            },
            set(target, property, value, receiver) {
                return false;
            }
        });
        return proxied;
    }
}
exports.APIService = APIService;
class APIHelper {
    constructor() {
        this.retryTime = 1;
        this._wrapper = false;
        this._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;
        let wrap = this._wrapper;
        while (times > 0) {
            try {
                result = await block();
                if (wrap) {
                    return netResult_1.NetReqResult.success(result);
                }
                return result;
            }
            catch (e) {
                retryTime += 1;
                if (times-- > 1) {
                    this._onRetry?.(retryTime, e);
                    continue;
                }
                await (0, sleep_1.sleep)(300);
                if (wrap) {
                    return netResult_1.NetReqResult.failed(`retry times reached, ${e}`);
                }
                throw Error('retry times reached', e);
            }
        }
        if (result) {
            return (wrap ? netResult_1.NetReqResult.success(result) : result);
        }
        if (wrap) {
            return netResult_1.NetReqResult.failed("unknown error");
        }
        throw Error('unknown error');
    }
    wrapperResult() {
        this._wrapper = true;
        return this;
    }
}