oak-backend-base 4.1.22 → 4.1.24

package/lib/AppLoader.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord, FreeTimer, OperationResult } from "oak-domain/lib/types";
 import { DbStore } from "./DbStore";
@@ -8,6 +7,7 @@ import { Namespace } from 'socket.io';
 import DataSubscriber from './cluster/DataSubscriber';
 import Synchronizer from './Synchronizer';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
+import { InternalErrorHandler } from './types';
 export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends GeneralAppLoader<ED, Cxt> {
     protected dbStore: DbStore<ED, Cxt>;
     private aspectDict;
@@ -18,6 +18,17 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     private nsSocket?;
     private watcherTimerId?;
     private scheduledJobs;
+    private internalErrorHandlers;
+    regAllExceptionHandler(): void;
+    /**
+     * 注册一个内部错误处理器
+     * @param handler 内部错误处理器
+     */
+    registerInternalErrorHandler(handler: InternalErrorHandler<ED, Cxt>): void;
+    /**
+     * 发布内部错误事件给注册的处理器
+     */
+    private publishInternalError;
     private requireSth;
     protected makeContext(cxtStr?: string, headers?: IncomingHttpHeaders): Promise<Cxt>;
     /**
@@ -38,9 +49,9 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     initialize(ifExists?: 'drop' | 'omit' | 'dropIfNotStatic'): Promise<void>;
     getStore(): DbStore<ED, Cxt>;
     getEndpoints(prefix: string): [string, "post" | "get" | "put" | "delete", string, (params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<{
-        headers?: Record<string, string | string[]> | undefined;
+        headers?: Record<string, string | string[]>;
         data: any;
-        statusCode?: number | undefined;
+        statusCode?: number;
     }>][];
     protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt, singleton?: true): Promise<OperationResult<ED>>;
     protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, forUpdate?: true, singleton?: true): Promise<Partial<ED[T]["Schema"]>[]>;

package/lib/AppLoader.js

@@ -28,6 +28,51 @@ class AppLoader extends types_1.AppLoader {
     nsSocket;
     watcherTimerId;
     scheduledJobs = {};
+    internalErrorHandlers = new Array();
+    regAllExceptionHandler() {
+        const handlers = this.requireSth('lib/configuration/exception');
+        if (Array.isArray(handlers)) {
+            handlers.forEach((handler) => {
+                console.log(`注册内部错误处理器: ${handler.name}`);
+                this.registerInternalErrorHandler(handler);
+            });
+        }
+        else {
+            console.warn('lib/configuration/exception必须默认导出一个处理器数组，当前导出类型不正确，将忽略此配置');
+        }
+    }
+    /**
+     * 注册一个内部错误处理器
+     * @param handler 内部错误处理器
+     */
+    registerInternalErrorHandler(handler) {
+        // 检查有没有名称重复
+        if (this.internalErrorHandlers.find(h => h.name === handler.name)) {
+            throw new Error(`内部错误处理器名称重复: ${handler.name}`);
+        }
+        this.internalErrorHandlers.push(handler);
+    }
+    /**
+     * 发布内部错误事件给注册的处理器
+     */
+    async publishInternalError(type, message, err) {
+        const errorToPublish = (0, lodash_1.cloneDeep)(err);
+        await Promise.all(this.internalErrorHandlers.map((handler) => {
+            return new Promise(async (resolve) => {
+                try {
+                    const ctx = await this.makeContext();
+                    console.log(`调用internalErrorHandler【${handler.name}】处理内部错误事件`);
+                    handler.handle(ctx, type, message, errorToPublish);
+                }
+                catch (e) {
+                    console.error('执行internalErrorHandler时出错', e);
+                }
+                finally {
+                    resolve();
+                }
+            });
+        }));
+    }
     requireSth(filePath) {
         return (0, requirePrj_1.default)(this.path, filePath, this.externalDependencies);
     }
@@ -172,7 +217,9 @@ class AppLoader extends types_1.AppLoader {
             };
         }
         catch (err) {
+            console.error(`执行aspect「${name}」出错`, err);
             await context.rollback();
+            this.publishInternalError(`aspect`, `执行aspect「${name}」出错`, err);
             if (err instanceof types_1.OakException) {
                 throw err;
             }
@@ -357,6 +404,7 @@ class AppLoader extends types_1.AppLoader {
             else {
                 await context.rollback();
             }
+            // 不能在这里publish，因为这个方法可能是在timer中调用，也可能是在routine中调用
             throw err;
         }
     }
@@ -382,6 +430,7 @@ class AppLoader extends types_1.AppLoader {
             }
             catch (err) {
                 console.error(`执行watcher【${watcher.name}】失败，耗时【${Date.now() - start}】，结果是：`, err);
+                await this.publishInternalError(`watcher`, `执行watcher【${watcher.name}】失败`, err);
             }
         };
         const doWatchers = async () => {
@@ -400,6 +449,7 @@ class AppLoader extends types_1.AppLoader {
             }
             catch (err) {
                 console.error(`执行了checkpoint，发生错误：`, err);
+                await this.publishInternalError(`checkpoint`, `执行checkpoint发生错误`, err);
             }
             this.watcherTimerId = setTimeout(() => doWatchers(), 120000);
         };
