oak-backend-base 3.2.1 → 3.2.2

package/lib/AppLoader.d.ts

@@ -1,24 +1,25 @@
 /// <reference types="node" />
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { AppLoader as GeneralAppLoader, EntityDict, OpRecord } from "oak-domain/lib/types";
+import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord } from "oak-domain/lib/types";
 import { DbStore } from "./DbStore";
 import { BackendRuntimeContext } from 'oak-frontend-base';
 import { IncomingHttpHeaders, IncomingMessage } from 'http';
 import { Namespace } from 'socket.io';
-import { ClusterInfo } from 'oak-domain/lib/types/Cluster';
+import DataSubscriber from './cluster/DataSubscriber';
 export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends GeneralAppLoader<ED, Cxt> {
-    private dbStore;
+    protected dbStore: DbStore<ED, Cxt>;
     private aspectDict;
     private externalDependencies;
-    private dataSubscriber?;
-    private contextBuilder;
+    protected dataSubscriber?: DataSubscriber<ED, Cxt>;
+    protected contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>;
     private requireSth;
-    constructor(path: string, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>, header?: IncomingHttpHeaders, clusterInfo?: ClusterInfo) => Promise<Cxt>, ns?: Namespace);
+    protected makeContext(cxtStr?: string, headers?: IncomingHttpHeaders): Promise<Cxt>;
+    constructor(path: string, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, ns?: Namespace, nsServer?: Namespace);
+    protected registerTrigger(trigger: Trigger<ED, keyof ED, Cxt>): void;
     initTriggers(): void;
-    startWatchers(): void;
     mount(initialize?: true): Promise<void>;
     unmount(): Promise<void>;
