oak-backend-base 3.3.2 → 3.3.4

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 synchronizer?: Synchronizer<ED, Cxt>;
+    protected synchronizers?: 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

@@ -21,7 +21,7 @@ class AppLoader extends types_1.AppLoader {
     aspectDict;
     externalDependencies;
     dataSubscriber;
-    synchronizer;
+    synchronizers;
     contextBuilder;
     requireSth(filePath) {
         const depFilePath = (0, path_1.join)(this.path, filePath);
@@ -101,10 +101,10 @@ class AppLoader extends types_1.AppLoader {
         const dbConfigFile = (0, path_1.join)(this.path, 'configuration', 'mysql.json');
         const dbConfig = require(dbConfigFile);
         const syncConfigFile = (0, path_1.join)(this.path, 'lib', 'configuration', 'sync.js');
-        const syncConfig = (0, fs_1.existsSync)(syncConfigFile) && require(syncConfigFile).default;
+        const syncConfigs = (0, fs_1.existsSync)(syncConfigFile) && require(syncConfigFile).default;
         return {
             dbConfig: dbConfig,
-            syncConfig: syncConfig,
+            syncConfigs: syncConfigs,
         };
     }
     constructor(path, contextBuilder, ns, nsServer) {
@@ -149,70 +149,20 @@ class AppLoader extends types_1.AppLoader {
         adTriggers.forEach((trigger) => this.registerTrigger(trigger));
         checkers.forEach((checker) => this.dbStore.registerChecker(checker));
         adCheckers.forEach((checker) => this.dbStore.registerChecker(checker));
-        if (this.synchronizer) {
+        if (this.synchronizers) {
             // 同步数据到远端结点通过commit trigger来完成
-            const syncTriggers = this.synchronizer.getSyncTriggers();
-            syncTriggers.forEach((trigger) => this.registerTrigger(trigger));
+            for (const synchronizer of this.synchronizers) {
+                const syncTriggers = synchronizer.getSyncTriggers();
+                syncTriggers.forEach((trigger) => this.registerTrigger(trigger));
+            }
         }
     }
     async mount(initialize) {
         const { path } = this;
         if (!initialize) {
-            const { dbConfig, syncConfig } = this.getConfiguration();
-            if (syncConfig) {
-                const { self, remotes } = syncConfig;
-                const { getSelfEncryptInfo, ...restSelf } = self;
-                this.synchronizer = new Synchronizer_1.default({
-                    self: {
-                        // entity: self.entity,
-                        getSelfEncryptInfo: async () => {
-                            const context = await this.contextBuilder()(this.dbStore);
-                            await context.begin();
-                            try {
-                                const result = await self.getSelfEncryptInfo(context);
-                                await context.commit();
-                                return result;
-                            }
-                            catch (err) {
-                                await context.rollback();
-                                throw err;
-                            }
-                        },
-                        ...restSelf
-                    },
-                    remotes: remotes.map((r) => {
-                        const { getPushInfo, getPullInfo, ...rest } = r;
-                        return {
-                            getRemotePushInfo: async (id) => {
-                                const context = await this.contextBuilder()(this.dbStore);
-                                await context.begin();
-                                try {
-                                    const result = await getPushInfo(id, context);
-                                    await context.commit();
-                                    return result;
-                                }
-                                catch (err) {
-                                    await context.rollback();
-                                    throw err;
-                                }
-                            },
-                            getRemotePullInfo: async (userId) => {
-                                const context = await this.contextBuilder()(this.dbStore);
-                                await context.begin();
-                                try {
-                                    const result = await getPullInfo(userId, context);
-                                    await context.commit();
-                                    return result;
-                                }
-                                catch (err) {
-                                    await context.rollback();
-                                    throw err;
-                                }
-                            },
-                            ...rest,
-                        };
-                    })
-                }, this.dbStore.getSchema());
+            const { syncConfigs } = this.getConfiguration();
+            if (syncConfigs) {
+                this.synchronizers = syncConfigs.map(config => new Synchronizer_1.default(config, this.dbStore.getSchema()));
             }
             this.initTriggers();
         }
@@ -325,9 +275,11 @@ class AppLoader extends types_1.AppLoader {
                 transformEndpointItem(router, item);
             }
         }
-        if (this.synchronizer) {
-            const syncEp = this.synchronizer.getSelfEndpoint();
-            transformEndpointItem(syncEp.name, syncEp);
+        if (this.synchronizers) {
+            this.synchronizers.forEach((synchronizer) => {
+                const syncEp = synchronizer.getSelfEndpoint();
+                transformEndpointItem(syncEp.name, syncEp);
+            });
         }
         return endPointRouters;
     }
@@ -476,6 +428,13 @@ 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/Synchronizer.d.ts

@@ -1,21 +1,21 @@
-import { EntityDict, StorageSchema, EndpointItem } from 'oak-domain/lib/types';
+import { EntityDict, StorageSchema, EndpointItem, SyncConfig, Watcher } 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';
-import { SyncConfigWrapper } from './types/Sync';
 export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> {
     private config;
     private schema;
-    private selfEncryptInfo?;
     private remotePullInfoMap;
     private pullMaxBornAtMap;
     private remotePushChannel;
+    private pushAccessMap;
     /**
      * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
      * @param channel
      * @param retry
      */
-    private pushOnChannel;
+    private startChannel;
+    private joinChannel;
     /**
      * 推向远端Node的oper，需要严格保证按产生的时间序推送。根据幂等原理，这里必须要推送成功
      * 因此在这里要实现两点：
@@ -25,14 +25,22 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      * 其实这里还无法严格保证先产生的oper一定先到达被推送，因为volatile trigger是在事务提交后再发生的，但这种情况在目前应该跑不出来，在实际执行oper的时候assert掉先。by Xc 20240226
      */
     private pushOper;
-    private getSelfEncryptInfo;
+    /**
+     * 因为应用可能是多租户，得提前确定context下的selfEncryptInfo
+     * 由于checkpoint时无法区别不同上下文之间的未完成oper数据，所以接口只能这样设计
+     * @param id
+     * @param context
+     * @param selfEncryptInfo
+     * @returns
+     */
+    private synchronizeOpersToRemote;
     private makeCreateOperTrigger;
-    constructor(config: SyncConfigWrapper<ED, Cxt>, schema: StorageSchema<ED>);
+    constructor(config: SyncConfig<ED, Cxt>, schema: StorageSchema<ED>);
     /**
      * 根据sync的定义，生成对应的 commit triggers
      * @returns
      */
     getSyncTriggers(): VolatileTrigger<ED, keyof ED, Cxt>[];
-    private checkOperationConsistent;
+    getSyncRoutine(): Watcher<ED, keyof ED, Cxt>;
     getSelfEndpoint(): EndpointItem<ED, Cxt>;
 }

package/lib/Synchronizer.js

@@ -1,55 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const types_1 = require("oak-domain/lib/types");
 const relationPath_1 = require("oak-domain/lib/utils/relationPath");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const path_1 = require("path");
 const lodash_1 = require("oak-domain/lib/utils/lodash");
 const filter_1 = require("oak-domain/lib/store/filter");
-const OAK_SYNC_HEADER_ITEM = 'oak-sync-remote-id';
+const uuid_1 = require("oak-domain/lib/utils/uuid");
+const OAK_SYNC_HEADER_ENTITY = 'oak-sync-entity';
+const OAK_SYNC_HEADER_ENTITYID = 'oak-sync-entity-id';
 class Synchronizer {
     config;
     schema;
-    selfEncryptInfo;
     remotePullInfoMap = {};
     pullMaxBornAtMap = {};
     remotePushChannel = {};
+    pushAccessMap = {};
     /**
      * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
      * @param channel
      * @param retry
      */
-    async pushOnChannel(channel, retry) {
-        const { queue, api, nextPushTimestamp } = channel;
-        (0, assert_1.default)(nextPushTimestamp);
-        // 失败重试的间隔，失败次数多了应当适当延长，最多延长到1024秒
-        let nextPushTimestamp2 = typeof retry === 'number' ? Math.pow(2, Math.min(retry, 10)) : 1;
-        channel.nextPushTimestamp = nextPushTimestamp2 * 1000 + Date.now();
+    async startChannel(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 restOpers = [];
+        let failedOpers = [];
         let needRetry = false;
         let json;
         try {
             // todo 加密
-            const selfEncryptInfo = await this.getSelfEncryptInfo();
             console.log('向远端结点sync数据', api, JSON.stringify(opers));
-            const res = await fetch(api, {
+            const finalApi = (0, path_1.join)(api, selfEncryptInfo.id);
+            const res = await fetch(finalApi, {
                 method: 'post',
                 headers: {
                     'Content-Type': 'application/json',
-                    [OAK_SYNC_HEADER_ITEM]: selfEncryptInfo.id,
+                    [OAK_SYNC_HEADER_ENTITY]: entity,
+                    [OAK_SYNC_HEADER_ENTITYID]: entityId,
                 },
                 body: JSON.stringify(opers),
             });
             if (res.status !== 200) {
-                throw new Error(`sync数据时，访问api「${api}」的结果不是200。「${res.status}」`);
+                throw new Error(`sync数据时，访问api「${finalApi}」的结果不是200。「${res.status}」`);
             }
             json = await res.json();
         }
         catch (err) {
             console.error('sync push时出现error', err);
             needRetry = true;
-            restOpers = queue;
+            failedOpers = queue;
         }
         if (!needRetry) {
             /**
@@ -63,22 +66,62 @@ class Synchronizer {
             }
             for (const req of queue) {
                 if (successIds.includes(req.oper.id)) {
-                    req.resolve();
+                    req.resolve(undefined);
                 }
                 else {
-                    restOpers.push(req);
+                    failedOpers.push(req);
                 }
             }
         }
-        if (restOpers.length > 0) {
-            const interval = Math.max(0, channel.nextPushTimestamp - Date.now());
-            const retry2 = needRetry ? (typeof retry === 'number' ? retry + 1 : 1) : undefined;
-            console.log('need retry', retry2);
-            setTimeout(() => this.pushOnChannel(channel, retry2), interval);
+        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;
+                }
+            }
+            else {
+                if (channel.nextPushTimestamp > nextPushTimestamp) {
+                    channel.nextPushTimestamp = nextPushTimestamp;
+                    if (channel.handler) {
+                        clearTimeout(channel.handler);
+                    }
+                    channel.handler = setTimeout(async () => {
+                        await this.startChannel(channel, retry);
+                    }, nextPushTimestamp - now);
+                }
+                else {
+                    // 当前队列的开始时间要早于自身要求，不用管
+                    (0, assert_1.default)(channel.handler);
+                }
+            }
         }
         else {
             channel.handler = undefined;
-            channel.nextPushTimestamp = undefined;
+            channel.nextPushTimestamp = Number.MAX_SAFE_INTEGER;
         }
     }
     // 将产生的oper推送到远端Node。注意要尽量在本地阻止重复推送
@@ -90,72 +133,149 @@ class Synchronizer {
      *
      * 其实这里还无法严格保证先产生的oper一定先到达被推送，因为volatile trigger是在事务提交后再发生的，但这种情况在目前应该跑不出来，在实际执行oper的时候assert掉先。by Xc 20240226
      */
-    async pushOper(oper, userId, url, endpoint, nextPushTimestamp) {
+    async pushOper(oper, userId, url, endpoint, remoteEntity, remoteEntityId, selfEncryptInfo) {
         if (!this.remotePushChannel[userId]) {
+            // channel上缓存这些信息，暂不支持动态更新
             this.remotePushChannel[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];
-        // 要去重且有序
-        let existed = false;
-        let idx = 0;
-        for (; idx < channel.queue.length; idx++) {
-            if (channel.queue[idx].oper.id === oper.id) {
-                existed = true;
-                break;
-            }
-            else if (channel.queue[idx].oper.bornAt > oper.bornAt) {
-                break;
+        (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);
+        });
+        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,
             }
-        }
-        if (!existed) {
-            const now = Date.now();
-            const nextPushTimestamp2 = nextPushTimestamp || now + 1000;
-            const waiter = new Promise((resolve, reject) => {
-                if (!existed) {
-                    channel.queue.splice(idx, 0, {
-                        oper,
-                        resolve,
-                        reject,
-                    });
+        }, { dontCollect: true, forUpdate: true });
+        const { operatorId, targetEntity, operEntity$oper: operEntities, action, data } = oper;
+        const entityIds = operEntities.map(ele => ele.entityId);
+        const pushEntityNodes = this.pushAccessMap[targetEntity];
+        if (pushEntityNodes && pushEntityNodes.length > 0) {
+            // 每个pushEntityNode代表配置的一个remoteEntity 
+            await Promise.all(pushEntityNodes.map(async (node) => {
+                const { projection, groupByUsers, getRemotePushInfo: getRemoteAccessInfo, endpoint, actions, onSynchronized } = node;
+                if (!actions || actions.includes(action)) {
+                    const pushed = [];
+                    const rows = await context.select(targetEntity, {
+                        data: {
+                            id: 1,
+                            ...projection,
+                        },
+                        filter: {
+                            id: {
+                                $in: entityIds,
+                            },
+                        },
+                    }, { dontCollect: true, includedDeleted: true });
+                    // userId就是需要发送给远端的user，但是要将本次操作的user过滤掉（操作的原本产生者）
+                    const userSendDict = groupByUsers(rows);
+                    const pushToUserIdFn = async (userId) => {
+                        const { entity, entityId, rowIds } = userSendDict[userId];
+                        // 推送到远端结点的oper
+                        const oper2 = {
+                            id: oper.id,
+                            action: action,
+                            data: (action === 'create' && data instanceof Array) ? data.filter(ele => rowIds.includes(ele.id)) : data,
+                            filter: {
+                                id: rowIds.length === 1 ? rowIds[0] : {
+                                    $in: rowIds,
+                                }
+                            },
+                            bornAt: oper.bornAt,
+                            targetEntity,
+                        };
+                        const { url } = await getRemoteAccessInfo(context, {
+                            userId,
+                            remoteEntityId: entityId,
+                        });
+                        await this.pushOper(oper, userId, url, endpoint, entity, entityId, selfEncryptInfo);
+                    };
+                    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);
+                        }
+                    }
                 }
-            });
-            if (!channel.handler) {
-                channel.nextPushTimestamp = nextPushTimestamp2;
-                channel.handler = setTimeout(async () => {
-                    await this.pushOnChannel(channel);
-                }, nextPushTimestamp2 - now);
-            }
-            else if (channel.nextPushTimestamp && channel.nextPushTimestamp > nextPushTimestamp2) {
-                // 当前队列的开始时间要晚于自身的要求，要求提前开始
-                channel.nextPushTimestamp = nextPushTimestamp2;
-            }
-            await waiter;
-        }
-        else {
-            // 感觉应该跑不出来
-            console.warn('在sync数据时，遇到了重复推送的oper', JSON.stringify(oper), userId, url);
-        }
-    }
-    async getSelfEncryptInfo() {
-        if (this.selfEncryptInfo) {
-            return this.selfEncryptInfo;
+            }));
+            // 到这里说明此oper成功，否则会在内部不停循环重试
+            // 主动去把oper上的跨事务标志清除，不依赖底层的triggerExecutor
+            await context.operate('oper', {
+                id: await (0, uuid_1.generateNewIdAsync)(),
+                action: 'update',
+                data: {
+                    [types_1.TriggerDataAttribute]: null,
+                    [types_1.TriggerUuidAttribute]: null,
+                },
+                filter: {
+                    id
+                },
+            }, {});
         }
-        this.selfEncryptInfo = await this.config.self.getSelfEncryptInfo();
-        return this.selfEncryptInfo;
+        return 0;
     }
     makeCreateOperTrigger() {
         const { config } = this;
         const { remotes, self } = config;
         // 根据remotes定义，建立从entity到需要同步的远端结点信息的Map
-        const pushAccessMap = {};
         remotes.forEach((remote) => {
-            const { getRemotePushInfo, pushEntities: pushEntityDefs, endpoint, pathToUser, relationName: rnRemote, entitySelf } = remote;
+            const { getPushInfo, pushEntities: pushEntityDefs, endpoint, pathToUser, relationName: rnRemote } = remote;
             if (pushEntityDefs) {
                 const pushEntities = [];
-                const endpoint2 = (0, path_1.join)(endpoint || 'sync', entitySelf || self.entitySelf);
+                const endpoint2 = (0, path_1.join)(endpoint || 'sync', self.entity);
                 for (const def of pushEntityDefs) {
                     const { path, relationName, recursive, entity, actions, onSynchronized } = def;
                     pushEntities.push(entity);
@@ -168,26 +288,32 @@ class Synchronizer {
                     }, recursive) : (0, relationPath_1.destructDirectPath)(this.schema, entity, path2, recursive);
                     const groupByUsers = (rows) => {
                         const userRowDict = {};
-                        rows.filter((row) => {
-                            const userIds = getData(row)?.map(ele => ele.userId);
-                            if (userIds) {
-                                userIds.forEach((userId) => {
+                        rows.forEach((row) => {
+                            const goals = getData(row);
+                            if (goals) {
+                                goals.forEach(({ entity, entityId, userId }) => {
                                     if (userRowDict[userId]) {
-                                        userRowDict[userId].push(row.id);
+                                        // 逻辑上来说同一个userId，其关联的entity和entityId必然相同，这个entity/entityId代表了对方
+                                        (0, assert_1.default)(userRowDict[userId].entity === entity && userRowDict[userId].entityId === entityId);
+                                        userRowDict[userId].rowIds.push(row.id);
                                     }
                                     else {
-                                        userRowDict[userId] = [row.id];
+                                        userRowDict[userId] = {
+                                            entity,
+                                            entityId,
+                                            rowIds: [row.id],
+                                        };
                                     }
                                 });
                             }
                         });
                         return userRowDict;
                     };
-                    if (!pushAccessMap[entity]) {
-                        pushAccessMap[entity] = [{
+                    if (!this.pushAccessMap[entity]) {
+                        this.pushAccessMap[entity] = [{
                                 projection,
                                 groupByUsers,
-                                getRemotePushInfo,
+                                getRemotePushInfo: getPushInfo,
                                 endpoint: endpoint2,
                                 entity,
                                 actions,
@@ -195,10 +321,10 @@ class Synchronizer {
                             }];
                     }
                     else {
-                        pushAccessMap[entity].push({
+                        this.pushAccessMap[entity].push({
                             projection,
                             groupByUsers,
-                            getRemotePushInfo,
+                            getRemotePushInfo: getPushInfo,
                             endpoint: endpoint2,
                             entity,
                             actions,
@@ -208,7 +334,7 @@ class Synchronizer {
                 }
             }
         });
-        const pushEntities = Object.keys(pushAccessMap);
+        const pushEntities = Object.keys(this.pushAccessMap);
         // push相关联的entity，在发生操作时，需要将operation推送到远端
         const createOperTrigger = {
             name: 'push oper to remote node',
@@ -222,88 +348,9 @@ class Synchronizer {
             },
             fn: async ({ ids }, context) => {
                 (0, assert_1.default)(ids.length === 1);
-                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: {
-                        id: ids[0],
-                    }
-                }, { dontCollect: true, forUpdate: true });
-                const { operatorId, targetEntity, operEntity$oper: operEntities, action, data } = oper;
-                const entityIds = operEntities.map(ele => ele.entityId);
-                const pushEntityNodes = pushAccessMap[targetEntity];
-                if (pushEntityNodes && pushEntityNodes.length > 0) {
-                    // 每个pushEntityNode代表配置的一个remoteEntity 
-                    await Promise.all(pushEntityNodes.map(async (node) => {
-                        const { projection, groupByUsers, getRemotePushInfo: getRemoteAccessInfo, endpoint, entity, actions, onSynchronized } = node;
-                        if (!actions || actions.includes(action)) {
-                            const pushed = [];
-                            const rows = await context.select(targetEntity, {
-                                data: {
-                                    id: 1,
-                                    ...projection,
-                                },
-                                filter: {
-                                    id: {
-                                        $in: entityIds,
-                                    },
-                                },
-                            }, { dontCollect: true, includedDeleted: true });
-                            // userId就是需要发送给远端的user，但是要将本次操作的user过滤掉（操作的原本产生者）
-                            const userSendDict = groupByUsers(rows);
-                            const pushToUserIdFn = async (userId) => {
-                                const rowIds = userSendDict[userId];
-                                // 推送到远端结点的oper
-                                const oper2 = {
-                                    id: oper.id,
-                                    action: action,
-                                    data: (action === 'create' && data instanceof Array) ? data.filter(ele => rowIds.includes(ele.id)) : data,
-                                    filter: {
-                                        id: rowIds.length === 1 ? rowIds[0] : {
-                                            $in: rowIds,
-                                        }
-                                    },
-                                    bornAt: oper.bornAt,
-                                    targetEntity,
-                                };
-                                const { url } = await getRemoteAccessInfo(userId);
-                                await this.pushOper(oper2 /** 这里不明白为什么TS过不去 */, userId, url, endpoint);
-                            };
-                            for (const userId in userSendDict) {
-                                if (userId !== operatorId) {
-                                    pushed.push(pushToUserIdFn(userId));
-                                }
-                            }
-                            if (pushed.length > 0) {
-                                await Promise.all(pushed);
-                                if (onSynchronized) {
-                                    await onSynchronized({
-                                        action: action,
-                                        data: data,
-                                        rowIds: entityIds,
-                                    }, context);
-                                }
-                            }
-                        }
-                    }));
-                    return entityIds.length * pushEntityNodes.length;
-                }
-                return 0;
+                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');
             }
         };
         return createOperTrigger;
@@ -319,17 +366,40 @@ class Synchronizer {
     getSyncTriggers() {
         return [this.makeCreateOperTrigger()];
     }
-    async checkOperationConsistent(entity, ids, bornAt) {
+    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);
+                }
+                return {};
+            }
+        };
     }
     getSelfEndpoint() {
         return {
             name: this.config.self.endpoint || 'sync',
             method: 'post',
-            params: ['entity'],
+            params: ['entity', 'entityId'],
             fn: async (context, params, headers, req, body) => {
                 // body中是传过来的oper数组信息
-                const { entity } = params;
-                const { [OAK_SYNC_HEADER_ITEM]: id } = headers;
+                const { entity, entityId } = params;
+                const { [OAK_SYNC_HEADER_ENTITY]: meEntity, [OAK_SYNC_HEADER_ENTITYID]: meEntityId } = headers;
                 console.log('接收到来自远端的sync数据', entity, JSON.stringify(body));
                 const successIds = [];
                 let failed;
@@ -337,22 +407,29 @@ class Synchronizer {
                 if (!this.remotePullInfoMap[entity]) {
                     this.remotePullInfoMap[entity] = {};
                 }
-                if (!this.remotePullInfoMap[entity][id]) {
-                    const { getRemotePullInfo, pullEntities } = this.config.remotes.find(ele => ele.entity === entity);
+                if (!this.remotePullInfoMap[entity][entityId]) {
+                    const { getPullInfo, pullEntities } = this.config.remotes.find(ele => ele.entity === entity);
                     const pullEntityDict = {};
                     if (pullEntities) {
                         pullEntities.forEach((def) => pullEntityDict[def.entity] = def);
                     }
-                    this.remotePullInfoMap[entity][id] = {
-                        pullInfo: await getRemotePullInfo(id),
+                    this.remotePullInfoMap[entity][entityId] = {
+                        pullInfo: await getPullInfo(context, {
+                            selfId: meEntityId,
+                            remoteEntityId: entityId,
+                        }),
                         pullEntityDict,
                     };
                 }
-                const { pullInfo, pullEntityDict } = this.remotePullInfoMap[entity][id];
-                const { userId, algorithm, publicKey } = pullInfo;
-                // todo 解密
+                const { pullInfo, pullEntityDict } = this.remotePullInfoMap[entity][entityId];
+                const { userId, algorithm, publicKey, cxtInfo } = pullInfo;
                 (0, assert_1.default)(userId);
-                if (!this.pullMaxBornAtMap.hasOwnProperty(id)) {
+                context.setCurrentUserId(userId);
+                if (cxtInfo) {
+                    await context.initialize(cxtInfo);
+                }
+                // todo 解密
+                if (!this.pullMaxBornAtMap.hasOwnProperty(entityId)) {
                     const [maxHisOper] = await context.select('oper', {
                         data: {
                             id: 1,
@@ -372,10 +449,9 @@ class Synchronizer {
                         indexFrom: 0,
                         count: 1,
                     }, { dontCollect: true });
-                    this.pullMaxBornAtMap[id] = maxHisOper?.bornAt || 0;
+                    this.pullMaxBornAtMap[entityId] = maxHisOper?.bornAt || 0;
                 }
-                let maxBornAt = this.pullMaxBornAtMap[id];
-                context.setCurrentUserId(userId);
+                let maxBornAt = this.pullMaxBornAtMap[entityId];
                 const opers = body;
                 const outdatedOpers = opers.filter(ele => ele.bornAt <= maxBornAt);
                 const freshOpers = opers.filter(ele => ele.bornAt > maxBornAt);
@@ -431,6 +507,7 @@ class Synchronizer {
                                 maxBornAt = bornAt;
                             }
                             catch (err) {
+                                console.error(err);
                                 console.error('sync时出错', entity, JSON.stringify(freshOper));
                                 failed = {
                                     id,
@@ -441,7 +518,7 @@ class Synchronizer {
                         }
                     })()
                 ]);
-                this.pullMaxBornAtMap[id] = maxBornAt;
+                this.pullMaxBornAtMap[entityId] = maxBornAt;
                 return {
                     successIds,
                     failed,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "3.3.2",
+    "version": "3.3.4",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -22,8 +22,8 @@
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^2.2.5",
         "oak-db": "^3.1.0",
-        "oak-domain": "^4.2.3",
-        "oak-frontend-base": "^4.2.4",
+        "oak-domain": "^4.2.8",
+        "oak-frontend-base": "^4.2.7",
         "socket.io": "^4.7.2",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"