oak-backend-base 4.1.26 → 4.1.28

package/lib/AppLoader.d.ts

@@ -1,5 +1,5 @@
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord, FreeTimer, OperationResult } from "oak-domain/lib/types";
+import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord, FreeTimer, OperationResult, BaseTimer } from "oak-domain/lib/types";
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { IncomingHttpHeaders, IncomingMessage } from 'http';
 import { Namespace } from 'socket.io';
@@ -19,6 +19,7 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     private watcherTimerId?;
     private scheduledJobs;
     private internalErrorHandlers;
+    private watcherExecutingData;
     regAllExceptionHandler(): void;
     /**
      * 注册一个内部错误处理器
@@ -32,9 +33,15 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     private requireSth;
     protected makeContext(cxtStr?: string, headers?: IncomingHttpHeaders): Promise<Cxt>;
     /**
-     * 后台启动的configuration，统一放在这里读取
+     *  获取数据库配置
+     * @returns  读取数据库配置
      */
-    private getConfiguration;
+    private getDbConfig;
+    /**
+     *  获取同步配置
+     * @returns  读取同步配置
+     */
+    private getSyncConfig;
     constructor(path: string, nsSubscribe?: Namespace, nsSocket?: Namespace, nsServer?: Namespace);
     protected registerTrigger(trigger: Trigger<ED, keyof ED, Cxt>): void;
     protected initTriggers(): void;
@@ -55,11 +62,36 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     }>][];
     protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt, singleton?: true): Promise<OperationResult<ED>>;
     protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, forUpdate?: true, singleton?: true): Promise<Partial<ED[T]["Schema"]>[]>;
+    /**
+     *  检查某个数据是否正在被watcher执行
+     * @param name  watcher名称
+     * @param dataId  数据ID
+     * @returns  如果没有正在执行则返回true，否则返回false
+     */
+    private checkDataExecuting;
+    /**
+     * 过滤出未在执行中的数据行，并标记为执行中
+     * @returns [过滤后的行, 是否有行被跳过]
+     */
+    private filterAndMarkExecutingRows;
+    /**
+     * 清理执行标记
+     */
+    private cleanupExecutingMarks;
+    /**
+     * 解析 filter 和 projection（支持函数或静态值）
+     */
+    private resolveFilterAndProjection;
+    /**
+     * 执行 WB 类型 watcher 的查询操作
+     */
+    private selectForWBWatcher;
     protected execWatcher(watcher: Watcher<ED, keyof ED, Cxt>): Promise<OperationResult<ED> | undefined>;
     protected getCheckpointTs(): number;
     protected checkpoint(): Promise<number>;
     startWatchers(): void;
-    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
+    protected execBaseTimer(timer: BaseTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
+    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, contextBuilder: () => Promise<Cxt>): Promise<OperationResult<ED>> | undefined;
     startTimers(): void;
     execStartRoutines(): Promise<void>;
     execStopRoutines(): Promise<void>;

package/lib/AppLoader.js

