oak-backend-base 4.1.25 → 4.1.26

package/lib/AppLoader.d.ts

@@ -1,6 +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 { DbStore } from "./DbStore";
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { IncomingHttpHeaders, IncomingMessage } from 'http';
 import { Namespace } from 'socket.io';
@@ -8,13 +7,14 @@ import DataSubscriber from './cluster/DataSubscriber';
 import Synchronizer from './Synchronizer';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
 import { InternalErrorHandler } from './types';
+import { AppDbStore } from './DbStore';
 export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends GeneralAppLoader<ED, Cxt> {
-    protected dbStore: DbStore<ED, Cxt>;
+    protected dbStore: AppDbStore<ED, Cxt>;
     private aspectDict;
     private externalDependencies;
     protected dataSubscriber?: DataSubscriber<ED, Cxt>;
     protected synchronizer?: Synchronizer<ED, Cxt>;
-    protected contextBuilder: (store: DbStore<ED, Cxt>) => Cxt;
+    protected contextBuilder: (store: AppDbStore<ED, Cxt>) => Cxt;
     private nsSocket?;
     private watcherTimerId?;
     private scheduledJobs;
@@ -47,7 +47,7 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
         message?: string;
     }>;
     initialize(ifExists?: 'drop' | 'omit' | 'dropIfNotStatic'): Promise<void>;
