oak-backend-base 4.0.1 → 4.0.3

package/lib/AppLoader.js

@@ -65,7 +65,7 @@ class AppLoader extends types_1.AppLoader {
         const { dbConfig } = this.getConfiguration();
         const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
         const depGraph = (0, dependencyBuilder_1.analyzeDepedency)(process.cwd());
-        this.externalDependencies = Object.keys(depGraph.nodeDict);
+        this.externalDependencies = depGraph.ascOrder;
         const { authDeduceRelationMap, selectFreeEntities, updateFreeDict } = this.requireSth('lib/configuration/relation');
         this.aspectDict = Object.assign({}, index_1.default, this.requireSth('lib/aspects/index'));
         this.dbStore = new DbStore_1.DbStore(storageSchema, () => this.contextBuilder(this.dbStore), dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
@@ -73,25 +73,29 @@ class AppLoader extends types_1.AppLoader {
             this.dataSubscriber = new DataSubscriber_1.default(ns, nsServer);
         }
         const { BackendRuntimeContext } = require(`${path}/lib/context/BackendRuntimeContext`);
-        this.contextBuilder = (store) => {
-            const context = new BackendRuntimeContext(store);
-            context.clusterInfo = (0, env_1.getClusterInfo)();
-            const originCommit = context.commit;
-            context.commit = async () => {
-                const { eventOperationMap, opRecords } = context;
-                await originCommit.call(context);
+        const loaderThis = this;
+        // 需要重载context上的构造和commit方法，否则程序中执行context.restartToExecute这样的方法中，new一个context出来是无法正确执行的
+        class BackendRuntimeContextWrapper extends BackendRuntimeContext {
+            constructor(store) {
+                super(store);
+                this.clusterInfo = (0, env_1.getClusterInfo)();
+            }
+            async commit() {
+                const { eventOperationMap, opRecords } = this;
+                await super.commit();
                 // 注入在提交后向dataSubscribe发送订阅的事件
-                if (this.dataSubscriber) {
+                if (loaderThis.dataSubscriber) {
                     Object.keys(eventOperationMap).forEach((event) => {
                         const ids = eventOperationMap[event];
                         const opRecordsToPublish = opRecords.filter((ele) => !!ele.id && ids.includes(ele.id));
                         (0, assert_1.default)(opRecordsToPublish.length === ids.length, '要推送的事件的operation数量不足，请检查确保');
-                        this.dataSubscriber.publishEvent(event, opRecordsToPublish, context.getSubscriberId());
+                        loaderThis.dataSubscriber.publishEvent(event, opRecordsToPublish, this.getSubscriberId());
                     });
                 }
-            };
-            return context;
-        };
+            }
+        }
+        ;
+        this.contextBuilder = (store) => new BackendRuntimeContextWrapper(store);
     }
     registerTrigger(trigger) {
         this.dbStore.registerTrigger(trigger);
@@ -220,13 +224,15 @@ class AppLoader extends types_1.AppLoader {
                     }
                 }]);
         };
-        for (const router in endpoints) {
-            const item = endpoints[router];
-            if (item instanceof Array) {
-                item.forEach(ele => transformEndpointItem(router, ele));
-            }
-            else {
-                transformEndpointItem(router, item);
+        if (endpoints) {
+            for (const router in endpoints) {
+                const item = endpoints[router];
+                if (item instanceof Array) {
+                    item.forEach(ele => transformEndpointItem(router, ele));
+                }
+                else {
+                    transformEndpointItem(router, item);
+                }
             }
         }
         if (this.synchronizer) {
@@ -285,7 +291,7 @@ class AppLoader extends types_1.AppLoader {
         const watchers = this.requireSth('lib/watchers/index');
         const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
         const { watchers: adWatchers } = (0, IntrinsicLogics_1.makeIntrinsicLogics)(this.dbStore.getSchema(), ActionDefDict);
-        const totalWatchers = watchers.concat(adWatchers);
+        const totalWatchers = (watchers || []).concat(adWatchers);
         let count = 0;
         const execOne = async (watcher, start) => {
             try {
@@ -317,38 +323,40 @@ class AppLoader extends types_1.AppLoader {
     }
     startTimers() {
         const timers = this.requireSth('lib/timers/index');
-        for (const timer of timers) {
-            const { cron, name } = timer;
-            (0, node_schedule_1.scheduleJob)(name, cron, async (date) => {
-                const start = Date.now();
-                console.log(`定时器【${name}】开始执行，时间是【${date.toLocaleTimeString()}】`);
-                if (timer.hasOwnProperty('entity')) {
-                    try {
-                        const result = await this.execWatcher(timer);
-                        console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒】，结果是`, result);
+        if (timers) {
+            for (const timer of timers) {
+                const { cron, name } = timer;
+                (0, node_schedule_1.scheduleJob)(name, cron, async (date) => {
+                    const start = Date.now();
+                    console.log(`定时器【${name}】开始执行，时间是【${date.toLocaleTimeString()}】`);
+                    if (timer.hasOwnProperty('entity')) {
+                        try {
+                            const result = await this.execWatcher(timer);
+                            console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒】，结果是`, result);
+                        }
+                        catch (err) {
+                            console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒】，错误是`, err);
+                        }
                     }
-                    catch (err) {
-                        console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒】，错误是`, err);
-                    }
-                }
-                else {
-                    const context = await this.makeContext();
-                    try {
-                        const { timer: timerFn } = timer;
-                        const result = await timerFn(context);
-                        console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
-                        await context.commit();
+                    else {
+                        const context = await this.makeContext();
+                        try {
+                            const { timer: timerFn } = timer;
+                            const result = await timerFn(context);
+                            console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                            await context.commit();
+                        }
+                        catch (err) {
+                            console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                            await context.rollback();
+                        }
                     }
-                    catch (err) {
-                        console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
-                        await context.rollback();
-                    }
-                }
-            });
+                });
+            }
         }
     }
     async execStartRoutines() {
-        const routines = this.requireSth('lib/routines/start');
+        const routines = this.requireSth('lib/routines/start') || [];
         if (this.synchronizer) {
             const routine = this.synchronizer.getSyncRoutine();
             routines.push(routine);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.0.1",
+    "version": "4.0.3",
     "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": "^3.0.0",
-        "oak-db": "^3.3.0",
-        "oak-domain": "^5.0.0",
-        "oak-frontend-base": "^5.0.0",
+        "oak-common-aspect": "~3.0.0",
+        "oak-db": "~3.3.0",
+        "oak-domain": "~5.0.5",
+        "oak-frontend-base": "~5.0.5",
         "socket.io": "^4.7.2",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"

package/lib/DataSubscriber.d.ts

@@ -1,18 +0,0 @@
-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 +0,0 @@
-"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;