@@ -30,6 +30,7 @@ class AppLoader extends types_1.AppLoader {
     watcherTimerId;
     scheduledJobs = {};
     internalErrorHandlers = new Array();
+    watcherExecutingData = new Map();
     regAllExceptionHandler() {
         const handlers = this.requireSth('lib/configuration/exception');
         if (Array.isArray(handlers)) {
@@ -57,13 +58,12 @@ class AppLoader extends types_1.AppLoader {
      * 发布内部错误事件给注册的处理器
      */
     async publishInternalError(type, message, err) {
-        const errorToPublish = (0, lodash_1.cloneDeep)(err);
         await Promise.all(this.internalErrorHandlers.map((handler) => {
             return new Promise(async (resolve) => {
                 const ctx = await this.makeContext();
                 try {
                     console.log(`调用internalErrorHandler【${handler.name}】处理内部错误事件`);
-                    await handler.handle(ctx, type, message, errorToPublish);
+                    await handler.handle(ctx, type, message, err);
                     await ctx.commit();
                 }
                 catch (e) {
@@ -93,20 +93,24 @@ class AppLoader extends types_1.AppLoader {
         return context;
     }
     /**
-     * 后台启动的configuration，统一放在这里读取
+     *  获取数据库配置
+     * @returns  读取数据库配置
      */
-    getConfiguration() {
-        const dbConfig = (0, dbPriority_1.getDbConfig)(this.path);
+    getDbConfig() {
+        return (0, dbPriority_1.getDbConfig)(this.path);
+    }
+    /**
+     *  获取同步配置
+     * @returns  读取同步配置
+     */
+    getSyncConfig() {
         const syncConfigFile = (0, path_1.join)(this.path, 'lib', 'configuration', 'sync.js');
         const syncConfigs = (0, fs_1.existsSync)(syncConfigFile) && require(syncConfigFile).default;
-        return {
-            dbConfig: dbConfig,
-            syncConfig: syncConfigs,
-        };
+        return syncConfigs;
     }
     constructor(path, nsSubscribe, nsSocket, nsServer) {
         super(path);
-        const { dbConfig } = this.getConfiguration();
+        const dbConfig = this.getDbConfig();
         const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
         const depGraph = (0, dependencyBuilder_1.analyzeDepedency)(process.cwd());
         this.externalDependencies = depGraph.ascOrder;
@@ -174,7 +178,7 @@ class AppLoader extends types_1.AppLoader {
     async mount(initialize) {
         const { path } = this;
         if (!initialize) {
-            const { syncConfig: syncConfig } = this.getConfiguration();
+            const syncConfig = this.getSyncConfig();
             if (syncConfig) {
                 this.synchronizer = new Synchronizer_1.default(syncConfig, this.dbStore.getSchema(), () => this.contextBuilder(this.dbStore));
             }
@@ -183,7 +187,7 @@ class AppLoader extends types_1.AppLoader {
         }
         const { importations, exportations } = require(`${path}/lib/ports/index`);
         (0, index_1.registerPorts)(importations || [], exportations || []);
-        this.dbStore.connect();
+        return this.dbStore.connect();
     }
     async unmount() {
         if (this.watcherTimerId) {
@@ -369,46 +373,172 @@ class AppLoader extends types_1.AppLoader {
             forUpdate,
         });
     }
+    /**
+     *  检查某个数据是否正在被watcher执行
+     * @param name  watcher名称
+     * @param dataId  数据ID
+     * @returns  如果没有正在执行则返回true，否则返回false
+     */
+    checkDataExecuting(name, dataId) {
+        let dataSet = this.watcherExecutingData.get(name);
+        if (!dataSet) {
+            dataSet = new Map();
+            this.watcherExecutingData.set(name, dataSet);
+        }
+        const existingTs = dataSet.get(dataId);
+        if (existingTs) {
+            const now = Date.now();
+            if (now - existingTs > 10 * 60 * 1000) {
+                console.error(`检测到执行器【${name}】的数据【${dataId}】标记超时（${Math.floor((now - existingTs) / 1000)}秒），请立即检查是否存在死循环或长时间阻塞的操作`);
+            }
+            return false;
+        }
+        dataSet.set(dataId, Date.now());
+        return true;
+    }
+    /**
+     * 过滤出未在执行中的数据行，并标记为执行中
+     * @returns [过滤后的行, 是否有行被跳过]
+     */
+    filterAndMarkExecutingRows(watcher, rows) {
+        if (watcher.exclusive !== true) {
+            // 不需要排他执行，直接返回所有行
+            return [rows, false];
+        }
+        const rowsWithoutExecuting = [];
+        let hasSkiped = false;
+        const watcherName = watcher.name;
+        for (const row of rows) {
+            if (!row.id) {
+                console.error(`实例【${process.env.OAK_INSTANCE_ID || '单机'}】执行器【${watcherName}】获取的数据没有ID，跳过此数据的并发检查处理：`, row);
+                rowsWithoutExecuting.push(row);
+                continue;
+            }
+            if (this.checkDataExecuting(watcherName, row.id)) {
+                rowsWithoutExecuting.push(row);
+            }
+            else {
+                hasSkiped = true;
+                console.warn(`实例【${process.env.OAK_INSTANCE_ID || '单机'}】执行器【${watcherName}】将跳过正在被执行的数据ID：【${row.id}】，请检查是否执行超时`);
+            }
+        }
+        return [rowsWithoutExecuting, hasSkiped];
+    }
+    /**
+     * 清理执行标记
+     */
+    cleanupExecutingMarks(watcherName, rows) {
+        for (const row of rows) {
+            if (row.id) {
+                const dataSet = this.watcherExecutingData.get(watcherName);
+                if (dataSet) {
+                    dataSet.delete(row.id);
+                }
+            }
+        }
+    }
+    /**
+     * 解析 filter 和 projection（支持函数或静态值）
+     */
+    async resolveFilterAndProjection(filter, projection) {
+        const filter2 = typeof filter === 'function' ? await filter() : (0, lodash_1.cloneDeep)(filter);
+        const projection2 = typeof projection === 'function' ? await projection() : (0, lodash_1.cloneDeep)(projection);
+        return [filter2, projection2];
+    }
+    /**
+     * 执行 WB 类型 watcher 的查询操作
+     */
+    async selectForWBWatcher(watcher, context) {
+        const { entity, projection, filter, singleton, forUpdate } = watcher;
+        const [filter2, projection2] = await this.resolveFilterAndProjection(filter, projection);
+        return await this.selectInWatcher(entity, {
+            data: projection2,
+            filter: filter2,
+        }, context, forUpdate, singleton);
+    }
     async execWatcher(watcher) {
-        const context = await this.makeContext();
         let result;
-        try {
-            if (watcher.hasOwnProperty('actionData')) {
+        // BBWatcher：直接操作，无需查询
+        if (watcher.hasOwnProperty('actionData')) {
+            // 如果配置了 exclusive，BBWatcher 不支持
+            if (watcher.exclusive === true) {
+                console.warn(`BBWatcher【${watcher.name}】配置了 exclusive=true，但 BBWatcher 不支持排他执行，将忽略此配置，请使用 WBWatcher 或 WBFreeWatcher 来实现排他执行`);
+            }
+            const context = await this.makeContext();
+            try {
                 const { entity, action, filter, actionData, singleton } = watcher;
                 const filter2 = typeof filter === 'function' ? await filter() : (0, lodash_1.cloneDeep)(filter);
-                const data = typeof actionData === 'function' ? await (actionData)() : (0, lodash_1.cloneDeep)(actionData);
+                const data = typeof actionData === 'function' ? await actionData() : (0, lodash_1.cloneDeep)(actionData);
                 result = await this.operateInWatcher(entity, {
                     id: await (0, uuid_1.generateNewIdAsync)(),
                     action: action,
                     data,
                     filter: filter2,
                 }, context, singleton);
+                await context.commit();
+                return result;
             }
-            else {
-                const { entity, projection, fn, filter, singleton, forUpdate } = watcher;
-                const filter2 = typeof filter === 'function' ? await filter() : (0, lodash_1.cloneDeep)(filter);
-                const projection2 = typeof projection === 'function' ? await projection() : (0, lodash_1.cloneDeep)(projection);
-                const rows = await this.selectInWatcher(entity, {
-                    data: projection2,
-                    filter: filter2,
-                }, context, forUpdate, singleton);
-                if (rows.length > 0) {
-                    result = await fn(context, rows);
+            catch (err) {
+                if (err instanceof types_1.OakPartialSuccess) {
+                    await context.commit();
                 }
+                else {
+                    await context.rollback();
+                }
+                throw err;
+            }
+        }
+        // WBFreeWatcher 和 WBWatcher：查询后执行
+        const isFreeType = watcher.hasOwnProperty('type') &&
+            watcher.type === 'free';
+        // 1. 执行查询（WBFreeWatcher 使用独立 context）
+        const selectContext = isFreeType ? await this.makeContext() : await this.makeContext();
+        const rows = await this.selectForWBWatcher(watcher, selectContext);
+        if (isFreeType) {
+            await selectContext.commit();
+        }
+        // 2. 并发检查：过滤出未在执行中的数据
+        const [rowsWithoutExecuting, hasSkipped] = this.filterAndMarkExecutingRows(watcher, rows);
+        if (rowsWithoutExecuting.length === 0) {
+            if (!isFreeType) {
+                await selectContext.commit();
+            }
+            // 全部行都被跳过，直接返回，实际没有执行任何操作，hasSkipped也是其他执行流在处理
+            // this.cleanupExecutingMarks(watcher.name, hasSkipped);
+            if (hasSkipped) {
+                console.log(`执行器【${watcher.name}】本次没有可执行的数据行，全部数据行均被跳过`);
             }
-            await context.commit();
             return result;
         }
-        catch (err) {
-            if (err instanceof types_1.OakPartialSuccess) {
-                await context.commit();
+        // 3. 执行业务逻辑
+        try {
+            if (isFreeType) {
+                const { fn } = watcher;
+                result = await fn(() => this.makeContext(), rowsWithoutExecuting);
             }
             else {
-                await context.rollback();
+                const { fn } = watcher;
+                result = await fn(selectContext, rowsWithoutExecuting);
+                await selectContext.commit();
+            }
+            return result;
+        }
+        catch (err) {
+            if (!isFreeType) {
+                if (err instanceof types_1.OakPartialSuccess) {
+                    await selectContext.commit();
+                }
+                else {
+                    await selectContext.rollback();
+                }
             }
-            // 不能在这里publish，因为这个方法可能是在timer中调用，也可能是在routine中调用
             throw err;
         }
+        finally {
+            // 清理执行标记
+            this.cleanupExecutingMarks(watcher.name, rowsWithoutExecuting);
+            // 这里只需要清理被执行的行，因为被跳过的行本来就不是这一次执行被占用的。
+        }
     }
     getCheckpointTs() {
         const now = Date.now();
@@ -423,7 +553,13 @@ class AppLoader extends types_1.AppLoader {
         const { watchers: adWatchers } = (0, IntrinsicLogics_1.makeIntrinsicLogics)(this.dbStore.getSchema(), ActionDefDict);
         const totalWatchers = (watchers || []).concat(adWatchers);
         let count = 0;
+        const skipOnceSet = new Set();
         const execOne = async (watcher, start) => {
+            if (skipOnceSet.has(watcher.name)) {
+                skipOnceSet.delete(watcher.name);
+                console.log(`跳过本次执行watcher【${watcher.name}】`);
+                return;
+            }
             try {
                 const result = await this.execWatcher(watcher);
                 if (result) {
@@ -455,12 +591,22 @@ class AppLoader extends types_1.AppLoader {
             }
             this.watcherTimerId = setTimeout(() => doWatchers(), 120000);
         };
+        // 首次执行时，跳过所有lazy的watcher
+        for (const w of totalWatchers) {
+            if (w.lazy) {
+                skipOnceSet.add(w.name);
+            }
+        }
         doWatchers();
     }
-    execFreeTimer(timer, context) {
+    execBaseTimer(timer, context) {
         const { timer: timerFn } = timer;
         return timerFn(context);
     }
+    execFreeTimer(timer, contextBuilder) {
+        const { timer: timerFn } = timer;
+        return timerFn(contextBuilder);
+    }
     startTimers() {
         const timers = this.requireSth('lib/timers/index');
         if (timers) {
@@ -480,9 +626,20 @@ class AppLoader extends types_1.AppLoader {
                         }
                     }
                     else {
+                        if (timer.hasOwnProperty('type') && timer.type === 'free') {
+                            try {
+                                const result = await this.execFreeTimer(timer, () => this.makeContext());
+                                console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
+                            }
+                            catch (err) {
+                                console.error(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                                this.publishInternalError(`timer`, `定时器【${name}】执行失败`, err);
+                            }
+                            return;
+                        }
                         const context = await this.makeContext();
                         try {
-                            const result = await this.execFreeTimer(timer, context);
+                            const result = await this.execBaseTimer(timer, context);
                             if (result) {
                                 console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
                             }

package/lib/ClusterAppLoader.d.ts

@@ -1,5 +1,5 @@
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { EntityDict, OperationResult, Trigger, Watcher, FreeTimer } from 'oak-domain/lib/types';
+import { EntityDict, OperationResult, Trigger, Watcher, FreeTimer, BaseTimer } from 'oak-domain/lib/types';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { AppLoader } from './AppLoader';
 import { Namespace } from 'socket.io';
@@ -15,6 +15,7 @@ export declare class ClusterAppLoader<ED extends EntityDict & BaseEntityDict, Cx
     protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt, singleton?: true): Promise<OperationResult<ED>>;
     protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, forUpdate?: true, singleton?: true): Promise<Partial<ED[T]['Schema']>[]>;
     protected execWatcher(watcher: Watcher<ED, keyof ED, Cxt>): Promise<OperationResult<ED> | undefined>;
-    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
+    protected execBaseTimer(timer: BaseTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
+    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, contextBuilder: () => Promise<Cxt>): Promise<OperationResult<ED>> | undefined;
     protected checkpoint(): Promise<number>;
 }

package/lib/ClusterAppLoader.js

@@ -168,11 +168,17 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
         }
         return super.execWatcher(watcher);
     }
-    execFreeTimer(timer, context) {
+    execBaseTimer(timer, context) {
         if (timer.singleton && (0, env_1.getClusterInfo)().instanceId !== 0) {
             return;
         }
-        return super.execFreeTimer(timer, context);
+        return super.execBaseTimer(timer, context);
+    }
+    execFreeTimer(timer, contextBuilder) {
+        if (timer.singleton && (0, env_1.getClusterInfo)().instanceId !== 0) {
+            return;
+        }
+        return super.execFreeTimer(timer, contextBuilder);
     }
     async checkpoint() {
         const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();

package/lib/DbStore.d.ts

@@ -2,6 +2,7 @@ import { DbConfiguration } from 'oak-db/src/types/configuration';
 import { EntityDict, StorageSchema, Trigger, Checker, SelectFreeEntities, UpdateFreeDict, AuthDeduceRelationMap, VolatileTrigger, OperateOption } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
+import { DbTypeSymbol } from './utils/dbPriority';
 import { CascadeStore } from 'oak-domain/lib/store/CascadeStore';
 import { DbStore } from 'oak-db/lib/types/dbStore';
 export type TriggerStore<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> = {
@@ -13,4 +14,6 @@ export type TriggerStore<ED extends EntityDict & BaseEntityDict, Cxt extends Bac
     independentCheckPoint(name: string, ts: number, instanceCount?: number, instanceId?: number): Promise<number>;
 };
 export type AppDbStore<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> = DbStore<ED, Cxt> & CascadeStore<ED> & TriggerStore<ED, Cxt>;
-export declare const createDbStore: <ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>>(storageSchema: StorageSchema<ED>, contextBuilder: () => Cxt, dbConfiguration: DbConfiguration, authDeduceRelationMap: AuthDeduceRelationMap<ED>, selectFreeEntities?: SelectFreeEntities<ED>, updateFreeDict?: UpdateFreeDict<ED>, onVolatileTrigger?: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>) => AppDbStore<ED, Cxt>;
+export declare const createDbStore: <ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>>(storageSchema: StorageSchema<ED>, contextBuilder: () => Cxt, dbConfiguration: DbConfiguration & {
+    [DbTypeSymbol]?: string;
+}, authDeduceRelationMap: AuthDeduceRelationMap<ED>, selectFreeEntities?: SelectFreeEntities<ED>, updateFreeDict?: UpdateFreeDict<ED>, onVolatileTrigger?: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>) => AppDbStore<ED, Cxt>;

package/lib/DbStore.js

@@ -5,8 +5,10 @@ const TriggerExecutor_1 = require("oak-domain/lib/store/TriggerExecutor");
 const RelationAuth_1 = require("oak-domain/lib/store/RelationAuth");
 const dbPriority_1 = require("./utils/dbPriority");
 const createDbStore = (storageSchema, contextBuilder, dbConfiguration, authDeduceRelationMap, selectFreeEntities = [], updateFreeDict = {}, onVolatileTrigger) => {
-    const BaseStoreClass = (0, dbPriority_1.getDbStoreClass)();
+    // TODO: 这里的类型检查会过不去，因为ts不知道上层已经实现这个抽象类。
+    const BaseStoreClass = (0, dbPriority_1.getDbStoreClass)(dbConfiguration);
     // 动态创建继承类
+    // @ts-ignore
     class DynamicDbStore extends BaseStoreClass {
         executor;
         relationAuth;

package/lib/utils/dbPriority.d.ts

@@ -1,10 +1,10 @@
 import { MysqlStore, PostgreSQLStore } from "oak-db";
 import { DbConfiguration } from "oak-db/src/types/configuration";
-import { AsyncRowStore } from "oak-domain/lib/store/AsyncRowStore";
 import { EntityDict, StorageSchema } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { CascadeStore } from "oak-domain/lib/store/CascadeStore";
+import { DbStore } from "oak-db/lib/types/dbStore";
 /**
  * 数据库优先级列表，按顺序尝试获取配置文件
  */
@@ -12,5 +12,10 @@ export declare const dbList: {
     mysql: typeof MysqlStore;
     postgres: typeof PostgreSQLStore;
 };
-export declare const getDbConfig: (path: string) => DbConfiguration;
-export declare const getDbStoreClass: <ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>>() => new (schema: StorageSchema<ED>, config: DbConfiguration) => AsyncRowStore<ED, Cxt> & CascadeStore<ED>;
+export declare const DbTypeSymbol: unique symbol;
+export declare const getDbConfig: (path: string) => DbConfiguration & {
+    [DbTypeSymbol]: string;
+};
+export declare const getDbStoreClass: <ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>>(config: {
+    [DbTypeSymbol]?: string;
+}) => new (schema: StorageSchema<ED>, config: DbConfiguration) => DbStore<ED, Cxt> & CascadeStore<ED>;

package/lib/utils/dbPriority.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDbStoreClass = exports.getDbConfig = exports.dbList = void 0;
+exports.getDbStoreClass = exports.getDbConfig = exports.DbTypeSymbol = exports.dbList = void 0;
 const oak_db_1 = require("oak-db");
 const path_1 = require("path");
 const fs_1 = require("fs");
@@ -11,7 +11,7 @@ exports.dbList = {
     mysql: oak_db_1.MysqlStore,
     postgres: oak_db_1.PostgreSQLStore
 };
-let usedDbType = null;
+exports.DbTypeSymbol = Symbol.for('oak:backend:db:type');
 const getDbConfig = (path) => {
     for (const db of Object.keys(exports.dbList)) {
         try {
@@ -25,8 +25,14 @@ const getDbConfig = (path) => {
             }
             const config = require(dbConfigFile);
             console.log(`使用${db}作为数据库`);
-            usedDbType = db;
-            return Object.assign({}, config);
+            // 定义不可枚举的属性，避免被序列化
+            Object.defineProperty(config, exports.DbTypeSymbol, {
+                value: db,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            });
+            return config;
         }
         catch (err) {
             // do nothing
@@ -35,10 +41,11 @@ const getDbConfig = (path) => {
     throw new Error(`没有找到数据库配置文件，请在configuration目录下添加任一配置文件：${Object.keys(exports.dbList).map(ele => `${ele}.json`).join('、')}`);
 };
 exports.getDbConfig = getDbConfig;
-const getDbStoreClass = () => {
-    const dbType = usedDbType || (() => {
-        throw new Error('无法确定数据库类型');
-    })();
+const getDbStoreClass = (config) => {
+    const dbType = Object.getOwnPropertyDescriptor(config, exports.DbTypeSymbol)?.value;
+    if (!dbType) {
+        throw new Error('无法获取数据库类型，请确认是否存在数据库配置文件');
+    }
     const DbStoreClass = exports.dbList[dbType.toLowerCase()];
     if (!DbStoreClass) {
         throw new Error(`不支持的数据库类型：${dbType}，请确认是否存在以下配置文件：${Object.keys(exports.dbList).map(ele => `${ele}.json`).join('、')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.26",
+    "version": "4.1.28",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -22,8 +22,8 @@
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^3.0.5",
-        "oak-db": "^3.3.12",
-        "oak-domain": "^5.1.33",
+        "oak-db": "^3.3.13",
+        "oak-domain": "^5.1.35",
         "oak-frontend-base": "^5.3.45",
         "socket.io": "^4.8.1",
         "socket.io-client": "^4.7.2",