-    getStore(): DbStore<ED, Cxt>;
+    getStore(): AppDbStore<ED, Cxt>;
     getEndpoints(prefix: string): [string, "post" | "get" | "put" | "delete", string, (params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<{
         headers?: Record<string, string | string[]>;
         data: any;

package/lib/AppLoader.js

@@ -9,7 +9,6 @@ const IntrinsicLogics_1 = require("oak-domain/lib/store/IntrinsicLogics");
 const lodash_1 = require("oak-domain/lib/utils/lodash");
 const uuid_1 = require("oak-domain/lib/utils/uuid");
 const types_1 = require("oak-domain/lib/types");
-const DbStore_1 = require("./DbStore");
 const index_1 = tslib_1.__importStar(require("oak-common-aspect/lib/index"));
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const dependencyBuilder_1 = require("oak-domain/lib/compiler/dependencyBuilder");
@@ -18,6 +17,8 @@ const env_1 = require("./cluster/env");
 const Synchronizer_1 = tslib_1.__importDefault(require("./Synchronizer"));
 const i18n_1 = tslib_1.__importDefault(require("oak-domain/lib/data/i18n"));
 const requirePrj_1 = tslib_1.__importDefault(require("./utils/requirePrj"));
+const dbPriority_1 = require("./utils/dbPriority");
+const DbStore_1 = require("./DbStore");
 class AppLoader extends types_1.AppLoader {
     dbStore;
     aspectDict;
@@ -95,8 +96,7 @@ class AppLoader extends types_1.AppLoader {
      * 后台启动的configuration，统一放在这里读取
      */
     getConfiguration() {
-        const dbConfigFile = (0, path_1.join)(this.path, 'configuration', 'mysql.json');
-        const dbConfig = require(dbConfigFile);
+        const dbConfig = (0, dbPriority_1.getDbConfig)(this.path);
         const syncConfigFile = (0, path_1.join)(this.path, 'lib', 'configuration', 'sync.js');
         const syncConfigs = (0, fs_1.existsSync)(syncConfigFile) && require(syncConfigFile).default;
         return {
@@ -112,7 +112,7 @@ class AppLoader extends types_1.AppLoader {
         this.externalDependencies = depGraph.ascOrder;
         const { authDeduceRelationMap, selectFreeEntities, updateFreeDict } = this.requireSth('lib/configuration/relation');
         this.aspectDict = Object.assign({}, index_1.default, this.requireSth('lib/aspects/index'));
-        this.dbStore = new DbStore_1.DbStore(storageSchema, () => this.contextBuilder(this.dbStore), dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
+        this.dbStore = (0, DbStore_1.createDbStore)(storageSchema, () => this.contextBuilder(this.dbStore), dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
         if (nsSubscribe) {
             this.dataSubscriber = new DataSubscriber_1.default(nsSubscribe, nsServer);
         }
@@ -290,7 +290,7 @@ class AppLoader extends types_1.AppLoader {
                 }
             }
         }
-        await this.dbStore.disconnect();
+        // await this.dbStore.disconnect(); // 不需要马上断开连接，在initialize后可能还会有操作，unmount时会断开
     }
     getStore() {
         return this.dbStore;
@@ -484,7 +484,7 @@ class AppLoader extends types_1.AppLoader {
                         try {
                             const result = await this.execFreeTimer(timer, context);
                             if (result) {
-                                console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                                console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
                             }
                             await context.commit();
                         }
@@ -536,7 +536,7 @@ class AppLoader extends types_1.AppLoader {
                         socket: this.nsSocket,
                         contextBuilder: () => this.makeContext(),
                     });
-                    console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
                     await context.commit();
                 }
                 catch (err) {
@@ -571,7 +571,7 @@ class AppLoader extends types_1.AppLoader {
                         socket: this.nsSocket,
                         contextBuilder: () => this.makeContext(),
                     });
-                    console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
                     await context.commit();
                 }
                 catch (err) {

package/lib/DbStore.d.ts

@@ -1,22 +1,16 @@
-import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
-import { EntityDict, StorageSchema, Trigger, Checker, SelectOption, SelectFreeEntities, UpdateFreeDict, AuthDeduceRelationMap, VolatileTrigger, OperateOption } from 'oak-domain/lib/types';
+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 { MySQLConfiguration } from 'oak-db/lib/MySQL/types/Configuration';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
-import { AsyncRowStore, AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
-export declare class DbStore<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends MysqlStore<ED, Cxt> implements AsyncRowStore<ED, Cxt> {
-    private executor;
-    private relationAuth;
-    constructor(storageSchema: StorageSchema<ED>, contextBuilder: () => Cxt, mysqlConfiguration: MySQLConfiguration, 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>);
-    checkRelationAsync<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, operation: Omit<ED[T]["Operation"] | ED[T]["Selection"], "id">, context: Cxt): Promise<void>;
-    protected cascadeUpdateAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option: MysqlOperateOption): Promise<import("oak-domain/lib/types").OperationResult<ED>>;
-    operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: MysqlOperateOption): Promise<import("oak-domain/lib/types").OperationResult<ED>>;
-    select<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: MySqlSelectOption): Promise<Partial<ED[T]["Schema"]>[]>;
-    count<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: SelectOption): Promise<number>;
+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>> = {
     registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
     registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>): void;
     setOnVolatileTrigger(onVolatileTrigger: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>): void;
     execVolatileTrigger<T extends keyof ED>(entity: T, name: string, ids: string[], context: Cxt, option: OperateOption): Promise<void>;
     checkpoint(ts: number): Promise<number>;
     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>;

package/lib/DbStore.js

@@ -1,128 +1,133 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbStore = void 0;
-const oak_db_1 = require("oak-db");
+exports.createDbStore = void 0;
 const TriggerExecutor_1 = require("oak-domain/lib/store/TriggerExecutor");
 const RelationAuth_1 = require("oak-domain/lib/store/RelationAuth");
-class DbStore extends oak_db_1.MysqlStore {
-    executor;
-    relationAuth;
-    constructor(storageSchema, contextBuilder, mysqlConfiguration, authDeduceRelationMap, selectFreeEntities = [], updateFreeDict = {}, onVolatileTrigger) {
-        super(storageSchema, mysqlConfiguration);
-        this.executor = new TriggerExecutor_1.TriggerExecutor(contextBuilder, undefined, onVolatileTrigger);
-        this.relationAuth = new RelationAuth_1.RelationAuth(storageSchema, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
-    }
-    checkRelationAsync(entity, operation, context) {
-        return this.relationAuth.checkRelationAsync(entity, operation, context);
-    }
-    async cascadeUpdateAsync(entity, operation, context, option) {
-        // 如果是在modi处理过程中，所有的trigger也可以延时到apply时再处理（这时候因为modi中的数据并不实际存在，处理会有问题）
-        if (!option.blockTrigger) {
-            await this.executor.preOperation(entity, operation, context, option);
-        }
-        const result = await super.cascadeUpdateAsync(entity, operation, context, option);
-        if (!option.blockTrigger) {
-            await this.executor.postOperation(entity, operation, context, option);
-        }
-        return result;
-    }
-    async operate(entity, operation, context, option) {
-        const autoCommit = !context.getCurrentTxnId();
-        let result;
-        if (autoCommit) {
-            await context.begin();
-        }
-        try {
-            await this.relationAuth.checkRelationAsync(entity, operation, context);
-            result = await super.operate(entity, operation, context, option);
-        }
-        catch (err) {
-            await context.rollback();
-            throw err;
-        }
-        if (autoCommit) {
-            await context.commit();
-        }
-        return result;
-    }
-    async select(entity, selection, context, option) {
-        const autoCommit = !context.getCurrentTxnId();
-        if (autoCommit) {
-            await context.begin();
-        }
-        let result;
-        // select的trigger应加在根select之前，cascade的select不加处理
-        Object.assign(selection, {
-            action: 'select',
-        });
-        if (!option.blockTrigger) {
-            await this.executor.preOperation(entity, selection, context, option);
+const dbPriority_1 = require("./utils/dbPriority");
+const createDbStore = (storageSchema, contextBuilder, dbConfiguration, authDeduceRelationMap, selectFreeEntities = [], updateFreeDict = {}, onVolatileTrigger) => {
+    const BaseStoreClass = (0, dbPriority_1.getDbStoreClass)();
+    // 动态创建继承类
+    class DynamicDbStore extends BaseStoreClass {
+        executor;
+        relationAuth;
+        constructor() {
+            super(storageSchema, dbConfiguration);
+            this.executor = new TriggerExecutor_1.TriggerExecutor(contextBuilder, undefined, onVolatileTrigger);
+            this.relationAuth = new RelationAuth_1.RelationAuth(storageSchema, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
+        }
+        checkRelationAsync(entity, operation, context) {
+            return this.relationAuth.checkRelationAsync(entity, operation, context);
+        }
+        async cascadeUpdateAsync(entity, operation, context, option) {
+            // 如果是在modi处理过程中，所有的trigger也可以延时到apply时再处理（这时候因为modi中的数据并不实际存在，处理会有问题）
+            if (!option.blockTrigger) {
+                await this.executor.preOperation(entity, operation, context, option);
+            }
+            const result = await super.cascadeUpdateAsync(entity, operation, context, option);
+            if (!option.blockTrigger) {
+                await this.executor.postOperation(entity, operation, context, option);
+            }
+            return result;
         }
-        if (!option.dontCollect) {
-            await this.relationAuth.checkRelationAsync(entity, selection, context);
+        async operate(entity, operation, context, option) {
+            const autoCommit = !context.getCurrentTxnId();
+            let result;
+            if (autoCommit) {
+                await context.begin();
+            }
+            try {
+                await this.relationAuth.checkRelationAsync(entity, operation, context);
+                result = await super.operate(entity, operation, context, option);
+            }
+            catch (err) {
+                await context.rollback();
+                throw err;
+            }
+            if (autoCommit) {
+                await context.commit();
+            }
+            return result;
         }
-        try {
-            result = await super.select(entity, selection, context, option);
+        async select(entity, selection, context, option) {
+            const autoCommit = !context.getCurrentTxnId();
+            if (autoCommit) {
+                await context.begin();
+            }
+            let result;
+            // select的trigger应加在根select之前，cascade的select不加处理
+            Object.assign(selection, {
+                action: 'select',
+            });
             if (!option.blockTrigger) {
-                await this.executor.postOperation(entity, selection, context, option, result);
+                await this.executor.preOperation(entity, selection, context, option);
+            }
+            if (!option.dontCollect) {
+                await this.relationAuth.checkRelationAsync(entity, selection, context);
+            }
+            try {
+                result = await super.select(entity, selection, context, option);
+                if (!option.blockTrigger) {
+                    await this.executor.postOperation(entity, selection, context, option, result);
+                }
+            }
+            catch (err) {
+                await context.rollback();
+                throw err;
+            }
+            if (autoCommit) {
+                await context.commit();
+            }
+            return result;
+        }
+        async count(entity, selection, context, option) {
+            const autoCommit = !context.getCurrentTxnId();
+            let result;
+            if (autoCommit) {
+                await context.begin();
+            }
+            try {
+                // count不用检查权限，因为检查权限中本身要用到count
+                // const selection2 = Object.assign({
+                //     action: 'select',
+                // }, selection) as ED[T]['Operation'];
+                // await this.relationAuth.checkRelationAsync(entity, selection2, context);
+                // if (!option.blockTrigger) {
+                //     await this.executor.preOperation(entity, selection2, context, option);
+                // }
+                result = await super.count(entity, selection, context, option);
+                /*  count应该不存在后trigger吧
+                if (!option.blockTrigger) {
+                    await this.executor.postOperation(entity, selection2, context, option);
+                } */
+            }
+            catch (err) {
+                await context.rollback();
+                throw err;
             }
+            if (autoCommit) {
+                await context.commit();
+            }
+            return result;
         }
-        catch (err) {
-            await context.rollback();
-            throw err;
+        registerTrigger(trigger) {
+            this.executor.registerTrigger(trigger);
         }
-        if (autoCommit) {
-            await context.commit();
+        registerChecker(checker) {
+            this.executor.registerChecker(checker, this.getSchema());
         }
-        return result;
-    }
-    async count(entity, selection, context, option) {
-        const autoCommit = !context.getCurrentTxnId();
-        let result;
-        if (autoCommit) {
-            await context.begin();
+        setOnVolatileTrigger(onVolatileTrigger) {
+            this.executor.setOnVolatileTrigger(onVolatileTrigger);
         }
-        try {
-            // count不用检查权限，因为检查权限中本身要用到count
-            // const selection2 = Object.assign({
-            //     action: 'select',
-            // }, selection) as ED[T]['Operation'];
-            // await this.relationAuth.checkRelationAsync(entity, selection2, context);
-            // if (!option.blockTrigger) {
-            //     await this.executor.preOperation(entity, selection2, context, option);
-            // }
-            result = await super.count(entity, selection, context, option);
-            /*  count应该不存在后trigger吧
-            if (!option.blockTrigger) {
-                await this.executor.postOperation(entity, selection2, context, option);
-            } */
+        async execVolatileTrigger(entity, name, ids, context, option) {
+            return this.executor.execVolatileTrigger(entity, name, ids, context, option);
         }
-        catch (err) {
-            await context.rollback();
-            throw err;
+        checkpoint(ts) {
+            return this.executor.checkpoint(ts);
         }
-        if (autoCommit) {
-            await context.commit();
+        independentCheckPoint(name, ts, instanceCount, instanceId) {
+            return this.executor.independentCheckPoint(name, ts, instanceCount, instanceId);
         }
-        return result;
-    }
-    registerTrigger(trigger) {
-        this.executor.registerTrigger(trigger);
-    }
-    registerChecker(checker) {
-        this.executor.registerChecker(checker, this.getSchema());
-    }
-    setOnVolatileTrigger(onVolatileTrigger) {
-        this.executor.setOnVolatileTrigger(onVolatileTrigger);
-    }
-    async execVolatileTrigger(entity, name, ids, context, option) {
-        return this.executor.execVolatileTrigger(entity, name, ids, context, option);
-    }
-    checkpoint(ts) {
-        return this.executor.checkpoint(ts);
-    }
-    independentCheckPoint(name, ts, instanceCount, instanceId) {
-        return this.executor.independentCheckPoint(name, ts, instanceCount, instanceId);
     }
-}
-exports.DbStore = DbStore;
+    return new DynamicDbStore();
+};
+exports.createDbStore = createDbStore;

package/lib/utils/dbPriority.d.ts

@@ -0,0 +1,16 @@
+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";
+/**
+ * 数据库优先级列表，按顺序尝试获取配置文件
+ */
+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>;

package/lib/utils/dbPriority.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbStoreClass = exports.getDbConfig = exports.dbList = void 0;
+const oak_db_1 = require("oak-db");
+const path_1 = require("path");
+const fs_1 = require("fs");
+/**
+ * 数据库优先级列表，按顺序尝试获取配置文件
+ */
+exports.dbList = {
+    mysql: oak_db_1.MysqlStore,
+    postgres: oak_db_1.PostgreSQLStore
+};
+let usedDbType = null;
+const getDbConfig = (path) => {
+    for (const db of Object.keys(exports.dbList)) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            let dbConfigFile = (0, path_1.join)(path, 'configuration', `${db}.${process.env.NODE_ENV}.json`);
+            if ((0, fs_1.existsSync)(dbConfigFile) === false) {
+                dbConfigFile = (0, path_1.join)(path, 'configuration', `${db}.json`);
+            }
+            if ((0, fs_1.existsSync)(dbConfigFile) === false) {
+                continue;
+            }
+            const config = require(dbConfigFile);
+            console.log(`使用${db}作为数据库`);
+            usedDbType = db;
+            return Object.assign({}, config);
+        }
+        catch (err) {
+            // do nothing
+        }
+    }
+    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 DbStoreClass = exports.dbList[dbType.toLowerCase()];
+    if (!DbStoreClass) {
+        throw new Error(`不支持的数据库类型：${dbType}，请确认是否存在以下配置文件：${Object.keys(exports.dbList).map(ele => `${ele}.json`).join('、')}`);
+    }
+    return DbStoreClass;
+};
+exports.getDbStoreClass = getDbStoreClass;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.25",
+    "version": "4.1.26",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -22,9 +22,9 @@
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^3.0.5",
-        "oak-db": "^3.3.11",
-        "oak-domain": "^5.1.31",
-        "oak-frontend-base": "^5.3.43",
+        "oak-db": "^3.3.12",
+        "oak-domain": "^5.1.33",
+        "oak-frontend-base": "^5.3.45",
         "socket.io": "^4.8.1",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"