oak-backend-base 3.3.4 → 3.4.1

package/lib/AppLoader.d.ts

@@ -12,7 +12,7 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     private aspectDict;
     private externalDependencies;
     protected dataSubscriber?: DataSubscriber<ED, Cxt>;
-    protected synchronizers?: Synchronizer<ED, Cxt>[];
+    protected synchronizer?: Synchronizer<ED, Cxt>;
     protected contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>;
     private requireSth;
     protected makeContext(cxtStr?: string, headers?: IncomingHttpHeaders): Promise<Cxt>;

package/lib/AppLoader.js

@@ -6,7 +6,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const node_schedule_1 = require("node-schedule");
 const env_1 = require("oak-domain/lib/compiler/env");
-const actionDef_1 = require("oak-domain/lib/store/actionDef");
+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");
@@ -21,7 +21,7 @@ class AppLoader extends types_1.AppLoader {
     aspectDict;
     externalDependencies;
     dataSubscriber;
-    synchronizers;
+    synchronizer;
     contextBuilder;
     requireSth(filePath) {
         const depFilePath = (0, path_1.join)(this.path, filePath);
@@ -104,7 +104,7 @@ class AppLoader extends types_1.AppLoader {
         const syncConfigs = (0, fs_1.existsSync)(syncConfigFile) && require(syncConfigFile).default;
         return {
             dbConfig: dbConfig,
-            syncConfigs: syncConfigs,
+            syncConfig: syncConfigs,
         };
     }
     constructor(path, contextBuilder, ns, nsServer) {
@@ -144,25 +144,23 @@ class AppLoader extends types_1.AppLoader {
         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);
+        const { triggers: adTriggers, checkers: adCheckers } = (0, IntrinsicLogics_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
         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));
-        if (this.synchronizers) {
-            // 同步数据到远端结点通过commit trigger来完成
-            for (const synchronizer of this.synchronizers) {
-                const syncTriggers = synchronizer.getSyncTriggers();
-                syncTriggers.forEach((trigger) => this.registerTrigger(trigger));
-            }
+        if (this.synchronizer) {
+            // 同步数据到远端结点通过commit trigger来完成            
+            const syncTriggers = this.synchronizer.getSyncTriggers();
+            syncTriggers.forEach((trigger) => this.registerTrigger(trigger));
         }
     }
     async mount(initialize) {
         const { path } = this;
         if (!initialize) {
-            const { syncConfigs } = this.getConfiguration();
-            if (syncConfigs) {
-                this.synchronizers = syncConfigs.map(config => new Synchronizer_1.default(config, this.dbStore.getSchema()));
+            const { syncConfig: syncConfig } = this.getConfiguration();
+            if (syncConfig) {
+                this.synchronizer = new Synchronizer_1.default(syncConfig, this.dbStore.getSchema());
             }
             this.initTriggers();
         }
@@ -275,11 +273,9 @@ class AppLoader extends types_1.AppLoader {
                 transformEndpointItem(router, item);
             }
         }
-        if (this.synchronizers) {
-            this.synchronizers.forEach((synchronizer) => {
-                const syncEp = synchronizer.getSelfEndpoint();
-                transformEndpointItem(syncEp.name, syncEp);
-            });
+        if (this.synchronizer) {
+            const syncEp = this.synchronizer.getSelfEndpoint();
+            transformEndpointItem(syncEp.name, syncEp);
         }
         return endPointRouters;
     }
@@ -333,7 +329,7 @@ class AppLoader extends types_1.AppLoader {
     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 { watchers: adWatchers } = (0, IntrinsicLogics_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
         const totalWatchers = watchers.concat(adWatchers);
         let count = 0;
         const execOne = async (watcher, start) => {
@@ -399,6 +395,10 @@ class AppLoader extends types_1.AppLoader {
     }
     async execStartRoutines() {
         const routines = this.requireSth('lib/routines/start');
+        if (this.synchronizer) {
+            const routine = this.synchronizer.getSyncRoutine();
+            routines.push(routine);
+        }
         for (const routine of routines) {
             if (routine.hasOwnProperty('entity')) {
                 const start = Date.now();
@@ -428,13 +428,6 @@ class AppLoader extends types_1.AppLoader {
                 }
             }
         }
-        if (this.synchronizers) {
-            this.synchronizers.forEach((synchronizer) => {
-                // 这个routine在内部处理异步
-                const routine = synchronizer.getSyncRoutine();
-                this.execWatcher(routine);
-            });
-        }
     }
     async execRoutine(routine) {
         const context = await this.makeContext();

package/lib/DataSubscriber.d.ts

@@ -1,18 +1,18 @@
-import { EntityDict } 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';
-export default class DataSubscriber<ED extends EntityDict & BaseEntityDict, Context extends BackendRuntimeContext<ED>> {
-    private ns;
-    private contextBuilder;
-    private filterMap;
-    private idEntityMap;
-    constructor(ns: Namespace, contextBuilder: (scene?: string) => Promise<Context>);
-    private formCreateRoomRoutine;
-    /**
-     * 来自外部的socket连接，监听数据变化
-     */
-    private startup;
-    private sendRecord;
-    onDataCommited(context: Context): void;
-}
+import { EntityDict } 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';
+export default class DataSubscriber<ED extends EntityDict & BaseEntityDict, Context extends BackendRuntimeContext<ED>> {
+    private ns;
+    private contextBuilder;
+    private filterMap;
+    private idEntityMap;
+    constructor(ns: Namespace, contextBuilder: (scene?: string) => Promise<Context>);
+    private formCreateRoomRoutine;
+    /**
+     * 来自外部的socket连接，监听数据变化
+     */
+    private startup;
+    private sendRecord;
+    onDataCommited(context: Context): void;
+}

package/lib/DataSubscriber.js

@@ -1,158 +1,158 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("oak-domain/lib/utils/lodash");
-const oak_domain_1 = require("oak-domain");
-class DataSubscriber {
-    ns;
-    contextBuilder;
-    filterMap;
-    idEntityMap;
-    constructor(ns, contextBuilder) {
-        this.ns = ns;
-        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连接，监听数据变化
-     */
-    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);
-                    });
-                });
-                socket.on('unsub', (ids) => {
-                    // console.log('instance:', process.env.NODE_APP_INSTANCE, 'on unsub', JSON.stringify(ids));
-                    ids.forEach((id) => {
-                        socket.leave(id);
-                    });
-                });
-            }
-            catch (err) {
-                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.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));
-        }
-        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]);
-                    }
-                }
-            });
-        }
-    }
-    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;
-                }
-            }
-        });
-    }
-}
-exports.default = DataSubscriber;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("oak-domain/lib/utils/lodash");
+const oak_domain_1 = require("oak-domain");
+class DataSubscriber {
+    ns;
+    contextBuilder;
+    filterMap;
+    idEntityMap;
+    constructor(ns, contextBuilder) {
+        this.ns = ns;
+        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连接，监听数据变化
+     */
+    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);
+                    });
+                });
+                socket.on('unsub', (ids) => {
+                    // console.log('instance:', process.env.NODE_APP_INSTANCE, 'on unsub', JSON.stringify(ids));
+                    ids.forEach((id) => {
+                        socket.leave(id);
+                    });
+                });
+            }
+            catch (err) {
+                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.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));
+        }
+        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]);
+                    }
+                }
+            });
+        }
+    }
+    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;
+                }
+            }
+        });
+    }
+}
+exports.default = DataSubscriber;