@@ -423,7 +473,8 @@ class AppLoader extends types_1.AppLoader {
                             console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒】，结果是`, result);
                         }
                         catch (err) {
-                            console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒】，错误是`, err);
+                            console.error(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒】，错误是`, err);
+                            this.publishInternalError(`timer`, `定时器【${name}】执行失败`, err);
                         }
                     }
                     else {
@@ -436,13 +487,14 @@ class AppLoader extends types_1.AppLoader {
                             await context.commit();
                         }
                         catch (err) {
-                            console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                            console.error(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
                             if (err instanceof types_1.OakPartialSuccess) {
                                 await context.commit();
                             }
                             else {
                                 await context.rollback();
                             }
+                            this.publishInternalError(`timer`, `定时器【${name}】执行失败`, err);
                         }
                     }
                 });
@@ -468,7 +520,7 @@ class AppLoader extends types_1.AppLoader {
                     console.log(`例程【${routine.name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
                 }
                 catch (err) {
-                    console.warn(`例程【${routine.name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    console.error(`例程【${routine.name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
                     throw err;
                 }
             }
@@ -484,7 +536,7 @@ class AppLoader extends types_1.AppLoader {
                     await context.commit();
                 }
                 catch (err) {
-                    console.warn(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    console.error(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
                     await context.rollback();
                     throw err;
                 }

package/lib/Synchronizer.d.ts

@@ -27,7 +27,7 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      * 根据sync的定义，生成对应的 commit triggers
      * @returns
      */
-    getSyncTriggers(): VolatileTrigger<ED, keyof ED, Cxt>[];
+    getSyncTriggers(): Array<VolatileTrigger<ED, keyof ED, Cxt>>;
     getSelfEndpoint(): EndpointItem<ED, Cxt>;
     tryCreateSyncProcess(): void;
 }

package/lib/Synchronizer.js

@@ -114,7 +114,7 @@ class Synchronizer {
                             remoteEntityId: entityId,
                             data: queue.map((ele) => ({
                                 entity: ele.oper.targetEntity,
-                                rowIds: ele.oper.filter.id.$in,
+                                rowIds: ele.oper.filter.id.$in, // 暂时应该没什么用
                                 action: ele.oper.action,
                                 data: ele.oper.data,
                             })),

package/lib/cluster/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClusterInfo = void 0;
+exports.getClusterInfo = getClusterInfo;
 function getProcessEnvOption(option) {
     if (process.env.hasOwnProperty(option)) {
         return process.env[option];
@@ -54,4 +54,3 @@ const MyClusterInfo = initialize();
 function getClusterInfo() {
     return MyClusterInfo;
 }
-exports.getClusterInfo = getClusterInfo;

package/lib/routines/i18n.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAndUpdateI18n = exports.checkI18n = void 0;
+exports.checkI18n = checkI18n;
+exports.checkAndUpdateI18n = checkAndUpdateI18n;
 const tslib_1 = require("tslib");
 const node_path_1 = require("node:path");
 const requirePrj_1 = tslib_1.__importDefault(require("../utils/requirePrj"));
@@ -66,7 +67,6 @@ async function checkAndUpdateI18nInner(context, onlyCheck) {
 function checkI18n(context) {
     return checkAndUpdateI18nInner(context, true);
 }
-exports.checkI18n = checkI18n;
 /**
  * 检查项目目录下的i18n数据和数据库中的差异，并更新
  * @param context
@@ -75,4 +75,3 @@ exports.checkI18n = checkI18n;
 function checkAndUpdateI18n(context) {
     return checkAndUpdateI18nInner(context);
 }
-exports.checkAndUpdateI18n = checkAndUpdateI18n;

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseEntityDict } from "oak-domain";
+import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
+import { EntityDict } from "oak-domain/lib/types";
+export type InternalErrorType = 'aspect' | 'trigger' | 'watcher' | 'timer' | 'checkpoint';
+export type InternalErrorHandler<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    handle: (ctx: Cxt, type: InternalErrorType, message: string, err: Error) => Promise<void>;
+};
+export type ExceptionPublisher = (type: string, message: string, err: any) => Promise<void>;

package/lib/types/index.js

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

package/lib/utils/requirePrj.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requireSth;
 const fs_1 = require("fs");
 const lodash_1 = require("oak-domain/lib/utils/lodash");
 const path_1 = require("path");
@@ -20,4 +21,3 @@ function requireSth(prjPath, filePath, dependencies) {
     }
     return (0, lodash_1.mergeConcatMany)(sthExternal);
 }
-exports.default = requireSth;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.22",
+    "version": "4.1.24",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -23,8 +23,8 @@
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^3.0.5",
         "oak-db": "^3.3.11",
-        "oak-domain": "^5.1.28",
-        "oak-frontend-base": "^5.3.38",
+        "oak-domain": "^5.1.30",
+        "oak-frontend-base": "^5.3.43",
         "socket.io": "^4.8.1",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"