-    execAspect(name: string, header?: IncomingHttpHeaders, contextString?: string, params?: any): Promise<{
+    execAspect(name: string, headers?: IncomingHttpHeaders, contextString?: string, params?: any): Promise<{
         opRecords: OpRecord<ED>[];
         result: any;
         message?: string;
@@ -26,6 +27,10 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     initialize(dropIfExists?: boolean): Promise<void>;
     getStore(): DbStore<ED, Cxt>;
     getEndpoints(prefix: string): [string, "get" | "post" | "put" | "delete", string, (params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>][];
+    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt): Promise<import("oak-domain/lib/types").OperationResult<ED>>;
+    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt): Promise<Partial<ED[T]["Schema"]>[]>;
+    protected execWatcher(watcher: Watcher<ED, keyof ED, Cxt>): Promise<void>;
+    startWatchers(): void;
     startTimers(): void;
     execStartRoutines(): Promise<void>;
     execRoutine(routine: (context: Cxt) => Promise<void>): Promise<void>;

package/lib/AppLoader.js

@@ -86,23 +86,36 @@ class AppLoader extends types_1.AppLoader {
         Object.assign(sthOut, sth);
         return sthOut;
     }
-    constructor(path, contextBuilder, ns) {
+    async makeContext(cxtStr, headers) {
+        const context = await this.contextBuilder(cxtStr)(this.dbStore);
+        context.clusterInfo = (0, env_2.getClusterInfo)();
+        context.headers = headers;
+        return context;
+    }
+    constructor(path, contextBuilder, ns, nsServer) {
         super(path);
         const dbConfig = require((0, path_1.join)(path, '/configuration/mysql.json'));
         const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
         const { authDeduceRelationMap, selectFreeEntities, updateFreeDict } = require(`${path}/lib/config/relation`);
         this.externalDependencies = require((0, env_1.OAK_EXTERNAL_LIBS_FILEPATH)((0, path_1.join)(path, 'lib')));
         this.aspectDict = Object.assign({}, index_1.default, this.requireSth('lib/aspects/index'));
-        this.dbStore = new DbStore_1.DbStore(storageSchema, contextBuilder, dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
+        this.dbStore = new DbStore_1.DbStore(storageSchema, (cxtStr) => this.makeContext(cxtStr), dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
         if (ns) {
-            this.dataSubscriber = new DataSubscriber_1.default(ns, (scene) => this.contextBuilder(scene)(this.dbStore));
-            this.contextBuilder = (scene) => async (store, header, clusterInfo) => {
-                const context = await contextBuilder(scene)(store, header, clusterInfo);
+            (0, assert_1.default)(nsServer);
+            this.dataSubscriber = new DataSubscriber_1.default(ns, nsServer, (scene) => this.contextBuilder(scene)(this.dbStore));
+            this.contextBuilder = (scene) => async (store) => {
+                const context = await contextBuilder(scene)(store);
                 // 注入在提交前向dataSubscribe
                 const originCommit = context.commit;
                 context.commit = async () => {
-                    this.dataSubscriber.onDataCommited(context);
+                    const { eventOperationMap, opRecords } = context;
                     await originCommit.call(context);
+                    Object.keys(eventOperationMap).forEach((event) => {
+                        const ids = eventOperationMap[event];
+                        const opRecordsToPublish = opRecords.filter((ele) => !!ele.id && ids.includes(ele.id));
+                        (0, assert_1.default)(opRecordsToPublish.length === ids.length, '要推送的事件的operation数量不足，请检查确保');
+                        this.dataSubscriber.publishEvent(event, opRecordsToPublish, context.getSubscriberId());
+                    });
                 };
                 return context;
             };
@@ -111,79 +124,19 @@ class AppLoader extends types_1.AppLoader {
             this.contextBuilder = contextBuilder;
         }
     }
+    registerTrigger(trigger) {
+        this.dbStore.registerTrigger(trigger);
+    }
     initTriggers() {
         const triggers = this.requireSth('lib/triggers/index');
         const checkers = this.requireSth('lib/checkers/index');
         const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
         const { triggers: adTriggers, checkers: adCheckers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
-        triggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
-        adTriggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
+        triggers.forEach((trigger) => this.registerTrigger(trigger));
+        adTriggers.forEach((trigger) => this.registerTrigger(trigger));
         checkers.forEach((checker) => this.dbStore.registerChecker(checker));
         adCheckers.forEach((checker) => this.dbStore.registerChecker(checker));
     }
-    startWatchers() {
-        const watchers = this.requireSth('lib/watchers/index');
-        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
-        const { watchers: adWatchers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
-        const totalWatchers = watchers.concat(adWatchers);
-        let count = 0;
-        const doWatchers = async () => {
-            count++;
-            const start = Date.now();
-            const context = await this.contextBuilder()(this.dbStore, undefined, (0, env_2.getClusterInfo)());
-            for (const w of totalWatchers) {
-                await context.begin();
-                try {
-                    if (w.hasOwnProperty('actionData')) {
-                        const { entity, action, filter, actionData } = w;
-                        const filter2 = typeof filter === 'function' ? await filter() : filter;
-                        const data = typeof actionData === 'function' ? await actionData() : actionData; // 这里有个奇怪的编译错误，不理解 by Xc
-                        const result = await this.dbStore.operate(entity, {
-                            id: await (0, uuid_1.generateNewIdAsync)(),
-                            action,
-                            data,
-                            filter: filter2
-                        }, context, {
-                            dontCollect: true,
-                        });
-                        console.log(`执行了watcher【${w.name}】，结果是：`, result);
-                    }
-                    else {
-                        const { entity, projection, fn, filter } = w;
-                        const filter2 = typeof filter === 'function' ? await filter() : filter;
-                        const projection2 = typeof projection === 'function' ? await projection() : projection;
-                        const rows = await this.dbStore.select(entity, {
-                            data: projection2,
-                            filter: filter2,
-                        }, context, {
-                            dontCollect: true,
-                            blockTrigger: true,
-                        });
-                        if (rows.length > 0) {
-                            const result = await fn(context, rows);
-                            console.log(`执行了watcher【${w.name}】，结果是：`, result);
-                        }
-                    }
-                    await context.commit();
-                }
-                catch (err) {
-                    await context.rollback();
-                    console.error(`执行了watcher【${w.name}】，发生错误：`, err);
-                }
-            }
-            const duration = Date.now() - start;
-            console.log(`第${count}次执行watchers，共执行${watchers.length}个，耗时${duration}毫秒`);
-            const now = Date.now();
-            try {
-                await this.dbStore.checkpoint(process.env.NODE_ENV === 'development' ? now - 30 * 1000 : now - 120 * 1000);
-            }
-            catch (err) {
-                console.error(`执行了checkpoint，发生错误：`, err);
-            }
-            setTimeout(() => doWatchers(), 120000);
-        };
-        doWatchers();
-    }
     async mount(initialize) {
         const { path } = this;
         if (!initialize) {
@@ -197,8 +150,8 @@ class AppLoader extends types_1.AppLoader {
         (0, index_1.clearPorts)();
         this.dbStore.disconnect();
     }
-    async execAspect(name, header, contextString, params) {
-        const context = await this.contextBuilder(contextString)(this.dbStore, header, (0, env_2.getClusterInfo)());
+    async execAspect(name, headers, contextString, params) {
+        const context = await this.makeContext(contextString, headers);
         const fn = this.aspectDict[name];
         if (!fn) {
             throw new Error(`不存在的接口名称: ${name}`);
@@ -209,7 +162,7 @@ class AppLoader extends types_1.AppLoader {
             await context.commit();
             await context.refineOpRecords();
             return {
-                opRecords: context.opRecords,
+                opRecords: context.opRecords.map(ele => (0, lodash_1.omit)(ele, 'id')),
                 message: context.getMessage(),
                 result,
             };
@@ -272,7 +225,7 @@ class AppLoader extends types_1.AppLoader {
                 }
             }
             endPointRouters.push([name, method, url, async (params, headers, req, body) => {
-                    const context = await this.contextBuilder()(this.dbStore, headers, (0, env_2.getClusterInfo)());
+                    const context = await this.makeContext(undefined, headers);
                     await context.begin();
                     try {
                         const result = await fn(context, params, headers, req, body);
@@ -297,18 +250,96 @@ class AppLoader extends types_1.AppLoader {
         }
         return endPointRouters;
     }
+    operateInWatcher(entity, operation, context) {
+        return this.dbStore.operate(entity, operation, context, {
+            dontCollect: true,
+        });
+    }
+    selectInWatcher(entity, selection, context) {
+        return this.dbStore.select(entity, selection, context, {
+            dontCollect: true,
+            blockTrigger: true,
+        });
+    }
+    async execWatcher(watcher) {
+        const context = await this.makeContext();
+        await context.begin();
+        try {
+            if (watcher.hasOwnProperty('actionData')) {
+                const { entity, action, filter, actionData } = watcher;
+                const filter2 = typeof filter === 'function' ? await filter() : filter;
+                const data = typeof actionData === 'function' ? await (actionData)() : actionData;
+                const result = await this.operateInWatcher(entity, {
+                    id: await (0, uuid_1.generateNewIdAsync)(),
+                    action,
+                    data,
+                    filter: filter2
+                }, context);
+                console.log(`执行了watcher【${watcher.name}】，结果是：`, result);
+            }
+            else {
+                const { entity, projection, fn, filter } = watcher;
+                const filter2 = typeof filter === 'function' ? await filter() : filter;
+                const projection2 = typeof projection === 'function' ? await projection() : projection;
+                const rows = await this.selectInWatcher(entity, {
+                    data: projection2,
+                    filter: filter2,
+                }, context);
+                if (rows.length > 0) {
+                    const result = await fn(context, rows);
+                    console.log(`执行了watcher【${watcher.name}】，结果是：`, result);
+                }
+            }
+            await context.commit();
+        }
+        catch (err) {
+            await context.rollback();
+            console.error(`执行了watcher【${watcher.name}】，发生错误：`, err);
+        }
+    }
+    startWatchers() {
+        const watchers = this.requireSth('lib/watchers/index');
+        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
+        const { watchers: adWatchers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
+        const totalWatchers = watchers.concat(adWatchers);
+        let count = 0;
+        const doWatchers = async () => {
+            count++;
+            const start = Date.now();
+            for (const w of totalWatchers) {
+                await this.execWatcher(w);
+            }
+            const duration = Date.now() - start;
+            console.log(`第${count}次执行watchers，共执行${watchers.length}个，耗时${duration}毫秒`);
+            const now = Date.now();
+            try {
+                await this.dbStore.checkpoint(process.env.NODE_ENV === 'development' ? now - 30 * 1000 : now - 120 * 1000);
+            }
+            catch (err) {
+                console.error(`执行了checkpoint，发生错误：`, err);
+            }
+            setTimeout(() => doWatchers(), 120000);
+        };
+        doWatchers();
+    }
     startTimers() {
         const timers = this.requireSth('lib/timers/index');
         for (const timer of timers) {
-            const { cron, fn, name } = timer;
+            const { cron, name } = timer;
             (0, node_schedule_1.scheduleJob)(name, cron, async (date) => {
                 const start = Date.now();
-                const context = await this.contextBuilder()(this.dbStore, undefined, (0, env_2.getClusterInfo)());
+                const context = await this.makeContext();
                 await context.begin();
                 console.log(`定时器【${name}】开始执行，时间是【${date.toLocaleTimeString()}】`);
                 try {
-                    const result = await fn(context);
-                    console.log(`定时器【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    if (timer.hasOwnProperty('entity')) {
+                        await this.execWatcher(timer);
+                    }
+                    else {
+                        const { timer: timerFn } = timer;
+                        const result = await timerFn(context);
+                        console.log(`定时器【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    }
                     await context.commit();
                 }
                 catch (err) {
@@ -321,23 +352,28 @@ class AppLoader extends types_1.AppLoader {
     async execStartRoutines() {
         const routines = this.requireSth('lib/routines/start');
         for (const routine of routines) {
-            const { name, fn } = routine;
-            const context = await this.contextBuilder()(this.dbStore, undefined, (0, env_2.getClusterInfo)());
-            const start = Date.now();
-            await context.begin();
-            try {
-                const result = await fn(context);
-                console.log(`例程【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
-                await context.commit();
+            if (routine.hasOwnProperty('entity')) {
+                this.execWatcher(routine);
             }
-            catch (err) {
-                console.warn(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
-                await context.rollback();
+            else {
+                const { name, routine: routineFn } = routine;
+                const context = await this.makeContext();
+                const start = Date.now();
+                await context.begin();
+                try {
+                    const result = await routineFn(context);
+                    console.log(`例程【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    await context.commit();
+                }
+                catch (err) {
+                    console.warn(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    await context.rollback();
+                }
             }
         }
     }
     async execRoutine(routine) {
-        const context = await this.contextBuilder()(this.dbStore, undefined, (0, env_2.getClusterInfo)());
+        const context = await this.makeContext();
         await routine(context);
     }
 }

package/lib/ClusterAppLoader.d.ts

@@ -0,0 +1,17 @@
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { EntityDict, OperationResult, Trigger } from 'oak-domain/lib/types';
+import { BackendRuntimeContext } from 'oak-frontend-base';
+import { AppLoader } from './AppLoader';
+import { DbStore } from './DbStore';
+import { Namespace } from 'socket.io';
+import { Socket } from 'socket.io-client';
+export declare class ClusterAppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends AppLoader<ED, Cxt> {
+    protected socket: Socket;
+    private csTriggers;
+    private connect;
+    private sub;
+    constructor(path: string, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, nsDs: Namespace, nsServer: Namespace, socketPath: string);
+    protected registerTrigger(trigger: Trigger<ED, keyof ED, Cxt>): void;
+    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt): Promise<OperationResult<ED>>;
+    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt): Promise<Partial<ED[T]['Schema']>[]>;
+}

package/lib/ClusterAppLoader.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterAppLoader = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = require("oak-domain/lib/utils/lodash");
+const filter_1 = require("oak-domain/lib/store/filter");
+const env_1 = require("./cluster/env");
+const AppLoader_1 = require("./AppLoader");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const socket_io_client_1 = require("socket.io-client");
+class ClusterAppLoader extends AppLoader_1.AppLoader {
+    socket;
+    csTriggers;
+    connect() {
+        const { instanceId } = (0, env_1.getClusterInfo)();
+        this.socket.on('connect', () => {
+            const csTriggerNames = Object.keys(this.csTriggers).map(ele => `${ele}-${instanceId}`);
+            if (csTriggerNames.length > 0) {
+                this.socket.emit('sub', csTriggerNames);
+            }
+        });
+        this.socket.on('disconnect', () => {
+            const csTriggerNames = Object.keys(this.csTriggers).map(ele => `${ele}-${instanceId}`);
+            if (csTriggerNames.length > 0) {
+                this.socket.connect();
+            }
+        });
+        this.socket.on('data', async (entity, name, ids, cxtStr, option) => {
+            const context = await this.makeContext(cxtStr);
+            await context.begin();
+            try {
+                await this.dbStore.execVolatileTrigger(entity, name, ids, context, option);
+                await context.commit();
+            }
+            catch (err) {
+                await context.rollback();
+                console.error('在集群环境下，处理来自其它实例的trigger数据，execVolatileTrigger异常', entity, name, ids, option, err);
+            }
+        });
+        this.socket.connect();
+    }
+    sub(name) {
+        const { instanceId } = (0, env_1.getClusterInfo)();
+        (0, assert_1.default)(!this.csTriggers[name], `命名为${name}的trigger出现了多次，请检查`);
+        this.csTriggers[name] = 1;
+        if (this.socket.connected) {
+            this.socket.emit('sub', [`${name}-${instanceId}`]);
+        }
+        else {
+            this.socket.connect();
+        }
+    }
+    constructor(path, contextBuilder, nsDs, nsServer, socketPath) {
+        super(path, contextBuilder, nsDs, nsServer);
+        this.dbStore.setOnVolatileTrigger(async (entity, trigger, ids, cxtStr, option) => {
+            const execLocal = async (ids2) => {
+                const context = await this.makeContext(cxtStr);
+                await context.begin();
+                try {
+                    await this.dbStore.execVolatileTrigger(entity, trigger.name, ids2, context, option);
+                    await context.commit();
+                }
+                catch (err) {
+                    await context.rollback();
+                    console.error('execVolatileTrigger异常', entity, trigger.name, ids2, option, err);
+                }
+            };
+            if (trigger.cs) {
+                // 如果是cluster sensative的触发器，需要发送到相应的instance上被处理
+                const context = await this.makeContext();
+                const rows = await context.select(entity, {
+                    data: {
+                        id: 1,
+                        $$seq$$: 1,
+                    },
+                    filter: {
+                        id: { $in: ids },
+                    }
+                }, { dontCollect: true });
+                await context.commit();
+                const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
+                const grouped = (0, lodash_1.groupBy)(rows, (ele) => ele.$$seq$$ % instanceCount);
+                for (const seqMod in grouped) {
+                    const ids2 = grouped[seqMod].map(ele => ele.id);
+                    if (parseInt(seqMod) === instanceId) {
+                        await execLocal(ids2);
+                    }
+                    else {
+                        this.dataSubscriber.publishVolatileTrigger(entity, trigger.name, seqMod, ids2, cxtStr, option);
+                    }
+                }
+            }
+            else {
+                await execLocal(ids);
+            }
+        });
+        const { name } = nsServer;
+        const socketUrl = `http://localhost:${process.env.PM2_PORT || 8080}${name}`;
+        this.socket = (0, socket_io_client_1.io)(socketUrl, {
+            path: socketPath,
+        });
+        this.connect();
+        this.csTriggers = {};
+    }
+    registerTrigger(trigger) {
+        // 如果是cluster sensative的trigger，注册到socket事件上
+        if (trigger.when === 'commit' && trigger.cs) {
+            const { name } = trigger;
+            this.sub(name);
+        }
+        this.dbStore.registerTrigger(trigger);
+    }
+    operateInWatcher(entity, operation, context) {
+        const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
+        (0, assert_1.default)(instanceCount && typeof instanceId === 'number');
+        const { filter } = operation;
+        const filter2 = (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
+                $$seq$$: {
+                    $mod: [instanceCount, instanceId]
+                }
+            }]);
+        return super.operateInWatcher(entity, {
+            ...operation,
+            filter: filter2,
+        }, context);
+    }
+    selectInWatcher(entity, selection, context) {
+        const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
+        (0, assert_1.default)(instanceCount && typeof instanceId === 'number');
+        const { filter } = selection;
+        const filter2 = (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
+                $$seq$$: {
+                    $mod: [instanceCount, instanceId]
+                }
+            }]);
+        return super.selectInWatcher(entity, {
+            ...selection,
+            filter: filter2,
+        }, context);
+    }
+}
+exports.ClusterAppLoader = ClusterAppLoader;

package/lib/DbStore.d.ts

@@ -1,5 +1,5 @@
 import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
-import { EntityDict, StorageSchema, Trigger, Checker, SelectOption, SelectFreeEntities, UpdateFreeDict, AuthDeduceRelationMap } from 'oak-domain/lib/types';
+import { EntityDict, StorageSchema, Trigger, Checker, SelectOption, 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';
@@ -7,12 +7,14 @@ import { AsyncContext, AsyncRowStore } 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: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, mysqlConfiguration: MySQLConfiguration, authDeduceRelationMap: AuthDeduceRelationMap<ED>, selectFreeEntities?: SelectFreeEntities<ED>, updateFreeDict?: UpdateFreeDict<ED>);
+    constructor(storageSchema: StorageSchema<ED>, contextBuilder: (scene?: string) => Promise<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>);
     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>;
     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>;
 }

package/lib/DbStore.js

@@ -7,9 +7,9 @@ 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 = {}) {
+    constructor(storageSchema, contextBuilder, mysqlConfiguration, authDeduceRelationMap, selectFreeEntities = [], updateFreeDict = {}, onVolatileTrigger) {
         super(storageSchema, mysqlConfiguration);
-        this.executor = new TriggerExecutor_1.TriggerExecutor((scene) => contextBuilder(scene)(this));
+        this.executor = new TriggerExecutor_1.TriggerExecutor((scene) => contextBuilder(scene), undefined, onVolatileTrigger);
         this.relationAuth = new RelationAuth_1.RelationAuth(storageSchema, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
     }
     async cascadeUpdateAsync(entity, operation, context, option) {
@@ -109,6 +109,12 @@ class DbStore extends oak_db_1.MysqlStore {
     registerChecker(checker) {
         this.executor.registerChecker(checker);
     }
+    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);
     }

package/lib/cluster/DataSubscriber.d.ts

@@ -1,18 +1,23 @@
-import { EntityDict } from 'oak-domain/lib/types';
+import { EntityDict, OperateOption, OpRecord } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base';
 import { Namespace } from 'socket.io';
+/**
+ * 集群行为备忘：
+ * 当socket.io通过adapter在集群间通信时，测试行为如下（测试环境为pm2 + cluster-adapter，其它adpater启用时需要再测一次）：
+ * 1）当client连接到node1并join room1时，只有node1上会有create room事件（room结构本身在结点间并不共享）
+ * 2）当某一个node执行 .adapter.to('room1').emit()时，连接到任一结点的client均能收到消息（但使用room可以实现跨结点推包）
+ * 3) serverSideEmit执行时如果有callback，而不是所有的接收者都执行callback的话，会抛出一个异常（意味着不需要本结点来判定是否收到全部的返回值了）
+ */
 export default class DataSubscriber<ED extends EntityDict & BaseEntityDict, Context extends BackendRuntimeContext<ED>> {
     private ns;
+    private nsServer;
     private contextBuilder;
-    private filterMap;
-    private idEntityMap;
-    constructor(ns: Namespace, contextBuilder: (scene?: string) => Promise<Context>);
-    private formCreateRoomRoutine;
+    constructor(ns: Namespace, nsServer: Namespace, contextBuilder: (scene?: string) => Promise<Context>);
     /**
      * 来自外部的socket连接，监听数据变化
      */
     private startup;
-    private sendRecord;
-    onDataCommited(context: Context): void;
+    publishEvent(event: string, records: OpRecord<ED>[], sid?: string): void;
+    publishVolatileTrigger(entity: keyof ED, name: string, instanceNumber: string, ids: string[], cxtStr: string, option: OperateOption): void;
 }

package/lib/cluster/DataSubscriber.js

@@ -1,41 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("oak-domain/lib/utils/lodash");
-const oak_domain_1 = require("oak-domain");
+const env_1 = require("./env");
+/**
+ * 集群行为备忘：
+ * 当socket.io通过adapter在集群间通信时，测试行为如下（测试环境为pm2 + cluster-adapter，其它adpater启用时需要再测一次）：
+ * 1）当client连接到node1并join room1时，只有node1上会有create room事件（room结构本身在结点间并不共享）
+ * 2）当某一个node执行 .adapter.to('room1').emit()时，连接到任一结点的client均能收到消息（但使用room可以实现跨结点推包）
+ * 3) serverSideEmit执行时如果有callback，而不是所有的接收者都执行callback的话，会抛出一个异常（意味着不需要本结点来判定是否收到全部的返回值了）
+ */
 class DataSubscriber {
     ns;
+    nsServer;
     contextBuilder;
-    filterMap;
-    idEntityMap;
-    constructor(ns, contextBuilder) {
+    constructor(ns, nsServer, contextBuilder) {
         this.ns = ns;
+        this.nsServer = nsServer;
         this.contextBuilder = contextBuilder;
         this.startup();
-        this.filterMap = {};
-        this.idEntityMap = {};
-    }
-    formCreateRoomRoutine(def) {
-        const { id, entity, filter } = def;
-        return (room) => {
-            if (room === id) {
-                console.log('instance:', process.env.NODE_APP_INSTANCE, 'add filter', room);
-                // 本房间不存在，说明这个filter是新出现的
-                if (this.filterMap[entity]) {
-                    // id的唯一性由前台保证，重复则无视
-                    Object.assign(this.filterMap[entity], {
-                        [id]: filter,
-                    });
-                }
-                else {
-                    Object.assign(this.filterMap, {
-                        [entity]: {
-                            [id]: filter,
-                        }
-                    });
-                }
-                this.idEntityMap[id] = entity;
-            }
-        };
     }
     /**
      * 来自外部的socket连接，监听数据变化
@@ -43,39 +24,14 @@ class DataSubscriber {
     startup() {
         this.ns.on('connection', async (socket) => {
             try {
-                const { 'oak-cxt': cxtStr } = socket.handshake.headers;
-                const context = await this.contextBuilder(cxtStr);
-                socket.userId = context.getCurrentUserId();
-                socket.context = context;
-                socket.idMap = {};
-                socket.on('sub', async (data) => {
-                    try {
-                        console.log('instance:', process.env.NODE_APP_INSTANCE, 'on sub', JSON.stringify(data));
-                        await Promise.all(data.map(async (ele) => {
-                            const { id, entity, filter } = ele;
-                            // 尝试select此filter，如果失败说明权限越界
-                            await context.select(entity, {
-                                data: {
-                                    id: 1,
-                                },
-                                filter,
-                            }, {});
-                        }));
-                    }
-                    catch (err) {
-                        socket.emit('error', err.toString());
-                        return;
-                    }
-                    data.forEach((ele) => {
-                        const createRoomRoutine = this.formCreateRoomRoutine(ele);
-                        this.ns.adapter.on('create-room', createRoomRoutine);
-                        socket.join(ele.id);
-                        this.ns.adapter.off('create-room', createRoomRoutine);
-                    });
+                const { instanceId } = (0, env_1.getClusterInfo)();
+                // console.log('on connection', instanceId);
+                socket.on('sub', async (events) => {
+                    events.forEach((event) => socket.join(event));
                 });
-                socket.on('unsub', (ids) => {
+                socket.on('unsub', (events) => {
                     // console.log('instance:', process.env.NODE_APP_INSTANCE, 'on unsub', JSON.stringify(ids));
-                    ids.forEach((id) => {
+                    events.forEach((id) => {
                         socket.leave(id);
                     });
                 });
@@ -84,75 +40,40 @@ class DataSubscriber {
                 socket.emit('error', err.toString());
             }
         });
-        this.ns.adapter.on('delete-room', (room) => {
-            const entity = this.idEntityMap[room];
-            if (entity) {
-                // console.log('instance:', process.env.NODE_APP_INSTANCE, 'remove filter', room);
-                (0, lodash_1.unset)(this.filterMap[entity], room);
-                (0, lodash_1.unset)(this.idEntityMap, room);
+        this.nsServer.on('connection', async (socket) => {
+            try {
+                const { instanceId } = (0, env_1.getClusterInfo)();
+                console.log('on nsServer connection', instanceId);
+                socket.on('sub', async (events) => {
+                    console.log('on nsServer sub', instanceId, events);
+                    events.forEach((event) => socket.join(event));
+                });
+                socket.on('unsub', (events) => {
+                    // console.log('instance:', process.env.NODE_APP_INSTANCE, 'on unsub', JSON.stringify(ids));
+                    events.forEach((id) => {
+                        socket.leave(id);
+                    });
+                });
+            }
+            catch (err) {
+                socket.emit('error', err.toString());
             }
-        });
-        this.ns.on('sendRecord', (entity, filter, record, isCreate) => {
-            console.log('instance:', process.env.NODE_APP_INSTANCE, 'get record from another', JSON.stringify(entity));
         });
     }
-    sendRecord(entity, filter, record, sid, isCreate) {
-        if (entity === 'spContractApplyment') {
-            console.log('instance:', process.env.NODE_APP_INSTANCE, 'sendRecord', JSON.stringify(entity));
+    publishEvent(event, records, sid) {
+        const { instanceId } = (0, env_1.getClusterInfo)();
+        // console.log('publishEvent', instanceId);
+        if (sid) {
+            this.ns.to(event).except(sid).emit('data', records);
         }
-        this.ns.serverSideEmit('sendRecord', entity, filter, record, isCreate);
-        if (this.filterMap[entity]) {
-            Object.keys(this.filterMap[entity]).forEach(async (room) => {
-                const context = await this.contextBuilder();
-                const filter2 = this.filterMap[entity][room];
-                let needSend = false;
-                if (isCreate) {
-                    // 如果是插入数据肯定是单行，使用相容性检测
-                    const contained = await (0, oak_domain_1.checkFilterContains)(entity, context, filter2, filter, true);
-                    needSend = contained;
-                }
-                else {
-                    const repeled = await (0, oak_domain_1.checkFilterRepel)(entity, context, filter, filter2, true);
-                    needSend = !repeled;
-                }
-                if (needSend) {
-                    // console.log('instance:', process.env.NODE_APP_INSTANCE, 'needSend', JSON.stringify(room));
-                    if (sid) {
-                        this.ns.to(room).except(sid).emit('data', [record], [room]);
-                    }
-                    else {
-                        this.ns.to(room).emit('data', [record], [room]);
-                    }
-                }
-            });
+        else {
+            this.ns.to(event).emit('data', records);
         }
     }
-    onDataCommited(context) {
-        const sid = context.getSubscriberId();
-        const { opRecords } = context;
-        opRecords.forEach((record) => {
-            const { a } = record;
-            switch (a) {
-                case 'c': {
-                    const { e, d } = record;
-                    this.sendRecord(e, d, record, sid, true);
-                    break;
-                }
-                case 'u': {
-                    const { e, d, f } = record;
-                    this.sendRecord(e, f, record, sid);
-                    break;
-                }
-                case 'r': {
-                    const { e, f } = record;
-                    this.sendRecord(e, f, record, sid);
-                    break;
-                }
-                default: {
-                    break;
-                }
-            }
-        });
+    publishVolatileTrigger(entity, name, instanceNumber, ids, cxtStr, option) {
+        const { instanceId } = (0, env_1.getClusterInfo)();
+        console.log('publishVolatileTrigger', instanceId, instanceNumber);
+        this.nsServer.to(`${name}-${instanceNumber}`).emit('data', entity, name, ids, cxtStr, option);
     }
 }
 exports.default = DataSubscriber;

package/lib/cluster/env.js

@@ -14,13 +14,27 @@ function getProcessEnvOption(option) {
         return process.env[upperCase];
     }
 }
-// 初始化判定集群状态，目前支持pm2的集群信息
+// 初始化判定集群状态，需要在环境变量中注入两个值
+/** pm2注入方法，见：https://pm2.fenxianglu.cn/docs/general/environment-variables
+ * apps: [
+        {
+            name: 'xxx',
+            script: "xxxjs",
+            instances: "2",
+            increment_var: "OAK_INSTANCE_ID",
+            env: {
+                OAK_INSTANCE_CNT: 9,
+                OAK_INSTANCE_ID: 8,
+            }
+        },
+    ],
+**/
 function initialize() {
-    const pmId = getProcessEnvOption('NODE_APP_INSTANCE');
-    if (pmId) {
+    const instanceIdStr = getProcessEnvOption('OAK_INSTANCE_ID');
+    if (instanceIdStr) {
         const usingCluster = true;
-        const instanceId = parseInt(pmId);
-        const instanceCount = parseInt(getProcessEnvOption('instances'));
+        const instanceId = parseInt(instanceIdStr);
+        const instanceCount = parseInt(getProcessEnvOption('OAK_INSTANCE_CNT'));
         return {
             usingCluster,
             instanceCount,

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { AppLoader } from './AppLoader';
+export { ClusterAppLoader } from './ClusterAppLoader';
 export * from './cluster/env';

package/lib/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppLoader = void 0;
+exports.ClusterAppLoader = exports.AppLoader = void 0;
 const tslib_1 = require("tslib");
 var AppLoader_1 = require("./AppLoader");
 Object.defineProperty(exports, "AppLoader", { enumerable: true, get: function () { return AppLoader_1.AppLoader; } });
+var ClusterAppLoader_1 = require("./ClusterAppLoader");
+Object.defineProperty(exports, "ClusterAppLoader", { enumerable: true, get: function () { return ClusterAppLoader_1.ClusterAppLoader; } });
 tslib_1.__exportStar(require("./cluster/env"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "3.2.1",
+    "version": "3.2.2",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -21,10 +21,11 @@
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^2.2.3",
-        "oak-frontend-base": "^4.0.1",
-        "oak-db": "^3.0.3",
-        "oak-domain": "^4.0.0",
+        "oak-db": "^3.0.4",
+        "oak-domain": "^4.0.1",
+        "oak-frontend-base": "^4.0.2",
         "socket.io": "^4.7.2",
+        "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"
     },
     "license": "ISC",