package/lib/DbStore.js

@@ -107,7 +107,7 @@ class DbStore extends oak_db_1.MysqlStore {
         this.executor.registerTrigger(trigger);
     }
     registerChecker(checker) {
-        this.executor.registerChecker(checker);
+        this.executor.registerChecker(checker, this.getSchema());
     }
     setOnVolatileTrigger(onVolatileTrigger) {
         this.executor.setOnVolatileTrigger(onVolatileTrigger);

package/lib/Synchronizer.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, StorageSchema, EndpointItem, SyncConfig, Watcher } from 'oak-domain/lib/types';
+import { EntityDict, StorageSchema, EndpointItem, SyncConfig, FreeRoutine } from 'oak-domain/lib/types';
 import { VolatileTrigger } from 'oak-domain/lib/types/Trigger';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
@@ -7,7 +7,7 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
     private schema;
     private remotePullInfoMap;
     private pullMaxBornAtMap;
-    private remotePushChannel;
+    private channelDict;
     private pushAccessMap;
     /**
      * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
@@ -15,25 +15,15 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      * @param retry
      */
     private startChannel;
-    private joinChannel;
+    private startAllChannel;
+    private pushOperToChannel;
+    private dispatchOperToChannels;
     /**
-     * 推向远端Node的oper，需要严格保证按产生的时间序推送。根据幂等原理，这里必须要推送成功
-     * 因此在这里要实现两点：
-     * 1）oper如果推送失败了，必须留存在queue中，以保证在后面产生的oper之前推送
-     * 2）当对queue中增加oper时，要检查是否有重（有重说明之前失败过），如果无重则将之放置在队列尾
-     *
-     * 其实这里还无法严格保证先产生的oper一定先到达被推送，因为volatile trigger是在事务提交后再发生的，但这种情况在目前应该跑不出来，在实际执行oper的时候assert掉先。by Xc 20240226
-     */
-    private pushOper;
-    /**
-     * 因为应用可能是多租户，得提前确定context下的selfEncryptInfo
-     * 由于checkpoint时无法区别不同上下文之间的未完成oper数据，所以接口只能这样设计
-     * @param id
+     * 为了保证推送的oper序，采用从database中顺序读取所有需要推送的oper来进行推送
+     * 每个进程都保证把当前所有的oper顺序处理掉，就不会有乱序的问题，大家通过database上的锁来完成同步
      * @param context
-     * @param selfEncryptInfo
-     * @returns
      */
