oak-backend-base 3.2.3 → 3.3.1

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.d.ts

@@ -1,20 +1,20 @@
-import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
-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';
-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) => 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>;
-}
+import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
+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/lib/context/BackendRuntimeContext';
+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) => 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

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

package/lib/Synchronizer.d.ts

@@ -0,0 +1,23 @@
+import { EntityDict, StorageSchema, EndpointItem } 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 remotePushChannel;
+    private pushOper;
+    private loadPublicKey;
+    private makeCreateOperTrigger;
+    constructor(config: SyncConfigWrapper<ED>, schema: StorageSchema<ED>);
+    /**
+     * 根据sync的定义，生成对应的 commit triggers
+     * @returns
+     */
+    getSyncTriggers(): VolatileTrigger<ED, keyof ED, Cxt>[];
+    private checkOperationConsistent;
+    getSelfEndpoint(): EndpointItem<ED, Cxt>;
+}