@backtest-kit/mongo 0.0.1

package/build/index.cjs

@@ -0,0 +1,2255 @@
+'use strict';
+
+var backtestKit = require('backtest-kit');
+var functoolsKit = require('functools-kit');
+var diKit = require('di-kit');
+var mongoose = require('mongoose');
+var ioredis = require('ioredis');
+var diFactory = require('di-factory');
+
+const GLOBAL_CONFIG = {
+    CC_REDIS_HOST: "",
+    CC_REDIS_PORT: 0,
+    CC_REDIS_USER: "",
+    CC_REDIS_PASSWORD: "",
+    CC_MONGO_CONNECTION_STRING: "",
+};
+Object.freeze({ ...GLOBAL_CONFIG });
+const getConfig = () => {
+    const config = {
+        CC_REDIS_HOST: process.env.CC_REDIS_HOST || "127.0.0.1",
+        CC_REDIS_PORT: parseInt(process.env.CC_REDIS_PORT) || 6379,
+        CC_REDIS_USER: process.env.CC_REDIS_USER || "",
+        CC_REDIS_PASSWORD: process.env.CC_REDIS_PASSWORD || "",
+        CC_MONGO_CONNECTION_STRING: process.env.CC_MONGO_CONNECTION_STRING ||
+            "mongodb://localhost:27017/backtest-kit?wtimeoutMS=15000",
+    };
+    if (GLOBAL_CONFIG.CC_REDIS_HOST) {
+        config.CC_REDIS_HOST = GLOBAL_CONFIG.CC_REDIS_HOST;
+    }
+    if (GLOBAL_CONFIG.CC_REDIS_PORT) {
+        config.CC_REDIS_PORT = GLOBAL_CONFIG.CC_REDIS_PORT;
+    }
+    if (GLOBAL_CONFIG.CC_REDIS_USER) {
+        config.CC_REDIS_USER = GLOBAL_CONFIG.CC_REDIS_USER;
+    }
+    if (GLOBAL_CONFIG.CC_REDIS_PASSWORD) {
+        config.CC_REDIS_PASSWORD = GLOBAL_CONFIG.CC_REDIS_PASSWORD;
+    }
+    if (GLOBAL_CONFIG.CC_MONGO_CONNECTION_STRING) {
+        config.CC_MONGO_CONNECTION_STRING =
+            GLOBAL_CONFIG.CC_MONGO_CONNECTION_STRING;
+    }
+    return config;
+};
+const setConfig = (config) => {
+    Object.assign(GLOBAL_CONFIG, config);
+};
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+const { init, inject, provide } = diKit.createActivator("mongo");
+
+const baseServices$1 = {
+    loggerService: Symbol('loggerService'),
+    mongoService: Symbol('mongoService'),
+    redisService: Symbol('redisService'),
+};
+const cacheServices$1 = {
+    candleCacheService: Symbol('candleCacheService'),
+    signalCacheService: Symbol('signalCacheService'),
+    scheduleCacheService: Symbol('scheduleCacheService'),
+    riskCacheService: Symbol('riskCacheService'),
+    partialCacheService: Symbol('partialCacheService'),
+    breakevenCacheService: Symbol('breakevenCacheService'),
+    storageCacheService: Symbol('storageCacheService'),
+    notificationCacheService: Symbol('notificationCacheService'),
+    logCacheService: Symbol('logCacheService'),
+    measureCacheService: Symbol('measureCacheService'),
+    intervalCacheService: Symbol('intervalCacheService'),
+    memoryCacheService: Symbol('memoryCacheService'),
+    recentCacheService: Symbol('recentCacheService'),
+    stateCacheService: Symbol('stateCacheService'),
+    sessionCacheService: Symbol('sessionCacheService'),
+};
+const dbServices$1 = {
+    candleDbService: Symbol('candleDbService'),
+    signalDbService: Symbol('signalDbService'),
+    scheduleDbService: Symbol('scheduleDbService'),
+    riskDbService: Symbol('riskDbService'),
+    partialDbService: Symbol('partialDbService'),
+    breakevenDbService: Symbol('breakevenDbService'),
+    storageDbService: Symbol('storageDbService'),
+    notificationDbService: Symbol('notificationDbService'),
+    logDbService: Symbol('logDbService'),
+    measureDbService: Symbol('measureDbService'),
+    intervalDbService: Symbol('intervalDbService'),
+    memoryDbService: Symbol('memoryDbService'),
+    recentDbService: Symbol('recentDbService'),
+    stateDbService: Symbol('stateDbService'),
+    sessionDbService: Symbol('sessionDbService'),
+};
+const TYPES = {
+    ...baseServices$1,
+    ...cacheServices$1,
+    ...dbServices$1,
+};
+
+const getMongo = functoolsKit.singleshot(async () => {
+    const GLOBAL_CONFIG = getConfig();
+    const mongo = mongoose.connection.readyState === 0
+        ? await mongoose.connect(GLOBAL_CONFIG.CC_MONGO_CONNECTION_STRING)
+        : mongoose;
+    mongo.connection.once("error", (err) => {
+        console.error(functoolsKit.errorData(err));
+    });
+    process.once("SIGINT", async () => {
+        await mongo.connection.close();
+    });
+    return mongo;
+});
+
+const CONNECTED_STATE = 1;
+const CONNECTION_TIMEOUT$1 = 15000;
+const TIMEOUT_SYMBOL$1 = Symbol("timeout");
+const waitForConnect$1 = (mongoose, self) => new Promise((resolve) => {
+    mongoose.connection.on("connected", () => {
+        self.loggerService.log("mongooseService Mongo connected to the database");
+        resolve();
+    });
+});
+class MongooseService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.waitForInit = functoolsKit.singleshot(async () => {
+            this.loggerService.log("mongooseService waitForInit");
+            const mongoose = await getMongo();
+            if (mongoose.connection.readyState === CONNECTED_STATE) {
+                return mongoose;
+            }
+            const result = await Promise.race([
+                waitForConnect$1(mongoose, this),
+                functoolsKit.sleep(CONNECTION_TIMEOUT$1).then(() => TIMEOUT_SYMBOL$1),
+            ]);
+            if (result === TIMEOUT_SYMBOL$1) {
+                this.waitForInit.clear();
+                throw new Error("Mongoose connection timeout");
+            }
+            return mongoose;
+        });
+        this.init = async () => {
+            this.loggerService.log("mongooseService init");
+            const mongoose = await this.waitForInit();
+            mongoose.connection.on("connected", () => {
+                this.loggerService.log("mongooseService Mongo connected to the database");
+            });
+            mongoose.connection.on("error", (err) => {
+                this.loggerService.log("mongooseService Mongo error", {
+                    error: functoolsKit.errorData(err),
+                });
+                throw new (class extends Error {
+                    constructor() {
+                        super("mongooseService Mongo error");
+                        this.originalError = functoolsKit.errorData(err);
+                    }
+                })();
+            });
+            mongoose.connection.on("disconnected", () => {
+                this.loggerService.log("mongooseService disconnected from the database.");
+            });
+            mongoose.connection.on("reconnected", () => {
+                this.loggerService.log("mongooseService reconnected to the database.");
+            });
+            process.on("SIGINT", async () => {
+                await mongoose.connection.close();
+            });
+        };
+    }
+}
+
+const getRedis = functoolsKit.singleshot(() => {
+    const GLOBAL_CONFIG = getConfig();
+    const redis = new ioredis.Redis({
+        host: GLOBAL_CONFIG.CC_REDIS_HOST,
+        port: GLOBAL_CONFIG.CC_REDIS_PORT,
+        username: GLOBAL_CONFIG.CC_REDIS_USER,
+        password: GLOBAL_CONFIG.CC_REDIS_PASSWORD,
+    });
+    setInterval(async () => {
+        await redis.ping();
+    }, 30000);
+    process.on("SIGINT", async () => {
+        await redis.disconnect(false);
+    });
+    return redis;
+});
+
+const CONNECTION_TIMEOUT = 15000;
+const TIMEOUT_SYMBOL = Symbol('timeout');
+const waitForConnect = (redis, self) => new Promise((resolve) => {
+    redis.on('ready', () => {
+        self.loggerService.log("redisService ready");
+        resolve();
+    });
+});
+class RedisService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.waitForInit = functoolsKit.singleshot(async () => {
+            this.loggerService.log("redisService waitForInit");
+            const redis = await getRedis();
+            if (redis.status === 'ready') {
+                return redis;
+            }
+            const result = await Promise.race([
+                waitForConnect(redis, this),
+                functoolsKit.sleep(CONNECTION_TIMEOUT).then(() => TIMEOUT_SYMBOL),
+            ]);
+            if (result === TIMEOUT_SYMBOL) {
+                this.waitForInit.clear();
+                throw new Error("Redis connection timeout");
+            }
+            return redis;
+        });
+        this.init = async () => {
+            this.loggerService.log("redisService init");
+            await this.waitForInit();
+        };
+    }
+}
+
+const ITERATOR_BATCH_SIZE = 100;
+const DEFAULT_TTL_EXPIRE_SECONDS = 5 * 60;
+const BaseMap = diFactory.factory(class BaseMap {
+    constructor(connectionKey, ttlExpireSeconds = DEFAULT_TTL_EXPIRE_SECONDS) {
+        this.connectionKey = connectionKey;
+        this.ttlExpireSeconds = ttlExpireSeconds;
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _getItemKey(key) {
+        return `${this.connectionKey}:${key}`;
+    }
+    async set(key, value) {
+        if (!key)
+            throw new Error("Key cannot be empty");
+        this.loggerService.info(`BaseMap set key=${key}`, { key, value });
+        const redis = await getRedis();
+        const itemKey = this._getItemKey(key);
+        await redis.set(itemKey, value);
+        if (this.ttlExpireSeconds !== -1) {
+            await redis.expire(itemKey, this.ttlExpireSeconds);
+        }
+    }
+    async get(key) {
+        this.loggerService.info(`BaseMap get key=${key}`);
+        if (key === null) {
+            return null;
+        }
+        const redis = await getRedis();
+        const value = await redis.get(this._getItemKey(key));
+        return value ?? null;
+    }
+    async delete(key) {
+        this.loggerService.info(`BaseMap delete key=${key}`);
+        if (key === null) {
+            return null;
+        }
+        const redis = await getRedis();
+        await redis.del(this._getItemKey(key));
+    }
+    async has(key) {
+        this.loggerService.info(`BaseMap has key=${key}`);
+        if (key === null) {
+            return false;
+        }
+        const redis = await getRedis();
+        const exists = await redis.exists(this._getItemKey(key));
+        return exists === 1;
+    }
+    async clear() {
+        this.loggerService.info(`BaseMap clear`);
+        const redis = await getRedis();
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            if (keys?.length) {
+                await redis.del(...keys);
+            }
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+    }
+    async toArray() {
+        this.loggerService.info(`BaseMap toArray`);
+        const redis = await getRedis();
+        const result = [];
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            if (keys?.length) {
+                const values = await redis.mget(...keys);
+                for (let i = 0; i < keys.length; i++) {
+                    if (typeof values[i] === "string") {
+                        const key = keys[i].substring(this.connectionKey.length + 1);
+                        result.push([key, values[i]]);
+                    }
+                }
+            }
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+        return result;
+    }
+    async *iterate() {
+        this.loggerService.info(`BaseMap iterate`);
+        const redis = await getRedis();
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            if (keys?.length) {
+                const values = await redis.mget(...keys);
+                for (let i = 0; i < keys.length; i++) {
+                    if (typeof values[i] === "string") {
+                        const key = keys[i].substring(this.connectionKey.length + 1);
+                        yield [key, values[i]];
+                    }
+                }
+            }
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+    }
+    async *keys() {
+        this.loggerService.info(`BaseMap iterate keys`);
+        const redis = await getRedis();
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            if (keys?.length) {
+                for (const fullKey of keys) {
+                    const key = fullKey.substring(this.connectionKey.length + 1);
+                    yield key;
+                }
+            }
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+    }
+    async *values() {
+        this.loggerService.info(`BaseMap iterate values`);
+        const redis = await getRedis();
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            if (keys?.length) {
+                const values = await redis.mget(...keys);
+                for (const value of values) {
+                    if (typeof value === "string") {
+                        yield value;
+                    }
+                }
+            }
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+    }
+    async size() {
+        this.loggerService.info(`BaseMap size`);
+        const redis = await getRedis();
+        let cursor = 0;
+        const pattern = `${this.connectionKey}:*`;
+        let count = 0;
+        while (true) {
+            const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", ITERATOR_BATCH_SIZE);
+            cursor = nextCursor;
+            count += keys.length;
+            if (cursor === "0" || cursor === 0)
+                break;
+        }
+        return count;
+    }
+});
+
+const REDIS_KEY$e = "candle_cache";
+class CandleCacheService extends BaseMap(REDIS_KEY$e, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, interval, exchangeName, timestamp) {
+        return `${exchangeName}:${symbol}:${interval}:${timestamp}`;
+    }
+    async hasCandleId(symbol, interval, exchangeName, timestamp) {
+        this.loggerService.log("candleCacheService getCandleId", {
+            symbol,
+            interval,
+            exchangeName,
+            timestamp,
+        });
+        const key = this._cacheKey(symbol, interval, exchangeName, timestamp);
+        return await this.has(key);
+    }
+    async getCandleId(symbol, interval, exchangeName, timestamp) {
+        this.loggerService.log("candleCacheService getCandleId", {
+            symbol,
+            interval,
+            exchangeName,
+            timestamp,
+        });
+        const key = this._cacheKey(symbol, interval, exchangeName, timestamp);
+        const id = await super.get(key);
+        return id ?? null;
+    }
+    async setCandleId(row) {
+        this.loggerService.log(`candleCacheService setCandleId`, {
+            symbol: row.symbol,
+            interval: row.interval,
+            timestamp: row.timestamp
+        });
+        const key = this._cacheKey(row.symbol, row.interval, row.exchangeName, row.timestamp);
+        await super.set(key, row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$d = "signal_cache";
+class SignalCacheService extends BaseMap(REDIS_KEY$d, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, strategyName, exchangeName) {
+        return `${exchangeName}:${strategyName}:${symbol}`;
+    }
+    async hasSignalId(symbol, strategyName, exchangeName) {
+        this.loggerService.log("signalCacheService hasSignalId", { symbol, strategyName, exchangeName });
+        return await this.has(this._cacheKey(symbol, strategyName, exchangeName));
+    }
+    async getSignalId(symbol, strategyName, exchangeName) {
+        this.loggerService.log("signalCacheService getSignalId", { symbol, strategyName, exchangeName });
+        const id = await super.get(this._cacheKey(symbol, strategyName, exchangeName));
+        return id ?? null;
+    }
+    async setSignalId(row) {
+        this.loggerService.log("signalCacheService setSignalId", {
+            symbol: row.symbol,
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+        });
+        await super.set(this._cacheKey(row.symbol, row.strategyName, row.exchangeName), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$c = "schedule_cache";
+class ScheduleCacheService extends BaseMap(REDIS_KEY$c, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, strategyName, exchangeName) {
+        return `${exchangeName}:${strategyName}:${symbol}`;
+    }
+    async hasScheduleId(symbol, strategyName, exchangeName) {
+        this.loggerService.log("scheduleCacheService hasScheduleId", { symbol, strategyName, exchangeName });
+        return await this.has(this._cacheKey(symbol, strategyName, exchangeName));
+    }
+    async getScheduleId(symbol, strategyName, exchangeName) {
+        this.loggerService.log("scheduleCacheService getScheduleId", { symbol, strategyName, exchangeName });
+        const id = await super.get(this._cacheKey(symbol, strategyName, exchangeName));
+        return id ?? null;
+    }
+    async setScheduleId(row) {
+        this.loggerService.log("scheduleCacheService setScheduleId", {
+            symbol: row.symbol,
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+        });
+        await super.set(this._cacheKey(row.symbol, row.strategyName, row.exchangeName), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$b = "risk_cache";
+class RiskCacheService extends BaseMap(REDIS_KEY$b, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(riskName, exchangeName) {
+        return `${exchangeName}:${riskName}`;
+    }
+    async hasRiskId(riskName, exchangeName) {
+        this.loggerService.log("riskCacheService hasRiskId", { riskName, exchangeName });
+        return await this.has(this._cacheKey(riskName, exchangeName));
+    }
+    async getRiskId(riskName, exchangeName) {
+        this.loggerService.log("riskCacheService getRiskId", { riskName, exchangeName });
+        const id = await super.get(this._cacheKey(riskName, exchangeName));
+        return id ?? null;
+    }
+    async setRiskId(row) {
+        this.loggerService.log("riskCacheService setRiskId", {
+            riskName: row.riskName,
+            exchangeName: row.exchangeName,
+        });
+        await super.set(this._cacheKey(row.riskName, row.exchangeName), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$a = "partial_cache";
+class PartialCacheService extends BaseMap(REDIS_KEY$a, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, strategyName, exchangeName, signalId) {
+        return `${exchangeName}:${strategyName}:${symbol}:${signalId}`;
+    }
+    async hasPartialId(symbol, strategyName, exchangeName, signalId) {
+        this.loggerService.log("partialCacheService hasPartialId", { symbol, strategyName, exchangeName, signalId });
+        return await this.has(this._cacheKey(symbol, strategyName, exchangeName, signalId));
+    }
+    async getPartialId(symbol, strategyName, exchangeName, signalId) {
+        this.loggerService.log("partialCacheService getPartialId", { symbol, strategyName, exchangeName, signalId });
+        const id = await super.get(this._cacheKey(symbol, strategyName, exchangeName, signalId));
+        return id ?? null;
+    }
+    async setPartialId(row) {
+        this.loggerService.log("partialCacheService setPartialId", {
+            symbol: row.symbol,
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+            signalId: row.signalId,
+        });
+        await super.set(this._cacheKey(row.symbol, row.strategyName, row.exchangeName, row.signalId), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$9 = "breakeven_cache";
+class BreakevenCacheService extends BaseMap(REDIS_KEY$9, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, strategyName, exchangeName, signalId) {
+        return `${exchangeName}:${strategyName}:${symbol}:${signalId}`;
+    }
+    async hasBreakevenId(symbol, strategyName, exchangeName, signalId) {
+        this.loggerService.log("breakevenCacheService hasBreakevenId", { symbol, strategyName, exchangeName, signalId });
+        return await this.has(this._cacheKey(symbol, strategyName, exchangeName, signalId));
+    }
+    async getBreakevenId(symbol, strategyName, exchangeName, signalId) {
+        this.loggerService.log("breakevenCacheService getBreakevenId", { symbol, strategyName, exchangeName, signalId });
+        const id = await super.get(this._cacheKey(symbol, strategyName, exchangeName, signalId));
+        return id ?? null;
+    }
+    async setBreakevenId(row) {
+        this.loggerService.log("breakevenCacheService setBreakevenId", {
+            symbol: row.symbol,
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+            signalId: row.signalId,
+        });
+        await super.set(this._cacheKey(row.symbol, row.strategyName, row.exchangeName, row.signalId), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$8 = "storage_cache";
+class StorageCacheService extends BaseMap(REDIS_KEY$8, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(backtest, signalId) {
+        return `${backtest ? "backtest" : "live"}:${signalId}`;
+    }
+    async hasStorageId(backtest, signalId) {
+        this.loggerService.log("storageCacheService hasStorageId", { backtest, signalId });
+        return await this.has(this._cacheKey(backtest, signalId));
+    }
+    async getStorageId(backtest, signalId) {
+        this.loggerService.log("storageCacheService getStorageId", { backtest, signalId });
+        const id = await super.get(this._cacheKey(backtest, signalId));
+        return id ?? null;
+    }
+    async setStorageId(row) {
+        this.loggerService.log("storageCacheService setStorageId", {
+            backtest: row.backtest,
+            signalId: row.signalId,
+        });
+        await super.set(this._cacheKey(row.backtest, row.signalId), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$7 = "notification_cache";
+class NotificationCacheService extends BaseMap(REDIS_KEY$7, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(backtest, notificationId) {
+        return `${backtest ? "backtest" : "live"}:${notificationId}`;
+    }
+    async hasNotificationId(backtest, notificationId) {
+        this.loggerService.log("notificationCacheService hasNotificationId", { backtest, notificationId });
+        return await this.has(this._cacheKey(backtest, notificationId));
+    }
+    async getNotificationId(backtest, notificationId) {
+        this.loggerService.log("notificationCacheService getNotificationId", { backtest, notificationId });
+        const id = await super.get(this._cacheKey(backtest, notificationId));
+        return id ?? null;
+    }
+    async setNotificationId(row) {
+        this.loggerService.log("notificationCacheService setNotificationId", {
+            backtest: row.backtest,
+            notificationId: row.notificationId,
+        });
+        await super.set(this._cacheKey(row.backtest, row.notificationId), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$6 = "log_cache";
+class LogCacheService extends BaseMap(REDIS_KEY$6, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    async hasLogId(entryId) {
+        this.loggerService.log("logCacheService hasLogId", { entryId });
+        return await this.has(entryId);
+    }
+    async getLogId(entryId) {
+        this.loggerService.log("logCacheService getLogId", { entryId });
+        const id = await super.get(entryId);
+        return id ?? null;
+    }
+    async setLogId(row) {
+        this.loggerService.log("logCacheService setLogId", { entryId: row.entryId });
+        await super.set(row.entryId, row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$5 = "measure_cache";
+class MeasureCacheService extends BaseMap(REDIS_KEY$5, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(bucket, entryKey) {
+        return `${bucket}:${entryKey}`;
+    }
+    async hasMeasureId(bucket, entryKey) {
+        this.loggerService.log("measureCacheService hasMeasureId", { bucket, entryKey });
+        return await this.has(this._cacheKey(bucket, entryKey));
+    }
+    async getMeasureId(bucket, entryKey) {
+        this.loggerService.log("measureCacheService getMeasureId", { bucket, entryKey });
+        const id = await super.get(this._cacheKey(bucket, entryKey));
+        return id ?? null;
+    }
+    async setMeasureId(row) {
+        this.loggerService.log("measureCacheService setMeasureId", { bucket: row.bucket, entryKey: row.entryKey });
+        await super.set(this._cacheKey(row.bucket, row.entryKey), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$4 = "interval_cache";
+class IntervalCacheService extends BaseMap(REDIS_KEY$4, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(bucket, entryKey) {
+        return `${bucket}:${entryKey}`;
+    }
+    async hasIntervalId(bucket, entryKey) {
+        this.loggerService.log("intervalCacheService hasIntervalId", { bucket, entryKey });
+        return await this.has(this._cacheKey(bucket, entryKey));
+    }
+    async getIntervalId(bucket, entryKey) {
+        this.loggerService.log("intervalCacheService getIntervalId", { bucket, entryKey });
+        const id = await super.get(this._cacheKey(bucket, entryKey));
+        return id ?? null;
+    }
+    async setIntervalId(row) {
+        this.loggerService.log("intervalCacheService setIntervalId", { bucket: row.bucket, entryKey: row.entryKey });
+        await super.set(this._cacheKey(row.bucket, row.entryKey), row.id);
+        return row.id;
+    }
+    async deleteIntervalId(bucket, entryKey) {
+        this.loggerService.log("intervalCacheService deleteIntervalId", { bucket, entryKey });
+        await super.delete(this._cacheKey(bucket, entryKey));
+    }
+}
+
+const REDIS_KEY$3 = "memory_cache";
+class MemoryCacheService extends BaseMap(REDIS_KEY$3, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(signalId, bucketName, memoryId) {
+        return `${signalId}:${bucketName}:${memoryId}`;
+    }
+    async hasMemoryEntryId(signalId, bucketName, memoryId) {
+        this.loggerService.log("memoryCacheService hasMemoryEntryId", { signalId, bucketName, memoryId });
+        return await this.has(this._cacheKey(signalId, bucketName, memoryId));
+    }
+    async getMemoryEntryId(signalId, bucketName, memoryId) {
+        this.loggerService.log("memoryCacheService getMemoryEntryId", { signalId, bucketName, memoryId });
+        const id = await super.get(this._cacheKey(signalId, bucketName, memoryId));
+        return id ?? null;
+    }
+    async setMemoryEntryId(row) {
+        this.loggerService.log("memoryCacheService setMemoryEntryId", {
+            signalId: row.signalId,
+            bucketName: row.bucketName,
+            memoryId: row.memoryId,
+        });
+        await super.set(this._cacheKey(row.signalId, row.bucketName, row.memoryId), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$2 = "recent_cache";
+class RecentCacheService extends BaseMap(REDIS_KEY$2, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(symbol, strategyName, exchangeName, frameName, backtest) {
+        return `${backtest ? "backtest" : "live"}:${exchangeName}:${strategyName}:${frameName}:${symbol}`;
+    }
+    async hasRecentId(symbol, strategyName, exchangeName, frameName, backtest) {
+        this.loggerService.log("recentCacheService hasRecentId", { symbol, strategyName, exchangeName, frameName, backtest });
+        return await this.has(this._cacheKey(symbol, strategyName, exchangeName, frameName, backtest));
+    }
+    async getRecentId(symbol, strategyName, exchangeName, frameName, backtest) {
+        this.loggerService.log("recentCacheService getRecentId", { symbol, strategyName, exchangeName, frameName, backtest });
+        const id = await super.get(this._cacheKey(symbol, strategyName, exchangeName, frameName, backtest));
+        return id ?? null;
+    }
+    async setRecentId(row) {
+        this.loggerService.log("recentCacheService setRecentId", {
+            symbol: row.symbol,
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+            frameName: row.frameName,
+            backtest: row.backtest,
+        });
+        await super.set(this._cacheKey(row.symbol, row.strategyName, row.exchangeName, row.frameName, row.backtest), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY$1 = "state_cache";
+class StateCacheService extends BaseMap(REDIS_KEY$1, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(signalId, bucketName) {
+        return `${signalId}:${bucketName}`;
+    }
+    async hasStateId(signalId, bucketName) {
+        this.loggerService.log("stateCacheService hasStateId", { signalId, bucketName });
+        return await this.has(this._cacheKey(signalId, bucketName));
+    }
+    async getStateId(signalId, bucketName) {
+        this.loggerService.log("stateCacheService getStateId", { signalId, bucketName });
+        const id = await super.get(this._cacheKey(signalId, bucketName));
+        return id ?? null;
+    }
+    async setStateId(row) {
+        this.loggerService.log("stateCacheService setStateId", {
+            signalId: row.signalId,
+            bucketName: row.bucketName,
+        });
+        await super.set(this._cacheKey(row.signalId, row.bucketName), row.id);
+        return row.id;
+    }
+}
+
+const REDIS_KEY = "session_cache";
+class SessionCacheService extends BaseMap(REDIS_KEY, -1) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    _cacheKey(strategyName, exchangeName, frameName) {
+        return `${exchangeName}:${strategyName}:${frameName}`;
+    }
+    async hasSessionId(strategyName, exchangeName, frameName) {
+        this.loggerService.log("sessionCacheService hasSessionId", { strategyName, exchangeName, frameName });
+        return await this.has(this._cacheKey(strategyName, exchangeName, frameName));
+    }
+    async getSessionId(strategyName, exchangeName, frameName) {
+        this.loggerService.log("sessionCacheService getSessionId", { strategyName, exchangeName, frameName });
+        const id = await super.get(this._cacheKey(strategyName, exchangeName, frameName));
+        return id ?? null;
+    }
+    async setSessionId(row) {
+        this.loggerService.log("sessionCacheService setSessionId", {
+            strategyName: row.strategyName,
+            exchangeName: row.exchangeName,
+            frameName: row.frameName,
+        });
+        await super.set(this._cacheKey(row.strategyName, row.exchangeName, row.frameName), row.id);
+        return row.id;
+    }
+}
+
+const readTransform = (data) => ({
+    ...data,
+    id: String(data._id),
+});
+
+function omit(obj, keys) {
+    const excluded = new Set(keys);
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !excluded.has(key)));
+}
+
+const FIND_ALL_LIMIT = 1000;
+const BaseCRUD = diFactory.factory(class {
+    constructor(TargetModel) {
+        this.TargetModel = TargetModel;
+        this.loggerService = inject(TYPES.loggerService);
+    }
+    async create(dto) {
+        this.loggerService.info(`BaseCRUD create modelName=${this.TargetModel.modelName}`, {
+            dto,
+        });
+        const item = await this.TargetModel.create(dto);
+        return readTransform(item.toJSON());
+    }
+    async update(id, dto) {
+        this.loggerService.info(`BaseCRUD update modelName=${this.TargetModel.modelName}`, {
+            id,
+            dto,
+        });
+        const updatedDocument = await this.TargetModel.findByIdAndUpdate(id, omit(dto, "id"), {
+            new: true,
+            runValidators: true,
+        });
+        if (!updatedDocument) {
+            throw new Error(`${this.TargetModel.modelName} not found`);
+        }
+        return readTransform(updatedDocument.toJSON());
+    }
+    async findById(id) {
+        this.loggerService.info(`BaseCRUD findById modelName=${this.TargetModel.modelName}`, {
+            id,
+        });
+        const item = await this.TargetModel.findById(id);
+        if (!item) {
+            throw new Error(`${this.TargetModel.modelName} not found`);
+        }
+        return readTransform(item.toJSON());
+    }
+    async findByFilter(filterData, sort) {
+        this.loggerService.info(`BaseCRUD findByFilter modelName=${this.TargetModel.modelName}`, {
+            filterData,
+            sort,
+        });
+        const item = await this.TargetModel.findOne(filterData, null, {
+            sort,
+        });
+        if (item) {
+            return readTransform(item.toJSON());
+        }
+        return null;
+    }
+    async findAll(filterData = {}, limit = FIND_ALL_LIMIT) {
+        this.loggerService.info(`BaseCRUD findAll modelName=${this.TargetModel.modelName}`, {
+            filterData,
+        });
+        const documents = await this.TargetModel.find(filterData)
+            .sort({ date: -1 })
+            .limit(limit);
+        return documents.map((doc) => readTransform(doc.toJSON()));
+    }
+    async *iterate(filterData = {}, sort) {
+        this.loggerService.info(`BaseCRUD iterate modelName=${this.TargetModel.modelName}`, {
+            filterData,
+            sort,
+        });
+        for await (const document of this.TargetModel.find(filterData, null, {
+            sort,
+        })) {
+            yield readTransform(document.toJSON());
+        }
+    }
+    async paginate(filterData, pagination, sort) {
+        this.loggerService.info(`BaseCRUD paginate modelName=${this.TargetModel.modelName}`, {
+            filterData,
+            pagination,
+            sort,
+        });
+        const itemsRaw = await this.TargetModel.find(filterData, null, {
+            sort,
+        })
+            .skip(pagination.offset)
+            .limit(pagination.limit);
+        const items = itemsRaw.map((item) => item.toJSON());
+        const total = await this.TargetModel.countDocuments(filterData);
+        return {
+            rows: items.map(readTransform),
+            total: total,
+        };
+    }
+});
+
+const INTERVAL_ENUM = [
+    "1m",
+    "3m",
+    "5m",
+    "15m",
+    "30m",
+    "1h",
+    "2h",
+    "4h",
+    "6h",
+    "8h",
+    "1d",
+];
+const CandleSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    interval: { type: String, required: true, enum: INTERVAL_ENUM, index: true },
+    timestamp: { type: Number, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    open: { type: Number, required: true },
+    high: { type: Number, required: true },
+    low: { type: Number, required: true },
+    close: { type: Number, required: true },
+    volume: { type: Number, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" } });
+CandleSchema.index({ symbol: 1, interval: 1, timestamp: 1 }, { unique: true });
+const CandleModel = mongoose.model("candle-items", CandleSchema);
+
+const EXCHANGE_NAME = "ccxt_binance";
+class CandleDbService extends BaseCRUD(CandleModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.candleCacheService = inject(TYPES.candleCacheService);
+        this.create = async (dto) => {
+            this.loggerService.log("candleDbService create", { dto });
+            const filter = {
+                symbol: dto.symbol,
+                interval: dto.interval,
+                timestamp: dto.timestamp,
+            };
+            const insertOnly = {
+                exchangeName: EXCHANGE_NAME,
+                open: dto.open,
+                high: dto.high,
+                low: dto.low,
+                close: dto.close,
+                volume: dto.volume,
+            };
+            const document = await CandleModel.findOneAndUpdate(filter, { $setOnInsert: insertOnly }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.candleCacheService.setCandleId(result);
+            return result;
+        };
+        this.hasCandle = async (symbol, interval, timestamp) => {
+            this.loggerService.log("candleDbService hasCandle", {
+                symbol,
+                interval,
+                timestamp,
+            });
+            const hasInCache = await this.candleCacheService.hasCandleId(symbol, interval, EXCHANGE_NAME, timestamp);
+            if (hasInCache) {
+                return true;
+            }
+            const hasInMongo = await this.findBySymbolIntervalTimestamp(symbol, interval, timestamp);
+            if (hasInMongo) {
+                return true;
+            }
+            return false;
+        };
+        this.findBySymbolIntervalTimestamp = async (symbol, interval, timestamp) => {
+            this.loggerService.log("candleDbService findBySymbolIntervalTimestamp", { symbol, interval, timestamp });
+            try {
+                const cachedId = await this.candleCacheService.getCandleId(symbol, interval, EXCHANGE_NAME, timestamp);
+                return await super.findById(cachedId);
+            }
+            catch {
+                const result = await super.findByFilter({ symbol, interval, exchangeName: EXCHANGE_NAME, timestamp });
+                if (result) {
+                    await this.candleCacheService.setCandleId(result);
+                }
+                return result;
+            }
+        };
+    }
+}
+
+const SignalSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+SignalSchema.index({ symbol: 1, strategyName: 1, exchangeName: 1 }, { unique: true });
+const SignalModel = mongoose.model("signal-items", SignalSchema);
+
+class SignalDbService extends BaseCRUD(SignalModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.signalCacheService = inject(TYPES.signalCacheService);
+        this.upsert = async (symbol, strategyName, exchangeName, payload) => {
+            this.loggerService.log("signalDbService upsert", { symbol, strategyName, exchangeName });
+            const filter = { symbol, strategyName, exchangeName };
+            const document = await SignalModel.findOneAndUpdate(filter, { $set: { payload } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.signalCacheService.setSignalId(result);
+        };
+        this.findByContext = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("signalDbService findByContext", { symbol, strategyName, exchangeName });
+            try {
+                const cachedId = await this.signalCacheService.getSignalId(symbol, strategyName, exchangeName);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ symbol, strategyName, exchangeName });
+            if (result) {
+                await this.signalCacheService.setSignalId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const ScheduleSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+ScheduleSchema.index({ symbol: 1, strategyName: 1, exchangeName: 1 }, { unique: true });
+const ScheduleModel = mongoose.model("schedule-items", ScheduleSchema);
+
+class ScheduleDbService extends BaseCRUD(ScheduleModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.scheduleCacheService = inject(TYPES.scheduleCacheService);
+        this.upsert = async (symbol, strategyName, exchangeName, payload) => {
+            this.loggerService.log("scheduleDbService upsert", { symbol, strategyName, exchangeName });
+            const filter = { symbol, strategyName, exchangeName };
+            const document = await ScheduleModel.findOneAndUpdate(filter, { $set: { payload } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.scheduleCacheService.setScheduleId(result);
+        };
+        this.findByContext = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("scheduleDbService findByContext", { symbol, strategyName, exchangeName });
+            try {
+                const cachedId = await this.scheduleCacheService.getScheduleId(symbol, strategyName, exchangeName);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ symbol, strategyName, exchangeName });
+            if (result) {
+                await this.scheduleCacheService.setScheduleId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const RiskSchema = new mongoose.Schema({
+    riskName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    positions: { type: mongoose.Schema.Types.Mixed, required: true, default: [] },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+RiskSchema.index({ riskName: 1, exchangeName: 1 }, { unique: true });
+const RiskModel = mongoose.model("risk-items", RiskSchema);
+
+class RiskDbService extends BaseCRUD(RiskModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.riskCacheService = inject(TYPES.riskCacheService);
+        this.upsert = async (riskName, exchangeName, positions, when) => {
+            this.loggerService.log("riskDbService upsert", { riskName, exchangeName, when });
+            const filter = { riskName, exchangeName };
+            const document = await RiskModel.findOneAndUpdate(filter, { $set: { positions, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.riskCacheService.setRiskId(result);
+        };
+        this.findByContext = async (riskName, exchangeName) => {
+            this.loggerService.log("riskDbService findByContext", { riskName, exchangeName });
+            try {
+                const cachedId = await this.riskCacheService.getRiskId(riskName, exchangeName);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ riskName, exchangeName });
+            if (result) {
+                await this.riskCacheService.setRiskId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const PartialSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    signalId: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true, default: {} },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+PartialSchema.index({ symbol: 1, strategyName: 1, exchangeName: 1, signalId: 1 }, { unique: true });
+const PartialModel = mongoose.model("partial-items", PartialSchema);
+
+class PartialDbService extends BaseCRUD(PartialModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.partialCacheService = inject(TYPES.partialCacheService);
+        this.upsert = async (symbol, strategyName, exchangeName, signalId, payload, when) => {
+            this.loggerService.log("partialDbService upsert", { symbol, strategyName, exchangeName, signalId, when });
+            const filter = { symbol, strategyName, exchangeName, signalId };
+            const document = await PartialModel.findOneAndUpdate(filter, { $set: { payload, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.partialCacheService.setPartialId(result);
+        };
+        this.findByContext = async (symbol, strategyName, exchangeName, signalId) => {
+            this.loggerService.log("partialDbService findByContext", { symbol, strategyName, exchangeName, signalId });
+            try {
+                const cachedId = await this.partialCacheService.getPartialId(symbol, strategyName, exchangeName, signalId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ symbol, strategyName, exchangeName, signalId });
+            if (result) {
+                await this.partialCacheService.setPartialId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const BreakevenSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    signalId: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true, default: {} },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+BreakevenSchema.index({ symbol: 1, strategyName: 1, exchangeName: 1, signalId: 1 }, { unique: true });
+const BreakevenModel = mongoose.model("breakeven-items", BreakevenSchema);
+
+class BreakevenDbService extends BaseCRUD(BreakevenModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.breakevenCacheService = inject(TYPES.breakevenCacheService);
+        this.upsert = async (symbol, strategyName, exchangeName, signalId, payload, when) => {
+            this.loggerService.log("breakevenDbService upsert", { symbol, strategyName, exchangeName, signalId, when });
+            const filter = { symbol, strategyName, exchangeName, signalId };
+            const document = await BreakevenModel.findOneAndUpdate(filter, { $set: { payload, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.breakevenCacheService.setBreakevenId(result);
+        };
+        this.findByContext = async (symbol, strategyName, exchangeName, signalId) => {
+            this.loggerService.log("breakevenDbService findByContext", { symbol, strategyName, exchangeName, signalId });
+            try {
+                const cachedId = await this.breakevenCacheService.getBreakevenId(symbol, strategyName, exchangeName, signalId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ symbol, strategyName, exchangeName, signalId });
+            if (result) {
+                await this.breakevenCacheService.setBreakevenId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const StorageSchema = new mongoose.Schema({
+    backtest: { type: Boolean, required: true, index: true },
+    signalId: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+StorageSchema.index({ backtest: 1, signalId: 1 }, { unique: true });
+const StorageModel = mongoose.model("storage-items", StorageSchema);
+
+class StorageDbService extends BaseCRUD(StorageModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.storageCacheService = inject(TYPES.storageCacheService);
+        this.upsert = async (backtest, signalId, payload) => {
+            this.loggerService.log("storageDbService upsert", { backtest, signalId });
+            const filter = { backtest, signalId };
+            const document = await StorageModel.findOneAndUpdate(filter, { $set: { payload } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.storageCacheService.setStorageId(result);
+        };
+        this.findBySignalId = async (backtest, signalId) => {
+            this.loggerService.log("storageDbService findBySignalId", { backtest, signalId });
+            try {
+                const cachedId = await this.storageCacheService.getStorageId(backtest, signalId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ backtest, signalId });
+            if (result) {
+                await this.storageCacheService.setStorageId(result);
+            }
+            return result;
+        };
+        this.listByMode = async (backtest) => {
+            this.loggerService.log("storageDbService listByMode", { backtest });
+            return await super.findAll({ backtest });
+        };
+    }
+}
+
+const NotificationSchema = new mongoose.Schema({
+    backtest: { type: Boolean, required: true, index: true },
+    notificationId: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+NotificationSchema.index({ backtest: 1, notificationId: 1 }, { unique: true });
+const NotificationModel = mongoose.model("notification-items", NotificationSchema);
+
+const LIST_LIMIT$1 = 200;
+class NotificationDbService extends BaseCRUD(NotificationModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.notificationCacheService = inject(TYPES.notificationCacheService);
+        this.upsert = async (backtest, notificationId, payload) => {
+            this.loggerService.log("notificationDbService upsert", { backtest, notificationId });
+            const filter = { backtest, notificationId };
+            const document = await NotificationModel.findOneAndUpdate(filter, { $set: { payload } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.notificationCacheService.setNotificationId(result);
+        };
+        this.findByNotificationId = async (backtest, notificationId) => {
+            this.loggerService.log("notificationDbService findByNotificationId", { backtest, notificationId });
+            try {
+                const cachedId = await this.notificationCacheService.getNotificationId(backtest, notificationId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ backtest, notificationId });
+            if (result) {
+                await this.notificationCacheService.setNotificationId(result);
+            }
+            return result;
+        };
+        this.listByMode = async (backtest) => {
+            this.loggerService.log("notificationDbService listByMode", { backtest });
+            const documents = await NotificationModel.find({ backtest })
+                .sort({ createDate: -1 })
+                .limit(LIST_LIMIT$1);
+            return documents.map((doc) => readTransform(doc.toJSON()));
+        };
+    }
+}
+
+const LogSchema = new mongoose.Schema({
+    entryId: { type: String, required: true, unique: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+const LogModel = mongoose.model("log-items", LogSchema);
+
+const LIST_LIMIT = 200;
+class LogDbService extends BaseCRUD(LogModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.logCacheService = inject(TYPES.logCacheService);
+        this.upsert = async (entryId, payload) => {
+            this.loggerService.log("logDbService upsert", { entryId });
+            const filter = { entryId };
+            const document = await LogModel.findOneAndUpdate(filter, { $set: { payload } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.logCacheService.setLogId(result);
+        };
+        this.findByEntryId = async (entryId) => {
+            this.loggerService.log("logDbService findByEntryId", { entryId });
+            try {
+                const cachedId = await this.logCacheService.getLogId(entryId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ entryId });
+            if (result) {
+                await this.logCacheService.setLogId(result);
+            }
+            return result;
+        };
+        this.listAll = async () => {
+            this.loggerService.log("logDbService listAll");
+            const documents = await LogModel.find({})
+                .sort({ createDate: -1 })
+                .limit(LIST_LIMIT);
+            return documents.map((doc) => readTransform(doc.toJSON()));
+        };
+    }
+}
+
+const MeasureSchema = new mongoose.Schema({
+    bucket: { type: String, required: true, index: true },
+    entryKey: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    removed: { type: Boolean, required: true, default: false, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+MeasureSchema.index({ bucket: 1, entryKey: 1 }, { unique: true });
+const MeasureModel = mongoose.model("measure-items", MeasureSchema);
+
+class MeasureDbService extends BaseCRUD(MeasureModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.measureCacheService = inject(TYPES.measureCacheService);
+        this.upsert = async (bucket, entryKey, payload) => {
+            this.loggerService.log("measureDbService upsert", { bucket, entryKey });
+            const filter = { bucket, entryKey };
+            const document = await MeasureModel.findOneAndUpdate(filter, { $set: { payload, removed: payload.removed } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.measureCacheService.setMeasureId(result);
+        };
+        this.findByKey = async (bucket, entryKey) => {
+            this.loggerService.log("measureDbService findByKey", { bucket, entryKey });
+            try {
+                const cachedId = await this.measureCacheService.getMeasureId(bucket, entryKey);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ bucket, entryKey });
+            if (result) {
+                await this.measureCacheService.setMeasureId(result);
+            }
+            return result;
+        };
+        this.softRemove = async (bucket, entryKey) => {
+            this.loggerService.log("measureDbService softRemove", { bucket, entryKey });
+            const filter = { bucket, entryKey };
+            const document = await MeasureModel.findOneAndUpdate(filter, { $set: { removed: true, "payload.removed": true } }, { new: true });
+            if (!document) {
+                return;
+            }
+            const result = readTransform(document.toJSON());
+            await this.measureCacheService.setMeasureId(result);
+        };
+        this.listKeys = async (bucket) => {
+            this.loggerService.log("measureDbService listKeys", { bucket });
+            const rows = await super.findAll({ bucket, removed: false });
+            return rows.map((row) => row.entryKey);
+        };
+    }
+}
+
+const IntervalSchema = new mongoose.Schema({
+    bucket: { type: String, required: true, index: true },
+    entryKey: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    removed: { type: Boolean, required: true, default: false, index: true },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+IntervalSchema.index({ bucket: 1, entryKey: 1 }, { unique: true });
+const IntervalModel = mongoose.model("interval-items", IntervalSchema);
+
+class IntervalDbService extends BaseCRUD(IntervalModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.intervalCacheService = inject(TYPES.intervalCacheService);
+        this.upsert = async (bucket, entryKey, payload, when) => {
+            this.loggerService.log("intervalDbService upsert", { bucket, entryKey, when });
+            const filter = { bucket, entryKey };
+            const document = await IntervalModel.findOneAndUpdate(filter, { $set: { payload, removed: payload.removed, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.intervalCacheService.setIntervalId(result);
+        };
+        this.findByKey = async (bucket, entryKey) => {
+            this.loggerService.log("intervalDbService findByKey", { bucket, entryKey });
+            try {
+                const cachedId = await this.intervalCacheService.getIntervalId(bucket, entryKey);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ bucket, entryKey });
+            if (result) {
+                await this.intervalCacheService.setIntervalId(result);
+            }
+            return result;
+        };
+        this.softRemove = async (bucket, entryKey) => {
+            this.loggerService.log("intervalDbService softRemove", { bucket, entryKey });
+            const filter = { bucket, entryKey };
+            const document = await IntervalModel.findOneAndUpdate(filter, { $set: { removed: true, "payload.removed": true } }, { new: true });
+            if (!document) {
+                return;
+            }
+            const result = readTransform(document.toJSON());
+            await this.intervalCacheService.setIntervalId(result);
+        };
+        this.listKeys = async (bucket) => {
+            this.loggerService.log("intervalDbService listKeys", { bucket });
+            const rows = await super.findAll({ bucket, removed: false });
+            return rows.map((row) => row.entryKey);
+        };
+        this.clearBucket = async (bucket) => {
+            this.loggerService.log("intervalDbService clearBucket", { bucket });
+            const rows = await super.findAll({ bucket });
+            for (const row of rows) {
+                await this.intervalCacheService.deleteIntervalId(bucket, row.entryKey);
+            }
+            await IntervalModel.deleteMany({ bucket });
+        };
+    }
+}
+
+const MemorySchema = new mongoose.Schema({
+    signalId: { type: String, required: true, index: true },
+    bucketName: { type: String, required: true, index: true },
+    memoryId: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    removed: { type: Boolean, required: true, default: false, index: true },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+MemorySchema.index({ signalId: 1, bucketName: 1, memoryId: 1 }, { unique: true });
+const MemoryModel = mongoose.model("memory-items", MemorySchema);
+
+class MemoryDbService extends BaseCRUD(MemoryModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.memoryCacheService = inject(TYPES.memoryCacheService);
+        this.upsert = async (signalId, bucketName, memoryId, payload, when) => {
+            this.loggerService.log("memoryDbService upsert", { signalId, bucketName, memoryId, when });
+            const filter = { signalId, bucketName, memoryId };
+            const document = await MemoryModel.findOneAndUpdate(filter, { $set: { payload, removed: payload.removed, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.memoryCacheService.setMemoryEntryId(result);
+        };
+        this.findByMemoryId = async (signalId, bucketName, memoryId) => {
+            this.loggerService.log("memoryDbService findByMemoryId", { signalId, bucketName, memoryId });
+            try {
+                const cachedId = await this.memoryCacheService.getMemoryEntryId(signalId, bucketName, memoryId);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ signalId, bucketName, memoryId });
+            if (result) {
+                await this.memoryCacheService.setMemoryEntryId(result);
+            }
+            return result;
+        };
+        this.hasMemoryEntry = async (signalId, bucketName, memoryId) => {
+            this.loggerService.log("memoryDbService hasMemoryEntry", { signalId, bucketName, memoryId });
+            if (await this.memoryCacheService.hasMemoryEntryId(signalId, bucketName, memoryId)) {
+                return true;
+            }
+            const row = await super.findByFilter({ signalId, bucketName, memoryId });
+            if (row) {
+                await this.memoryCacheService.setMemoryEntryId(row);
+                return true;
+            }
+            return false;
+        };
+        this.softRemove = async (signalId, bucketName, memoryId) => {
+            this.loggerService.log("memoryDbService softRemove", { signalId, bucketName, memoryId });
+            const filter = { signalId, bucketName, memoryId };
+            const document = await MemoryModel.findOneAndUpdate(filter, { $set: { removed: true, "payload.removed": true } }, { new: true });
+            if (!document) {
+                return;
+            }
+            const result = readTransform(document.toJSON());
+            await this.memoryCacheService.setMemoryEntryId(result);
+        };
+        this.listEntries = async (signalId, bucketName) => {
+            this.loggerService.log("memoryDbService listEntries", { signalId, bucketName });
+            return await super.findAll({ signalId, bucketName, removed: false });
+        };
+    }
+}
+
+const RecentSchema = new mongoose.Schema({
+    symbol: { type: String, required: true, index: true },
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    frameName: { type: String, required: true, index: true },
+    backtest: { type: Boolean, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+RecentSchema.index({ symbol: 1, strategyName: 1, exchangeName: 1, frameName: 1, backtest: 1 }, { unique: true });
+const RecentModel = mongoose.model("recent-items", RecentSchema);
+
+class RecentDbService extends BaseCRUD(RecentModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.recentCacheService = inject(TYPES.recentCacheService);
+        this.upsert = async (symbol, strategyName, exchangeName, frameName, backtest, payload, when) => {
+            this.loggerService.log("recentDbService upsert", { symbol, strategyName, exchangeName, frameName, backtest, when });
+            const filter = { symbol, strategyName, exchangeName, frameName, backtest };
+            const document = await RecentModel.findOneAndUpdate(filter, { $set: { payload, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.recentCacheService.setRecentId(result);
+        };
+        this.findByContext = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("recentDbService findByContext", { symbol, strategyName, exchangeName, frameName, backtest });
+            try {
+                const cachedId = await this.recentCacheService.getRecentId(symbol, strategyName, exchangeName, frameName, backtest);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ symbol, strategyName, exchangeName, frameName, backtest });
+            if (result) {
+                await this.recentCacheService.setRecentId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const StateSchema = new mongoose.Schema({
+    signalId: { type: String, required: true, index: true },
+    bucketName: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+StateSchema.index({ signalId: 1, bucketName: 1 }, { unique: true });
+const StateModel = mongoose.model("state-items", StateSchema);
+
+class StateDbService extends BaseCRUD(StateModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.stateCacheService = inject(TYPES.stateCacheService);
+        this.upsert = async (signalId, bucketName, payload, when) => {
+            this.loggerService.log("stateDbService upsert", { signalId, bucketName, when });
+            const filter = { signalId, bucketName };
+            const document = await StateModel.findOneAndUpdate(filter, { $set: { payload, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.stateCacheService.setStateId(result);
+        };
+        this.findByContext = async (signalId, bucketName) => {
+            this.loggerService.log("stateDbService findByContext", { signalId, bucketName });
+            try {
+                const cachedId = await this.stateCacheService.getStateId(signalId, bucketName);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ signalId, bucketName });
+            if (result) {
+                await this.stateCacheService.setStateId(result);
+            }
+            return result;
+        };
+    }
+}
+
+const SessionSchema = new mongoose.Schema({
+    strategyName: { type: String, required: true, index: true },
+    exchangeName: { type: String, required: true, index: true },
+    frameName: { type: String, required: true, index: true },
+    payload: { type: mongoose.Schema.Types.Mixed, required: true },
+    when: { type: Number, required: true, index: true },
+}, { timestamps: { createdAt: "createDate", updatedAt: "updatedDate" }, minimize: false });
+SessionSchema.index({ strategyName: 1, exchangeName: 1, frameName: 1 }, { unique: true });
+const SessionModel = mongoose.model("session-items", SessionSchema);
+
+class SessionDbService extends BaseCRUD(SessionModel) {
+    constructor() {
+        super(...arguments);
+        this.loggerService = inject(TYPES.loggerService);
+        this.sessionCacheService = inject(TYPES.sessionCacheService);
+        this.upsert = async (strategyName, exchangeName, frameName, payload, when) => {
+            this.loggerService.log("sessionDbService upsert", { strategyName, exchangeName, frameName, when });
+            const filter = { strategyName, exchangeName, frameName };
+            const document = await SessionModel.findOneAndUpdate(filter, { $set: { payload, when: when.getTime() } }, { upsert: true, new: true, setDefaultsOnInsert: true });
+            const result = readTransform(document.toJSON());
+            await this.sessionCacheService.setSessionId(result);
+        };
+        this.findByContext = async (strategyName, exchangeName, frameName) => {
+            this.loggerService.log("sessionDbService findByContext", { strategyName, exchangeName, frameName });
+            try {
+                const cachedId = await this.sessionCacheService.getSessionId(strategyName, exchangeName, frameName);
+                if (cachedId) {
+                    return await super.findById(cachedId);
+                }
+            }
+            catch {
+            }
+            const result = await super.findByFilter({ strategyName, exchangeName, frameName });
+            if (result) {
+                await this.sessionCacheService.setSessionId(result);
+            }
+            return result;
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+    provide(TYPES.mongoService, () => new MongooseService());
+    provide(TYPES.redisService, () => new RedisService());
+}
+{
+    provide(TYPES.candleCacheService, () => new CandleCacheService());
+    provide(TYPES.signalCacheService, () => new SignalCacheService());
+    provide(TYPES.scheduleCacheService, () => new ScheduleCacheService());
+    provide(TYPES.riskCacheService, () => new RiskCacheService());
+    provide(TYPES.partialCacheService, () => new PartialCacheService());
+    provide(TYPES.breakevenCacheService, () => new BreakevenCacheService());
+    provide(TYPES.storageCacheService, () => new StorageCacheService());
+    provide(TYPES.notificationCacheService, () => new NotificationCacheService());
+    provide(TYPES.logCacheService, () => new LogCacheService());
+    provide(TYPES.measureCacheService, () => new MeasureCacheService());
+    provide(TYPES.intervalCacheService, () => new IntervalCacheService());
+    provide(TYPES.memoryCacheService, () => new MemoryCacheService());
+    provide(TYPES.recentCacheService, () => new RecentCacheService());
+    provide(TYPES.stateCacheService, () => new StateCacheService());
+    provide(TYPES.sessionCacheService, () => new SessionCacheService());
+}
+{
+    provide(TYPES.candleDbService, () => new CandleDbService());
+    provide(TYPES.signalDbService, () => new SignalDbService());
+    provide(TYPES.scheduleDbService, () => new ScheduleDbService());
+    provide(TYPES.riskDbService, () => new RiskDbService());
+    provide(TYPES.partialDbService, () => new PartialDbService());
+    provide(TYPES.breakevenDbService, () => new BreakevenDbService());
+    provide(TYPES.storageDbService, () => new StorageDbService());
+    provide(TYPES.notificationDbService, () => new NotificationDbService());
+    provide(TYPES.logDbService, () => new LogDbService());
+    provide(TYPES.measureDbService, () => new MeasureDbService());
+    provide(TYPES.intervalDbService, () => new IntervalDbService());
+    provide(TYPES.memoryDbService, () => new MemoryDbService());
+    provide(TYPES.recentDbService, () => new RecentDbService());
+    provide(TYPES.stateDbService, () => new StateDbService());
+    provide(TYPES.sessionDbService, () => new SessionDbService());
+}
+
+const baseServices = {
+    loggerService: inject(TYPES.loggerService),
+    mongoService: inject(TYPES.mongoService),
+    redisService: inject(TYPES.redisService),
+};
+const cacheServices = {
+    candleCacheService: inject(TYPES.candleCacheService),
+    signalCacheService: inject(TYPES.signalCacheService),
+    scheduleCacheService: inject(TYPES.scheduleCacheService),
+    riskCacheService: inject(TYPES.riskCacheService),
+    partialCacheService: inject(TYPES.partialCacheService),
+    breakevenCacheService: inject(TYPES.breakevenCacheService),
+    storageCacheService: inject(TYPES.storageCacheService),
+    notificationCacheService: inject(TYPES.notificationCacheService),
+    logCacheService: inject(TYPES.logCacheService),
+    measureCacheService: inject(TYPES.measureCacheService),
+    intervalCacheService: inject(TYPES.intervalCacheService),
+    memoryCacheService: inject(TYPES.memoryCacheService),
+    recentCacheService: inject(TYPES.recentCacheService),
+    stateCacheService: inject(TYPES.stateCacheService),
+    sessionCacheService: inject(TYPES.sessionCacheService),
+};
+const dbServices = {
+    candleDbService: inject(TYPES.candleDbService),
+    signalDbService: inject(TYPES.signalDbService),
+    scheduleDbService: inject(TYPES.scheduleDbService),
+    riskDbService: inject(TYPES.riskDbService),
+    partialDbService: inject(TYPES.partialDbService),
+    breakevenDbService: inject(TYPES.breakevenDbService),
+    storageDbService: inject(TYPES.storageDbService),
+    notificationDbService: inject(TYPES.notificationDbService),
+    logDbService: inject(TYPES.logDbService),
+    measureDbService: inject(TYPES.measureDbService),
+    intervalDbService: inject(TYPES.intervalDbService),
+    memoryDbService: inject(TYPES.memoryDbService),
+    recentDbService: inject(TYPES.recentDbService),
+    stateDbService: inject(TYPES.stateDbService),
+    sessionDbService: inject(TYPES.sessionDbService),
+};
+const ioc = {
+    ...baseServices,
+    ...cacheServices,
+    ...dbServices,
+};
+init();
+
+const waitForInfra = functoolsKit.singleshot(async () => {
+    await Promise.all([
+        ioc.mongoService.waitForInit(),
+        ioc.redisService.waitForInit(),
+    ]);
+});
+
+class PersistCandleInstance {
+    constructor(symbol, interval, exchangeName) {
+        this.symbol = symbol;
+        this.interval = interval;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async writeCandlesData(candles) {
+        for (const candle of candles) {
+            await ioc.candleDbService.create({
+                symbol: this.symbol,
+                interval: this.interval,
+                close: candle.close,
+                high: candle.high,
+                low: candle.low,
+                open: candle.open,
+                timestamp: candle.timestamp,
+                volume: candle.volume,
+            });
+        }
+    }
+    async readCandlesData(limit, sinceTimestamp) {
+        const stepMs = backtestKit.intervalStepMs(this.interval);
+        const result = [];
+        for (let i = 0; i < limit; i++) {
+            const ts = sinceTimestamp + i * stepMs;
+            const row = await ioc.candleDbService.findBySymbolIntervalTimestamp(this.symbol, this.interval, ts);
+            if (!row) {
+                return null;
+            }
+            result.push({ timestamp: row.timestamp, open: row.open, high: row.high, low: row.low, close: row.close, volume: row.volume });
+        }
+        return result;
+    }
+}
+
+class PersistSignalInstance {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readSignalData() {
+        const row = await ioc.signalDbService.findByContext(this.symbol, this.strategyName, this.exchangeName);
+        return row ? row.payload : null;
+    }
+    async writeSignalData(signalRow) {
+        await ioc.signalDbService.upsert(this.symbol, this.strategyName, this.exchangeName, signalRow);
+    }
+}
+
+class PersistRiskInstance {
+    constructor(riskName, exchangeName) {
+        this.riskName = riskName;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readPositionData(_when) {
+        const row = await ioc.riskDbService.findByContext(this.riskName, this.exchangeName);
+        return row ? row.positions : [];
+    }
+    async writePositionData(positions, when) {
+        await ioc.riskDbService.upsert(this.riskName, this.exchangeName, positions, when);
+    }
+}
+
+class PersistScheduleInstance {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readScheduleData() {
+        const row = await ioc.scheduleDbService.findByContext(this.symbol, this.strategyName, this.exchangeName);
+        return row ? row.payload : null;
+    }
+    async writeScheduleData(scheduleRow) {
+        await ioc.scheduleDbService.upsert(this.symbol, this.strategyName, this.exchangeName, scheduleRow);
+    }
+}
+
+class PersistPartialInstance {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readPartialData(signalId, _when) {
+        const row = await ioc.partialDbService.findByContext(this.symbol, this.strategyName, this.exchangeName, signalId);
+        return row ? row.payload : {};
+    }
+    async writePartialData(data, signalId, when) {
+        await ioc.partialDbService.upsert(this.symbol, this.strategyName, this.exchangeName, signalId, data, when);
+    }
+}
+
+class PersistBreakevenInstance {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readBreakevenData(signalId, _when) {
+        const row = await ioc.breakevenDbService.findByContext(this.symbol, this.strategyName, this.exchangeName, signalId);
+        return row ? row.payload : {};
+    }
+    async writeBreakevenData(data, signalId, when) {
+        await ioc.breakevenDbService.upsert(this.symbol, this.strategyName, this.exchangeName, signalId, data, when);
+    }
+}
+
+class PersistStorageInstance {
+    constructor(backtest) {
+        this.backtest = backtest;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readStorageData() {
+        const rows = await ioc.storageDbService.listByMode(this.backtest);
+        return rows.map((row) => row.payload);
+    }
+    async writeStorageData(signals) {
+        for (const signal of signals) {
+            await ioc.storageDbService.upsert(this.backtest, signal.id, signal);
+        }
+    }
+}
+
+class PersistNotificationInstance {
+    constructor(backtest) {
+        this.backtest = backtest;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readNotificationData() {
+        const rows = await ioc.notificationDbService.listByMode(this.backtest);
+        return rows.map((row) => row.payload).reverse();
+    }
+    async writeNotificationData(notifications) {
+        for (const notification of notifications) {
+            await ioc.notificationDbService.upsert(this.backtest, notification.id, notification);
+        }
+    }
+}
+
+class PersistLogInstance {
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readLogData() {
+        const rows = await ioc.logDbService.listAll();
+        return rows.map((row) => row.payload).reverse();
+    }
+    async writeLogData(entries) {
+        for (const entry of entries) {
+            await ioc.logDbService.upsert(entry.id, entry);
+        }
+    }
+}
+
+class PersistMeasureInstance {
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readMeasureData(key) {
+        const row = await ioc.measureDbService.findByKey(this.bucket, key);
+        if (!row || row.removed) {
+            return null;
+        }
+        return row.payload;
+    }
+    async writeMeasureData(data, key, _when) {
+        await ioc.measureDbService.upsert(this.bucket, key, data);
+    }
+    async removeMeasureData(key) {
+        await ioc.measureDbService.softRemove(this.bucket, key);
+    }
+    async *listMeasureData() {
+        const keys = await ioc.measureDbService.listKeys(this.bucket);
+        for (const key of keys) {
+            yield key;
+        }
+    }
+}
+
+class PersistIntervalInstance {
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readIntervalData(key) {
+        const row = await ioc.intervalDbService.findByKey(this.bucket, key);
+        if (!row || row.removed) {
+            return null;
+        }
+        return row.payload;
+    }
+    async writeIntervalData(data, key, when) {
+        await ioc.intervalDbService.upsert(this.bucket, key, data, when);
+    }
+    async removeIntervalData(key) {
+        await ioc.intervalDbService.softRemove(this.bucket, key);
+    }
+    async *listIntervalData() {
+        const keys = await ioc.intervalDbService.listKeys(this.bucket);
+        for (const key of keys) {
+            yield key;
+        }
+    }
+}
+
+class PersistMemoryInstance {
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readMemoryData(memoryId) {
+        const row = await ioc.memoryDbService.findByMemoryId(this.signalId, this.bucketName, memoryId);
+        if (!row || row.removed) {
+            return null;
+        }
+        return row.payload;
+    }
+    async hasMemoryData(memoryId) {
+        return await ioc.memoryDbService.hasMemoryEntry(this.signalId, this.bucketName, memoryId);
+    }
+    async writeMemoryData(data, memoryId, when) {
+        await ioc.memoryDbService.upsert(this.signalId, this.bucketName, memoryId, data, when);
+    }
+    async removeMemoryData(memoryId) {
+        await ioc.memoryDbService.softRemove(this.signalId, this.bucketName, memoryId);
+    }
+    async *listMemoryData() {
+        const rows = await ioc.memoryDbService.listEntries(this.signalId, this.bucketName);
+        for (const row of rows) {
+            yield { memoryId: row.memoryId, data: row.payload };
+        }
+    }
+    dispose() { }
+}
+
+class PersistRecentInstance {
+    constructor(symbol, strategyName, exchangeName, frameName, backtest) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this.backtest = backtest;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readRecentData() {
+        const row = await ioc.recentDbService.findByContext(this.symbol, this.strategyName, this.exchangeName, this.frameName, this.backtest);
+        return row ? row.payload : null;
+    }
+    async writeRecentData(signalRow, when) {
+        await ioc.recentDbService.upsert(this.symbol, this.strategyName, this.exchangeName, this.frameName, this.backtest, signalRow, when);
+    }
+}
+
+class PersistStateInstance {
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readStateData() {
+        const row = await ioc.stateDbService.findByContext(this.signalId, this.bucketName);
+        return row ? row.payload : null;
+    }
+    async writeStateData(data, when) {
+        await ioc.stateDbService.upsert(this.signalId, this.bucketName, data, when);
+    }
+    dispose() { }
+}
+
+class PersistSessionInstance {
+    constructor(strategyName, exchangeName, frameName) {
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+    }
+    async waitForInit(initial) {
+        if (!initial) {
+            return;
+        }
+        await waitForInfra();
+    }
+    async readSessionData() {
+        const row = await ioc.sessionDbService.findByContext(this.strategyName, this.exchangeName, this.frameName);
+        return row ? row.payload : null;
+    }
+    async writeSessionData(data, when) {
+        await ioc.sessionDbService.upsert(this.strategyName, this.exchangeName, this.frameName, data, when);
+    }
+    dispose() { }
+}
+
+/**
+ * Initializes the `@backtest-kit/mongo` package: applies user-provided configuration
+ * and registers all MongoDB/Redis persistence adapters into the global `backtest-kit` registries.
+ *
+ * Should be called **once** at application startup — before any trading data operations.
+ * Internally calls {@link setConfig} followed by {@link install}.
+ *
+ * @param config - Connection parameters. If omitted, {@link DEFAULT_CONFIG} is used,
+ *   which reads values from environment variables:
+ *   - `CC_MONGO_CONNECTION_STRING` — MongoDB connection string (default: `mongodb://localhost:27017/backtest-kit`)
+ *   - `CC_REDIS_HOST` — Redis host (default: `127.0.0.1`)
+ *   - `CC_REDIS_PORT` — Redis port (default: `6379`)
+ *   - `CC_REDIS_USER` — Redis username (default: empty string)
+ *   - `CC_REDIS_PASSWORD` — Redis password (default: empty string)
+ *
+ * @example
+ * // Minimal — everything is read from env variables
+ * setup();
+ *
+ * @example
+ * // Explicit configuration
+ * setup({
+ *   CC_MONGO_CONNECTION_STRING: "mongodb://mongo:27017/mydb",
+ *   CC_REDIS_HOST: "redis",
+ *   CC_REDIS_PORT: 6379,
+ *   CC_REDIS_USER: "",
+ *   CC_REDIS_PASSWORD: "secret",
+ * });
+ */
+function setup(config) {
+    config && setConfig(config);
+    install();
+}
+/**
+ * Registers MongoDB implementations of all `backtest-kit` persistence adapters
+ * without modifying the global connection configuration.
+ *
+ * Use directly when the configuration has already been applied via {@link setConfig}
+ * or is provided through environment variables and does not need to be overridden.
+ * In the typical scenario, calling {@link setup} is sufficient — it calls `install` internally.
+ *
+ * Registered adapters:
+ * - **Candle** — OHLCV candle data (`PersistCandleAdapter`)
+ * - **Signal** — strategy signals (`PersistSignalAdapter`)
+ * - **Risk** — risk manager positions (`PersistRiskAdapter`)
+ * - **Schedule** — deferred signals (`PersistScheduleAdapter`)
+ * - **Partial** — partial close data (`PersistPartialAdapter`)
+ * - **Breakeven** — breakeven data (`PersistBreakevenAdapter`)
+ * - **Storage** — general signal storage (`PersistStorageAdapter`)
+ * - **Notification** — notifications (`PersistNotificationAdapter`)
+ * - **Log** — log entries (`PersistLogAdapter`)
+ * - **Measure** — arbitrary metrics keyed by bucket/key (`PersistMeasureAdapter`)
+ * - **Interval** — interval task data (`PersistIntervalAdapter`)
+ * - **Memory** — long-term signal memory (`PersistMemoryAdapter`)
+ * - **Recent** — latest strategy frame result (`PersistRecentAdapter`)
+ * - **State** — signal state (`PersistStateAdapter`)
+ * - **Session** — strategy session data (`PersistSessionAdapter`)
+ *
+ * @example
+ * // Configuration is provided via env variables, adapters are installed manually
+ * install();
+ */
+function install() {
+    backtestKit.PersistCandleAdapter.usePersistCandleAdapter(PersistCandleInstance);
+    backtestKit.PersistSignalAdapter.usePersistSignalAdapter(PersistSignalInstance);
+    backtestKit.PersistRiskAdapter.usePersistRiskAdapter(PersistRiskInstance);
+    backtestKit.PersistScheduleAdapter.usePersistScheduleAdapter(PersistScheduleInstance);
+    backtestKit.PersistPartialAdapter.usePersistPartialAdapter(PersistPartialInstance);
+    backtestKit.PersistBreakevenAdapter.usePersistBreakevenAdapter(PersistBreakevenInstance);
+    backtestKit.PersistStorageAdapter.usePersistStorageAdapter(PersistStorageInstance);
+    backtestKit.PersistNotificationAdapter.usePersistNotificationAdapter(PersistNotificationInstance);
+    backtestKit.PersistLogAdapter.usePersistLogAdapter(PersistLogInstance);
+    backtestKit.PersistMeasureAdapter.usePersistMeasureAdapter(PersistMeasureInstance);
+    backtestKit.PersistIntervalAdapter.usePersistIntervalAdapter(PersistIntervalInstance);
+    backtestKit.PersistMemoryAdapter.usePersistMemoryAdapter(PersistMemoryInstance);
+    backtestKit.PersistRecentAdapter.usePersistRecentAdapter(PersistRecentInstance);
+    backtestKit.PersistStateAdapter.usePersistStateAdapter(PersistStateInstance);
+    backtestKit.PersistSessionAdapter.usePersistSessionAdapter(PersistSessionInstance);
+}
+/**
+ * Attaches a custom logger to the internal `LoggerService`.
+ *
+ * By default the package logs to `console`. Pass your own {@link ILogger} implementation
+ * to redirect output to an external logging system (Winston, Pino, Datadog, etc.).
+ *
+ * @param logger - Object with `log`, `debug`, `info`, and `warn` methods.
+ *   Each method receives a string topic followed by arbitrary arguments.
+ *
+ * @example
+ * import winston from "winston";
+ *
+ * setLogger({
+ *   log:   (topic, ...args) => winston.verbose(topic, ...args),
+ *   debug: (topic, ...args) => winston.debug(topic, ...args),
+ *   info:  (topic, ...args) => winston.info(topic, ...args),
+ *   warn:  (topic, ...args) => winston.warn(topic, ...args),
+ * });
+ */
+function setLogger(logger) {
+    ioc.loggerService.setLogger(logger);
+}
+
+exports.getConfig = getConfig;
+exports.getMongo = getMongo;
+exports.getRedis = getRedis;
+exports.install = install;
+exports.setConfig = setConfig;
+exports.setLogger = setLogger;
+exports.setup = setup;