-    private synchronizeOpersToRemote;
+    private trySynchronizeOpers;
     private makeCreateOperTrigger;
     constructor(config: SyncConfig<ED, Cxt>, schema: StorageSchema<ED>);
     /**
@@ -41,6 +31,6 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      * @returns
      */
     getSyncTriggers(): VolatileTrigger<ED, keyof ED, Cxt>[];
-    getSyncRoutine(): Watcher<ED, keyof ED, Cxt>;
+    getSyncRoutine(): FreeRoutine<ED, Cxt>;
     getSelfEndpoint(): EndpointItem<ED, Cxt>;
 }

package/lib/Synchronizer.js

@@ -8,6 +8,7 @@ const path_1 = require("path");
 const lodash_1 = require("oak-domain/lib/utils/lodash");
 const filter_1 = require("oak-domain/lib/store/filter");
 const uuid_1 = require("oak-domain/lib/utils/uuid");
+const lodash_2 = require("lodash");
 const OAK_SYNC_HEADER_ENTITY = 'oak-sync-entity';
 const OAK_SYNC_HEADER_ENTITYID = 'oak-sync-entity-id';
 class Synchronizer {
@@ -15,24 +16,20 @@ class Synchronizer {
     schema;
     remotePullInfoMap = {};
     pullMaxBornAtMap = {};
-    remotePushChannel = {};
+    channelDict = {};
     pushAccessMap = {};
     /**
      * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
      * @param channel
      * @param retry
      */
-    async startChannel(channel, retry) {
+    async startChannel(context, channel, retry) {
         const { queue, api, selfEncryptInfo, entity, entityId } = channel;
-        channel.queue = [];
-        channel.running = true;
-        channel.nextPushTimestamp = Number.MAX_SAFE_INTEGER;
-        const opers = queue.map(ele => ele.oper);
-        let failedOpers = [];
-        let needRetry = false;
         let json;
         try {
             // todo 加密
+            const queue = channel.queue;
+            const opers = queue.map(ele => ele.oper);
             console.log('向远端结点sync数据', api, JSON.stringify(opers));
             const finalApi = (0, path_1.join)(api, selfEncryptInfo.id);
             const res = await fetch(finalApi, {
@@ -50,155 +47,125 @@ class Synchronizer {
             json = await res.json();
         }
         catch (err) {
+            // 最大延迟redo时间512秒
+            const retryDelay = Math.pow(2, Math.min(9, retry)) * 1000;
             console.error('sync push时出现error', err);
-            needRetry = true;
-            failedOpers = queue;
+            console.error(`将于${retryDelay}毫秒后重试`);
+            return new Promise((resolve) => {
+                setTimeout(async () => {
+                    await this.startChannel(context, channel, retry + 1);
+                    resolve(undefined);
+                }, retryDelay);
+            });
         }
-        if (!needRetry) {
-            /**
-             * 返回结构见this.getSelfEndpoint
-             */
-            const { successIds, failed } = json;
-            if (failed) {
-                needRetry = true;
-                const { id, error } = failed;
-                console.error('同步过程中发生异常', id, error);
-            }
-            for (const req of queue) {
-                if (successIds.includes(req.oper.id)) {
-                    req.resolve(undefined);
-                }
-                else {
-                    failedOpers.push(req);
-                }
-            }
+        /**
+         * 返回结构见this.getSelfEndpoint
+         */
+        const { successIds, failed, redundantIds } = json;
+        if (failed) {
+            const { id, error } = failed;
+            console.error('同步过程中发生异常', id, error, retry);
         }
-        channel.running = false;
-        channel.handler = undefined;
-        const retry2 = retry + 1;
-        console.log('need retry', retry2);
-        this.joinChannel(channel, failedOpers, retry2);
-    }
-    joinChannel(channel, opers, retry) {
-        // 要去重且有序
-        let idx = 0;
-        const now = Date.now();
-        opers.forEach((oper) => {
-            for (; idx < channel.queue.length; idx++) {
-                if (channel.queue[idx].oper.id === oper.oper.id) {
-                    (0, assert_1.default)(false, '不应当出现重复的oper');
-                    break;
-                }
-                else if (channel.queue[idx].oper.bornAt > oper.oper.bornAt) {
-                    break;
-                }
-            }
-            channel.queue.splice(idx, 0, oper);
-        });
-        const retryWeight = Math.pow(2, Math.min(retry, 10));
-        const nextPushTimestamp = retryWeight * 1000 + now;
-        if (channel.queue.length > 0) {
-            if (channel.running) {
-                if (channel.nextPushTimestamp > nextPushTimestamp) {
-                    channel.nextPushTimestamp = nextPushTimestamp;
-                }
+        const unsuccessfulOpers = queue.filter(ele => !successIds.includes(ele.oper.id) && !redundantIds.includes(ele.oper.id));
+        // 重新开始前，可以将已经完成的oper的triggerData位清零。要注意，在多个remote配置下，有可能一个oper要推给多个channel
+        // 这里可能设计过度了，代码也没经过测试
+        channel.queue = unsuccessfulOpers;
+        const aliveOperIds = [];
+        for (const k in this.channelDict) {
+            if (this.channelDict[k].queue.length > 0) {
+                aliveOperIds.push(...this.channelDict[k].queue.map(ele => ele.oper.id));
             }
-            else {
-                if (channel.nextPushTimestamp > nextPushTimestamp) {
-                    channel.nextPushTimestamp = nextPushTimestamp;
-                    if (channel.handler) {
-                        clearTimeout(channel.handler);
+        }
+        const overIds = (0, lodash_1.difference)(successIds, aliveOperIds);
+        if (overIds.length > 0) {
+            await context.operate('oper', {
+                id: await (0, uuid_1.generateNewIdAsync)(),
+                action: 'update',
+                data: {
+                    [types_1.TriggerDataAttribute]: null,
+                    [types_1.TriggerUuidAttribute]: null,
+                },
+                filter: {
+                    id: {
+                        $in: overIds,
                     }
-                    channel.handler = setTimeout(async () => {
-                        await this.startChannel(channel, retry);
-                    }, nextPushTimestamp - now);
-                }
-                else {
-                    // 当前队列的开始时间要早于自身要求，不用管
-                    (0, assert_1.default)(channel.handler);
                 }
+            }, {});
+        }
+        if (successIds.length > 0) {
+            try {
+                await Promise.all(successIds.map((id) => {
+                    const { onSynchronized, oper } = queue.find(ele => ele.oper.id === id);
+                    return onSynchronized && onSynchronized({
+                        action: oper.action,
+                        data: oper.data,
+                        rowIds: (0, filter_1.getRelevantIds)(oper.filter),
+                    }, context);
+                }));
+            }
+            catch (err) {
+                // 这时候无法处理？
+                console.error('onSynchronzied时出错', err);
+                (0, assert_1.default)(false);
             }
         }
-        else {
-            channel.handler = undefined;
-            channel.nextPushTimestamp = Number.MAX_SAFE_INTEGER;
+        if (channel.queue.length > 0) {
+            // 最大延迟redo时间512秒
+            const retryDelay = Math.pow(2, Math.min(9, retry)) * 1000;
+            console.error(`有${channel.queue.length}个oper同步失败，将于${retryDelay}毫秒后重试`);
+            return new Promise((resolve) => {
+                setTimeout(async () => {
+                    await this.startChannel(context, channel, retry + 1);
+                    resolve(undefined);
+                }, retryDelay);
+            });
         }
     }
-    // 将产生的oper推送到远端Node。注意要尽量在本地阻止重复推送
-    /**
-     * 推向远端Node的oper，需要严格保证按产生的时间序推送。根据幂等原理，这里必须要推送成功
-     * 因此在这里要实现两点：
-     * 1）oper如果推送失败了，必须留存在queue中，以保证在后面产生的oper之前推送
-     * 2）当对queue中增加oper时，要检查是否有重（有重说明之前失败过），如果无重则将之放置在队列尾
-     *
-     * 其实这里还无法严格保证先产生的oper一定先到达被推送，因为volatile trigger是在事务提交后再发生的，但这种情况在目前应该跑不出来，在实际执行oper的时候assert掉先。by Xc 20240226
-     */
-    async pushOper(oper, userId, url, endpoint, remoteEntity, remoteEntityId, selfEncryptInfo) {
-        if (!this.remotePushChannel[userId]) {
+    async startAllChannel(context) {
+        await Promise.all(Object.keys(this.channelDict).map(async (k) => {
+            const channel = this.channelDict[k];
+            if (channel.queue.length > 0) {
+                channel.queue.sort((o1, o2) => o1.oper.$$seq$$ - o2.oper.$$seq$$);
+                return this.startChannel(context, channel, 0);
+            }
+        }));
+    }
+    pushOperToChannel(oper, userId, url, endpoint, remoteEntity, remoteEntityId, selfEncryptInfo, onSynchronized) {
+        if (!this.channelDict[userId]) {
             // channel上缓存这些信息，暂不支持动态更新
-            this.remotePushChannel[userId] = {
+            this.channelDict[userId] = {
                 api: (0, path_1.join)(url, 'endpoint', endpoint),
                 queue: [],
                 entity: remoteEntity,
                 entityId: remoteEntityId,
-                nextPushTimestamp: Number.MAX_SAFE_INTEGER,
-                running: false,
                 selfEncryptInfo,
             };
         }
-        const channel = this.remotePushChannel[userId];
+        else {
+            // 趁机更新一下加密信息
+            this.channelDict[userId].selfEncryptInfo = selfEncryptInfo;
+        }
+        const channel = this.channelDict[userId];
         (0, assert_1.default)(channel.api === (0, path_1.join)(url, 'endpoint', endpoint));
         (0, assert_1.default)(channel.entity === remoteEntity);
         (0, assert_1.default)(channel.entityId === remoteEntityId);
-        const promise = new Promise((resolve) => {
-            this.joinChannel(channel, [{
-                    oper,
-                    resolve,
-                }], 0);
+        channel.queue.push({
+            oper,
+            onSynchronized,
         });
-        await promise;
     }
-    /**
-     * 因为应用可能是多租户，得提前确定context下的selfEncryptInfo
-     * 由于checkpoint时无法区别不同上下文之间的未完成oper数据，所以接口只能这样设计
-     * @param id
-     * @param context
-     * @param selfEncryptInfo
-     * @returns
-     */
-    async synchronizeOpersToRemote(id, context, selfEncryptInfo) {
-        const [oper] = await context.select('oper', {
-            data: {
-                id: 1,
-                action: 1,
-                data: 1,
-                targetEntity: 1,
-                operatorId: 1,
-                operEntity$oper: {
-                    $entity: 'operEntity',
-                    data: {
-                        id: 1,
-                        entity: 1,
-                        entityId: 1,
-                    },
-                },
-                bornAt: 1,
-                $$createAt$$: 1,
-                filter: 1,
-            },
-            filter: {
-                id,
-            }
-        }, { dontCollect: true, forUpdate: true });
-        const { operatorId, targetEntity, operEntity$oper: operEntities, action, data } = oper;
-        const entityIds = operEntities.map(ele => ele.entityId);
+    async dispatchOperToChannels(oper, context) {
+        const { operatorId, targetEntity, filter, action, data } = oper;
+        const entityIds = (0, filter_1.getRelevantIds)(filter);
+        (0, assert_1.default)(entityIds.length > 0);
         const pushEntityNodes = this.pushAccessMap[targetEntity];
+        let pushed = false;
         if (pushEntityNodes && pushEntityNodes.length > 0) {
             // 每个pushEntityNode代表配置的一个remoteEntity 
             await Promise.all(pushEntityNodes.map(async (node) => {
-                const { projection, groupByUsers, getRemotePushInfo: getRemoteAccessInfo, endpoint, actions, onSynchronized } = node;
+                const { projection, groupByUsers, getRemotePushInfo: getRemoteAccessInfo, groupBySelfEntity, endpoint, actions, onSynchronized } = node;
+                // 定义中应该不可能没有actions
                 if (!actions || actions.includes(action)) {
-                    const pushed = [];
                     const rows = await context.select(targetEntity, {
                         data: {
                             id: 1,
@@ -212,8 +179,18 @@ class Synchronizer {
                     }, { dontCollect: true, includedDeleted: true });
                     // userId就是需要发送给远端的user，但是要将本次操作的user过滤掉（操作的原本产生者）
                     const userSendDict = groupByUsers(rows);
+                    const selfEntityIdDict = groupBySelfEntity(rows);
+                    const encryptInfoDict = {};
                     const pushToUserIdFn = async (userId) => {
                         const { entity, entityId, rowIds } = userSendDict[userId];
+                        const selfEntityIds = rowIds.map((rowId) => selfEntityIdDict[rowId]);
+                        const uniqSelfEntityIds = (0, lodash_2.uniq)(selfEntityIds);
+                        (0, assert_1.default)(uniqSelfEntityIds.length === 1, '推向同一个userId的oper不可能关联在多个不同的selfEntity行上');
+                        const selfEntityId = uniqSelfEntityIds[0];
+                        if (!encryptInfoDict[selfEntityId]) {
+                            encryptInfoDict[selfEntityId] = await this.config.self.getSelfEncryptInfo(context, selfEntityId);
+                        }
+                        const selfEncryptInfo = encryptInfoDict[selfEntityId];
                         // 推送到远端结点的oper
                         const oper2 = {
                             id: oper.id,
@@ -224,48 +201,96 @@ class Synchronizer {
                                     $in: rowIds,
                                 }
                             },
-                            bornAt: oper.bornAt,
+                            $$seq$$: oper.$$seq$$,
                             targetEntity,
                         };
                         const { url } = await getRemoteAccessInfo(context, {
                             userId,
                             remoteEntityId: entityId,
                         });
-                        await this.pushOper(oper, userId, url, endpoint, entity, entityId, selfEncryptInfo);
+                        this.pushOperToChannel(oper2, userId, url, endpoint, entity, entityId, selfEncryptInfo, onSynchronized);
                     };
                     for (const userId in userSendDict) {
                         if (userId !== operatorId) {
-                            pushed.push(pushToUserIdFn(userId));
-                        }
-                    }
-                    if (pushed.length > 0) {
-                        // 对单个oper，这里必须要等所有的push返回，不然会一直等在上面
-                        await Promise.all(pushed);
-                        if (onSynchronized) {
-                            await onSynchronized({
-                                action: action,
-                                data: data,
-                                rowIds: entityIds,
-                            }, context);
+                            await pushToUserIdFn(userId);
+                            pushed = true;
                         }
                     }
                 }
             }));
-            // 到这里说明此oper成功，否则会在内部不停循环重试
-            // 主动去把oper上的跨事务标志清除，不依赖底层的triggerExecutor
-            await context.operate('oper', {
-                id: await (0, uuid_1.generateNewIdAsync)(),
-                action: 'update',
+        }
+        // 如果oper一个也不用推送，说明其定义的推送path和对象行的path不匹配（动态指针）
+        return pushed;
+    }
+    /**
+     * 为了保证推送的oper序，采用从database中顺序读取所有需要推送的oper来进行推送
+     * 每个进程都保证把当前所有的oper顺序处理掉，就不会有乱序的问题，大家通过database上的锁来完成同步
+     * @param context
+     */
+    async trySynchronizeOpers(context) {
+        let dirtyOpers = await context.select('oper', {
+            data: {
+                id: 1,
+            },
+            filter: {
+                [types_1.TriggerDataAttribute]: {
+                    $exists: true,
+                },
+            }
+        }, { dontCollect: true });
+        if (dirtyOpers.length > 0) {
+            // 这一步是加锁，保证只有一个进程完成推送，推送者提交前会将$$triggerData$$清零
+            const ids = dirtyOpers.map(ele => ele.id);
+            dirtyOpers = await context.select('oper', {
                 data: {
-                    [types_1.TriggerDataAttribute]: null,
-                    [types_1.TriggerUuidAttribute]: null,
+                    id: 1,
+                    action: 1,
+                    data: 1,
+                    targetEntity: 1,
+                    operatorId: 1,
+                    [types_1.TriggerDataAttribute]: 1,
+                    bornAt: 1,
+                    $$createAt$$: 1,
+                    $$seq$$: 1,
+                    filter: 1,
                 },
                 filter: {
-                    id
+                    id: { $in: ids },
                 },
-            }, {});
+            }, { dontCollect: true, forUpdate: true });
+            dirtyOpers = dirtyOpers.filter(ele => !!ele[types_1.TriggerDataAttribute]);
+            if (dirtyOpers.length > 0) {
+                const pushedIds = [];
+                const unpushedIds = [];
+                await Promise.all(dirtyOpers.map(async (oper) => {
+                    const result = await this.dispatchOperToChannels(oper, context);
+                    if (result) {
+                        pushedIds.push(oper.id);
+                    }
+                    else {
+                        unpushedIds.push(oper.id);
+                    }
+                }));
+                if (unpushedIds.length > 0) {
+                    await context.operate('oper', {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'update',
+                        data: {
+                            [types_1.TriggerDataAttribute]: null,
+                            [types_1.TriggerUuidAttribute]: null,
+                        },
+                        filter: {
+                            id: {
+                                $in: unpushedIds,
+                            }
+                        }
+                    }, {});
+                }
+                if (pushedIds.length > 0) {
+                    await this.startAllChannel(context);
+                }
+            }
         }
-        return 0;
     }
     makeCreateOperTrigger() {
         const { config } = this;
@@ -277,21 +302,24 @@ class Synchronizer {
                 const pushEntities = [];
                 const endpoint2 = (0, path_1.join)(endpoint || 'sync', self.entity);
                 for (const def of pushEntityDefs) {
-                    const { path, relationName, recursive, entity, actions, onSynchronized } = def;
+                    const { pathToRemoteEntity, pathToSelfEntity, relationName, recursive, entity, actions, onSynchronized } = def;
                     pushEntities.push(entity);
                     const relationName2 = relationName || rnRemote;
-                    const path2 = pathToUser ? `${path}.${pathToUser}` : path;
+                    const path2 = pathToUser ? `${pathToRemoteEntity}.${pathToUser}` : pathToRemoteEntity;
+                    (0, assert_1.default)(!recursive);
                     const { projection, getData } = relationName2 ? (0, relationPath_1.destructRelationPath)(this.schema, entity, path2, {
                         relation: {
                             name: relationName,
                         }
-                    }, recursive) : (0, relationPath_1.destructDirectPath)(this.schema, entity, path2, recursive);
+                    }, recursive) : (0, relationPath_1.destructDirectUserPath)(this.schema, entity, path2);
+                    const toSelfEntity = (0, relationPath_1.destructDirectPath)(this.schema, entity, pathToSelfEntity);
                     const groupByUsers = (rows) => {
                         const userRowDict = {};
                         rows.forEach((row) => {
                             const goals = getData(row);
                             if (goals) {
                                 goals.forEach(({ entity, entityId, userId }) => {
+                                    (0, assert_1.default)(userId);
                                     if (userRowDict[userId]) {
                                         // 逻辑上来说同一个userId，其关联的entity和entityId必然相同，这个entity/entityId代表了对方
                                         (0, assert_1.default)(userRowDict[userId].entity === entity && userRowDict[userId].entityId === entityId);
@@ -309,10 +337,28 @@ class Synchronizer {
                         });
                         return userRowDict;
                     };
+                    const projectionMerged = (0, lodash_2.merge)(projection, toSelfEntity.projection);
+                    const groupBySelfEntity = (rows) => {
+                        const selfEntityIdDict = {};
+                        for (const row of rows) {
+                            const selfEntityInfo = toSelfEntity.getData(row, pathToSelfEntity);
+                            if (selfEntityInfo) {
+                                const selfEntityIds = selfEntityInfo.map((info) => {
+                                    (0, assert_1.default)(info.entity === this.config.self.entity);
+                                    return info.data.id;
+                                });
+                                const uniqSelfEntityIds = (0, lodash_2.uniq)(selfEntityIds);
+                                (0, assert_1.default)(uniqSelfEntityIds.length === 1, '同一行数据不可能关联在两行selfEntity上');
+                                selfEntityIdDict[row.id] = uniqSelfEntityIds[0];
+                            }
+                        }
+                        return selfEntityIdDict;
+                    };
                     if (!this.pushAccessMap[entity]) {
                         this.pushAccessMap[entity] = [{
-                                projection,
+                                projection: projectionMerged,
                                 groupByUsers,
+                                groupBySelfEntity,
                                 getRemotePushInfo: getPushInfo,
                                 endpoint: endpoint2,
                                 entity,
@@ -324,6 +370,7 @@ class Synchronizer {
                         this.pushAccessMap[entity].push({
                             projection,
                             groupByUsers,
+                            groupBySelfEntity,
                             getRemotePushInfo: getPushInfo,
                             endpoint: endpoint2,
                             entity,
@@ -344,13 +391,15 @@ class Synchronizer {
             strict: 'makeSure',
             check: (operation) => {
                 const { data } = operation;
-                return pushEntities.includes(data.targetEntity);
+                const { targetEntity, action } = data;
+                return pushEntities.includes(data.targetEntity)
+                    && !!this.pushAccessMap[targetEntity].find(({ actions }) => !actions || actions.includes(action));
             },
             fn: async ({ ids }, context) => {
                 (0, assert_1.default)(ids.length === 1);
-                const selfEncryptInfo = await this.config.self.getSelfEncryptInfo(context);
-                this.synchronizeOpersToRemote(ids[0], context, selfEncryptInfo);
-                throw new types_1.OakException('consistency on oper will be managed by myself');
+                this.trySynchronizeOpers(context);
+                // 内部自主处理triggerData，因此不需要让triggerExecutor处理
+                throw new types_1.OakMakeSureByMySelfException();
             }
         };
         return createOperTrigger;
@@ -369,26 +418,10 @@ class Synchronizer {
     getSyncRoutine() {
         return {
             name: 'checkpoint routine for sync',
-            entity: 'oper',
-            filter: {
-                [types_1.TriggerDataAttribute]: {
-                    $exists: true,
-                }
-            },
-            projection: {
-                id: 1,
-                [types_1.TriggerDataAttribute]: 1,
-            },
-            fn: async (context, data) => {
-                for (const ele of data) {
-                    const { id, [types_1.TriggerDataAttribute]: triggerData } = ele;
-                    const { cxtStr = '{}' } = triggerData;
-                    await context.initialize(JSON.parse(cxtStr), true);
-                    const selfEncryptInfo = await this.config.self.getSelfEncryptInfo(context);
-                    this.synchronizeOpersToRemote(id, context, selfEncryptInfo);
-                }
+            routine: async (context) => {
+                this.trySynchronizeOpers(context);
                 return {};
-            }
+            },
         };
     }
     getSelfEndpoint() {
@@ -402,6 +435,7 @@ class Synchronizer {
                 const { [OAK_SYNC_HEADER_ENTITY]: meEntity, [OAK_SYNC_HEADER_ENTITYID]: meEntityId } = headers;
                 console.log('接收到来自远端的sync数据', entity, JSON.stringify(body));
                 const successIds = [];
+                const redundantIds = [];
                 let failed;
                 // todo 这里先缓存，不考虑本身同步相关信息的更新
                 if (!this.remotePullInfoMap[entity]) {
@@ -453,8 +487,8 @@ class Synchronizer {
                 }
                 let maxBornAt = this.pullMaxBornAtMap[entityId];
                 const opers = body;
-                const outdatedOpers = opers.filter(ele => ele.bornAt <= maxBornAt);
-                const freshOpers = opers.filter(ele => ele.bornAt > maxBornAt);
+                const outdatedOpers = opers.filter(ele => ele.$$seq$$ <= maxBornAt);
+                const freshOpers = opers.filter(ele => ele.$$seq$$ > maxBornAt);
                 await Promise.all([
                     // 无法严格保证推送按bornAt，所以一旦还有outdatedOpers，检查其已经被apply
                     (async () => {
@@ -475,13 +509,13 @@ class Synchronizer {
                                 // todo 这里如果远端业务逻辑严格，发生乱序应是无关的oper，直接执行就好 by Xc
                                 throw new Error(`在sync过程中发现有丢失的oper数据「${missed}」`);
                             }
-                            successIds.push(...ids);
+                            redundantIds.push(...ids);
                         }
                     })(),
                     (async () => {
                         for (const freshOper of freshOpers) {
-                            // freshOpers是按bornAt序产生的
-                            const { id, targetEntity, action, data, bornAt, filter } = freshOper;
+                            // freshOpers是按$$seq$$序产生的
+                            const { id, targetEntity, action, data, $$seq$$, filter } = freshOper;
                             const ids = (0, filter_1.getRelevantIds)(filter);
                             (0, assert_1.default)(ids.length > 0);
                             try {
@@ -500,11 +534,11 @@ class Synchronizer {
                                             $in: ids,
                                         },
                                     },
-                                    bornAt: bornAt,
+                                    bornAt: $$seq$$,
                                 };
                                 await context.operate(targetEntity, operation, {});
                                 successIds.push(id);
-                                maxBornAt = bornAt;
+                                maxBornAt = $$seq$$;
                             }
                             catch (err) {
                                 console.error(err);
@@ -522,6 +556,7 @@ class Synchronizer {
                 return {
                     successIds,
                     failed,
+                    redundantIds,
                 };
             }
         };

package/lib/types/Sync.d.ts

@@ -1,16 +1,16 @@
-import { EntityDict } 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 { RemotePushInfo, RemotePullInfo, SelfEncryptInfo, SyncRemoteConfigBase, SyncSelfConfigBase, SyncConfig } from 'oak-domain/lib/types/Sync';
-interface SyncRemoteConfigWrapper<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends SyncRemoteConfigBase<ED, Cxt> {
-    getRemotePushInfo: (userId: string) => Promise<RemotePushInfo>;
-    getRemotePullInfo: (id: string) => Promise<RemotePullInfo>;
-}
-interface SyncSelfConfigWrapper<ED extends EntityDict & BaseEntityDict> extends SyncSelfConfigBase<ED> {
-    getSelfEncryptInfo: () => Promise<SelfEncryptInfo>;
-}
-export interface SyncConfigWrapper<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> {
-    self: SyncSelfConfigWrapper<ED>;
-    remotes: Array<SyncRemoteConfigWrapper<ED, Cxt>>;
-}
-export { RemotePushInfo, RemotePullInfo, SelfEncryptInfo, SyncConfig, };
+import { EntityDict } 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 { RemotePushInfo, RemotePullInfo, SelfEncryptInfo, SyncRemoteConfigBase, SyncSelfConfigBase, SyncConfig } from 'oak-domain/lib/types/Sync';
+interface SyncRemoteConfigWrapper<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends SyncRemoteConfigBase<ED, Cxt> {
+    getRemotePushInfo: (userId: string) => Promise<RemotePushInfo>;
+    getRemotePullInfo: (id: string) => Promise<RemotePullInfo>;
+}
+interface SyncSelfConfigWrapper<ED extends EntityDict & BaseEntityDict> extends SyncSelfConfigBase<ED> {
+    getSelfEncryptInfo: () => Promise<SelfEncryptInfo>;
+}
+export interface SyncConfigWrapper<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> {
+    self: SyncSelfConfigWrapper<ED>;
+    remotes: Array<SyncRemoteConfigWrapper<ED, Cxt>>;
+}
+export { RemotePushInfo, RemotePullInfo, SelfEncryptInfo, SyncConfig, };

package/lib/types/Sync.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-;
-;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;
+;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "3.3.4",
+    "version": "3.4.1",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -20,10 +20,10 @@
         "mysql": "^2.18.1",
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
-        "oak-common-aspect": "^2.2.5",
-        "oak-db": "^3.1.0",
-        "oak-domain": "^4.2.8",
-        "oak-frontend-base": "^4.2.7",
+        "oak-common-aspect": "^2.3.0",
+        "oak-db": "^3.2.0",
+        "oak-domain": "^4.3.1",
+        "oak-frontend-base": "^4.3.0",
         "socket.io": "^4.7.2",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"