oak-backend-base 3.0.0 → 3.1.0

package/lib/AppLoader.d.ts

@@ -1,25 +1,31 @@
-import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { AppLoader as GeneralAppLoader, EntityDict } from "oak-domain/lib/types";
-import { DbStore } from "./DbStore";
-import { MySQLConfiguration } from 'oak-db/lib/MySQL/types/Configuration';
-import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
-import { Endpoint } from 'oak-domain/lib/types/Endpoint';
-export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends GeneralAppLoader<ED, Cxt> {
-    private dbStore;
-    private aspectDict;
-    private externalDependencies;
-    private contextBuilder;
-    private requireSth;
-    constructor(path: string, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, dbConfig: MySQLConfiguration);
-    initTriggers(): void;
-    startWatchers(): void;
-    mount(initialize?: true): Promise<void>;
-    unmount(): Promise<void>;
-    execAspect(name: string, context: Cxt, params?: any): Promise<any>;
-    initialize(dropIfExists?: boolean): Promise<void>;
-    getStore(): DbStore<ED, Cxt>;
-    getEndpoints(): Record<string, Endpoint<ED, Cxt>>;
-    startTimers(): void;
-    execStartRoutines(): Promise<void>;
-    execRoutine(routine: (context: Cxt) => Promise<void>): Promise<void>;
-}
+/// <reference types="node" />
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { AppLoader as GeneralAppLoader, EntityDict, OpRecord } from "oak-domain/lib/types";
+import { DbStore } from "./DbStore";
+import { BackendRuntimeContext } from 'oak-frontend-base';
+import { IncomingHttpHeaders, IncomingMessage } from 'http';
+import { Namespace } from 'socket.io';
+export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends GeneralAppLoader<ED, Cxt> {
+    private dbStore;
+    private aspectDict;
+    private externalDependencies;
+    private dataSubscriber?;
+    private contextBuilder;
+    private requireSth;
+    constructor(path: string, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>, header?: IncomingHttpHeaders) => Promise<Cxt>, ns?: Namespace);
+    initTriggers(): void;
+    startWatchers(): void;
+    mount(initialize?: true): Promise<void>;
+    unmount(): Promise<void>;
+    execAspect(name: string, header?: IncomingHttpHeaders, contextString?: string, params?: any): Promise<{
+        opRecords: OpRecord<ED>[];
+        result: any;
+        message?: string;
+    }>;
+    initialize(dropIfExists?: boolean): Promise<void>;
+    getStore(): DbStore<ED, Cxt>;
+    getEndpoints(prefix: string): [string, "get" | "post" | "put" | "delete", string, (params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>][];
+    startTimers(): void;
+    execStartRoutines(): Promise<void>;
+    execRoutine(routine: (context: Cxt) => Promise<void>): Promise<void>;
+}

package/lib/AppLoader.js

@@ -1,251 +1,343 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppLoader = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const node_schedule_1 = require("node-schedule");
-const env_1 = require("oak-domain/lib/compiler/env");
-const actionDef_1 = require("oak-domain/lib/store/actionDef");
-const lodash_1 = require("oak-domain/lib/utils/lodash");
-const uuid_1 = require("oak-domain/lib/utils/uuid");
-const types_1 = require("oak-domain/lib/types");
-const DbStore_1 = require("./DbStore");
-const index_1 = tslib_1.__importStar(require("oak-common-aspect/lib/index"));
-const assert_1 = tslib_1.__importDefault(require("assert"));
-class AppLoader extends types_1.AppLoader {
-    dbStore;
-    aspectDict;
-    externalDependencies;
-    contextBuilder;
-    requireSth(filePath) {
-        const sth = require((0, path_1.join)(this.path, filePath)).default;
-        const sthExternal = this.externalDependencies.map(ele => {
-            const depFilePath = (0, path_1.join)(this.path, 'node_modules', ele, filePath);
-            if ((0, fs_1.existsSync)(`${depFilePath}.js`)) {
-                return require(depFilePath).default;
-            }
-        }).filter(ele => !!ele);
-        if (sth instanceof Array) {
-            sthExternal.forEach((sth2, idx) => {
-                (0, assert_1.default)(sth2 instanceof Array, `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象不是数组，与项目对应路径的输出不一致`);
-                sth.push(...sth2);
-            });
-            return sth;
-        }
-        (0, assert_1.default)(typeof sth === 'object');
-        const sthOut = {};
-        sthExternal.forEach((sth2, idx) => {
-            (0, assert_1.default)(typeof sth2 === 'object' && !(sth2 instanceof Array), `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象不是非数组对象，与项目对应路径的输出不一致`);
-            const inter = (0, lodash_1.intersection)(Object.keys(sthOut), Object.keys(sth2));
-            if (inter.length > 0) {
-                console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${inter.join(',')}】与其它对应路径输出的key值有冲突，请仔细检查避免错误`);
-                inter.forEach((ele) => {
-                    if (sth2[ele] instanceof Array && sthOut[ele]) {
-                        (0, assert_1.default)(sthOut[ele] instanceof Array, `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象的${ele}键值是数组，但之前的相应对象的${ele}却不是，请仔细检查以避免错误`);
-                        console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${ele}】与其它对应路径输出的key值【${ele}】将以数组格式进行合并，请仔细检查避免错误`);
-                        sth2[ele].push(...sthOut[ele]);
-                    }
-                    else if (!(sth2[ele] instanceof Array) && sthOut[ele]) {
-                        (0, assert_1.default)(!(sthOut[ele] instanceof Array), `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象的${ele}键值不是数组，但之前的相应对象的${ele}却是，请仔细检查以避免错误`);
-                        console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${ele}】将对与其它对应路径输出的key值【${ele}】进行覆盖，请仔细检查避免错误`);
-                    }
-                });
-            }
-            Object.assign(sthOut, sth2);
-        });
-        const inter = (0, lodash_1.intersection)(Object.keys(sthOut), Object.keys(sth));
-        if (inter.length > 0) {
-            inter.forEach((ele) => {
-                if (sth[ele] instanceof Array && sthOut[ele]) {
-                    (0, assert_1.default)(sthOut[ele] instanceof Array, `项目${filePath}中的default输出对象的${ele}键值是数组，但之前的相应对象的${ele}却不是，请仔细检查以避免错误`);
-                    console.warn(`项目${filePath}中的default输出对象中的key值【${ele}】与其它引用包该路径输出的key值【${ele}】将以数组格式进行合并，请仔细检查避免错误`);
-                    sth[ele].push(...sthOut[ele]);
-                }
-                else if (!(sth[ele] instanceof Array) && sthOut[ele]) {
-                    (0, assert_1.default)(!(sthOut[ele] instanceof Array), `项目${filePath}中的default输出对象的${ele}键值不是数组，但之前的相应对象的${ele}却是，请仔细检查以避免错误`);
-                    console.warn(`项目${filePath}中的default输出对象中的key值【${ele}】将对其它引用包该路径输出的key值【${ele}】进行覆盖，请仔细检查避免错误`);
-                }
-            });
-        }
-        Object.assign(sthOut, sth);
-        return sthOut;
-    }
-    constructor(path, contextBuilder, dbConfig) {
-        super(path);
-        const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
-        const { ActionCascadePathGraph, RelationCascadePathGraph, selectFreeEntities, createFreeEntities, updateFreeEntities, deducedRelationMap } = require(`${path}/lib/oak-app-domain/Relation`);
-        this.externalDependencies = require((0, env_1.OAK_EXTERNAL_LIBS_FILEPATH)((0, path_1.join)(path, 'lib')));
-        this.aspectDict = Object.assign({}, index_1.default, this.requireSth('lib/aspects/index'));
-        this.dbStore = new DbStore_1.DbStore(storageSchema, contextBuilder, dbConfig, ActionCascadePathGraph, RelationCascadePathGraph, deducedRelationMap, selectFreeEntities, createFreeEntities, updateFreeEntities);
-        this.contextBuilder = contextBuilder;
-    }
-    initTriggers() {
-        const triggers = this.requireSth('lib/triggers/index');
-        const checkers = this.requireSth('lib/checkers/index');
-        const authDict = this.requireSth('lib/auth/index');
-        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
-        const { triggers: adTriggers, checkers: adCheckers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
-        triggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
-        adTriggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
-        checkers.forEach((checker) => this.dbStore.registerChecker(checker));
-        adCheckers.forEach((checker) => this.dbStore.registerChecker(checker));
-    }
-    startWatchers() {
-        const watchers = this.requireSth('lib/watchers/index');
-        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
-        const { watchers: adWatchers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
-        const totalWatchers = watchers.concat(adWatchers);
-        let count = 0;
-        const doWatchers = async () => {
-            count++;
-            const start = Date.now();
-            const context = await this.contextBuilder()(this.dbStore);
-            for (const w of totalWatchers) {
-                await context.begin();
-                try {
-                    if (w.hasOwnProperty('actionData')) {
-                        const { entity, action, filter, actionData } = w;
-                        const filter2 = typeof filter === 'function' ? await filter() : filter;
-                        const data = typeof actionData === 'function' ? await actionData() : actionData; // 这里有个奇怪的编译错误，不理解 by Xc
-                        const result = await this.dbStore.operate(entity, {
-                            id: await (0, uuid_1.generateNewIdAsync)(),
-                            action,
-                            data,
-                            filter: filter2
-                        }, context, {
-                            dontCollect: true,
-                        });
-                        console.log(`执行了watcher【${w.name}】，结果是：`, result);
-                    }
-                    else {
-                        const { entity, projection, fn, filter } = w;
-                        const filter2 = typeof filter === 'function' ? await filter() : filter;
-                        const projection2 = typeof projection === 'function' ? await projection() : projection;
-                        const rows = await this.dbStore.select(entity, {
-                            data: projection2,
-                            filter: filter2,
-                        }, context, {
-                            dontCollect: true,
-                            blockTrigger: true,
-                        });
-                        const result = await fn(context, rows);
-                        console.log(`执行了watcher【${w.name}】，结果是：`, result);
-                    }
-                    await context.commit();
-                }
-                catch (err) {
-                    await context.rollback();
-                    console.error(`执行了watcher【${w.name}】，发生错误：`, err);
-                }
-            }
-            const duration = Date.now() - start;
-            console.log(`第${count}次执行watchers，共执行${watchers.length}个，耗时${duration}毫秒`);
-            setTimeout(() => doWatchers(), 120000);
-        };
-        doWatchers();
-    }
-    async mount(initialize) {
-        const { path } = this;
-        if (!initialize) {
-            this.initTriggers();
-        }
-        const { importations, exportations } = require(`${path}/lib/ports/index`);
-        (0, index_1.registerPorts)(importations || [], exportations || []);
-        this.dbStore.connect();
-    }
-    async unmount() {
-        (0, index_1.clearPorts)();
-        this.dbStore.disconnect();
-    }
-    async execAspect(name, context, params) {
-        const fn = this.aspectDict[name];
-        if (!fn) {
-            throw new Error(`不存在的接口名称: ${name}`);
-        }
-        return await fn(params, context);
-    }
-    async initialize(dropIfExists) {
-        await this.dbStore.initialize(dropIfExists);
-        const data = this.requireSth('lib/data/index');
-        const context = await this.contextBuilder()(this.dbStore);
-        for (const entity in data) {
-            let rows = data[entity];
-            if (entity === 'area') {
-                //  对area暂时处理一下
-                rows = require('./data/area.json');
-            }
-            if (rows.length > 0) {
-                await context.begin();
-                try {
-                    await this.dbStore.operate(entity, {
-                        data: rows,
-                        action: 'create',
-                    }, context, {
-                        dontCollect: true,
-                        dontCreateOper: true,
-                    });
-                    await context.commit();
-                    console.log(`data in ${entity} initialized!`);
-                }
-                catch (err) {
-                    await context.rollback();
-                    console.error(`data on ${entity} initilization failed!`);
-                    throw err;
-                }
-            }
-        }
-        this.dbStore.disconnect();
-    }
-    getStore() {
-        return this.dbStore;
-    }
-    getEndpoints() {
-        const endpoints = this.requireSth('lib/endpoints/index');
-        return endpoints;
-    }
-    startTimers() {
-        const timers = this.requireSth('lib/timers/index');
-        for (const timer of timers) {
-            const { cron, fn, name } = timer;
-            (0, node_schedule_1.scheduleJob)(name, cron, async (date) => {
-                const start = Date.now();
-                const context = await this.contextBuilder()(this.dbStore);
-                await context.begin();
-                console.log(`定时器【${name}】开始执行，时间是【${date.toLocaleTimeString()}】`);
-                try {
-                    const result = await fn(context);
-                    console.log(`定时器【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
-                    await context.commit();
-                }
-                catch (err) {
-                    console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
-                    await context.rollback();
-                }
-            });
-        }
-    }
-    async execStartRoutines() {
-        const routines = this.requireSth('lib/routines/start');
-        for (const routine of routines) {
-            const { name, fn } = routine;
-            const context = await this.contextBuilder()(this.dbStore);
-            const start = Date.now();
-            await context.begin();
-            try {
-                const result = await fn(context);
-                console.log(`例程【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
-                await context.commit();
-            }
-            catch (err) {
-                console.warn(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
-                await context.rollback();
-            }
-        }
-    }
-    async execRoutine(routine) {
-        const context = await this.contextBuilder()(this.dbStore);
-        await routine(context);
-    }
-}
-exports.AppLoader = AppLoader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLoader = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const node_schedule_1 = require("node-schedule");
+const env_1 = require("oak-domain/lib/compiler/env");
+const actionDef_1 = require("oak-domain/lib/store/actionDef");
+const lodash_1 = require("oak-domain/lib/utils/lodash");
+const uuid_1 = require("oak-domain/lib/utils/uuid");
+const types_1 = require("oak-domain/lib/types");
+const DbStore_1 = require("./DbStore");
+const index_1 = tslib_1.__importStar(require("oak-common-aspect/lib/index"));
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const DataSubscriber_1 = tslib_1.__importDefault(require("./DataSubscriber"));
+class AppLoader extends types_1.AppLoader {
+    dbStore;
+    aspectDict;
+    externalDependencies;
+    dataSubscriber;
+    contextBuilder;
+    requireSth(filePath) {
+        const depFilePath = (0, path_1.join)(this.path, filePath);
+        let sth;
+        if ((0, fs_1.existsSync)(`${depFilePath}.js`)) {
+            sth = require((0, path_1.join)(this.path, filePath)).default;
+        }
+        const sthExternal = this.externalDependencies.map(ele => {
+            const depFilePath = (0, path_1.join)(this.path, 'node_modules', ele, filePath);
+            if ((0, fs_1.existsSync)(`${depFilePath}.js`)) {
+                return require(depFilePath).default;
+            }
+        }).filter(ele => !!ele);
+        if (!sth) {
+            if (sthExternal.length > 0 && sthExternal[0] instanceof Array) {
+                sth = [];
+            }
+            else {
+                sth = {};
+            }
+        }
+        if (sth instanceof Array) {
+            sthExternal.forEach((sth2, idx) => {
+                (0, assert_1.default)(sth2 instanceof Array, `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象不是数组，与项目对应路径的输出不一致`);
+                sth.push(...sth2);
+            });
+            return sth;
+        }
+        (0, assert_1.default)(typeof sth === 'object');
+        const sthOut = {};
+        sthExternal.forEach((sth2, idx) => {
+            (0, assert_1.default)(typeof sth2 === 'object' && !(sth2 instanceof Array), `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象不是非数组对象，与项目对应路径的输出不一致`);
+            const inter = (0, lodash_1.intersection)(Object.keys(sthOut), Object.keys(sth2));
+            if (inter.length > 0) {
+                console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${inter.join(',')}】与其它对应路径输出的key值有冲突，请仔细检查避免错误`);
+                inter.forEach((ele) => {
+                    if (sth2[ele] instanceof Array && sthOut[ele]) {
+                        (0, assert_1.default)(sthOut[ele] instanceof Array, `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象的${ele}键值是数组，但之前的相应对象的${ele}却不是，请仔细检查以避免错误`);
+                        console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${ele}】与其它对应路径输出的key值【${ele}】将以数组格式进行合并，请仔细检查避免错误`);
+                        sth2[ele].push(...sthOut[ele]);
+                    }
+                    else if (!(sth2[ele] instanceof Array) && sthOut[ele]) {
+                        (0, assert_1.default)(!(sthOut[ele] instanceof Array), `${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象的${ele}键值不是数组，但之前的相应对象的${ele}却是，请仔细检查以避免错误`);
+                        console.warn(`${(0, path_1.join)(this.path, 'node_modules', this.externalDependencies[idx], filePath)}中的default输出对象中的key值【${ele}】将对与其它对应路径输出的key值【${ele}】进行覆盖，请仔细检查避免错误`);
+                    }
+                });
+            }
+            Object.assign(sthOut, sth2);
+        });
+        const inter = (0, lodash_1.intersection)(Object.keys(sthOut), Object.keys(sth));
+        if (inter.length > 0) {
+            inter.forEach((ele) => {
+                if (sth[ele] instanceof Array && sthOut[ele]) {
+                    (0, assert_1.default)(sthOut[ele] instanceof Array, `项目${filePath}中的default输出对象的${ele}键值是数组，但之前的相应对象的${ele}却不是，请仔细检查以避免错误`);
+                    console.warn(`项目${filePath}中的default输出对象中的key值【${ele}】与其它引用包该路径输出的key值【${ele}】将以数组格式进行合并，请仔细检查避免错误`);
+                    sth[ele].push(...sthOut[ele]);
+                }
+                else if (!(sth[ele] instanceof Array) && sthOut[ele]) {
+                    (0, assert_1.default)(!(sthOut[ele] instanceof Array), `项目${filePath}中的default输出对象的${ele}键值不是数组，但之前的相应对象的${ele}却是，请仔细检查以避免错误`);
+                    console.warn(`项目${filePath}中的default输出对象中的key值【${ele}】将对其它引用包该路径输出的key值【${ele}】进行覆盖，请仔细检查避免错误`);
+                }
+            });
+        }
+        Object.assign(sthOut, sth);
+        return sthOut;
+    }
+    constructor(path, contextBuilder, ns) {
+        super(path);
+        const dbConfig = require((0, path_1.join)(path, '/configuration/mysql.json'));
+        const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
+        const { authDeduceRelationMap, selectFreeEntities, updateFreeDict } = require(`${path}/lib/config/relation`);
+        this.externalDependencies = require((0, env_1.OAK_EXTERNAL_LIBS_FILEPATH)((0, path_1.join)(path, 'lib')));
+        this.aspectDict = Object.assign({}, index_1.default, this.requireSth('lib/aspects/index'));
+        this.dbStore = new DbStore_1.DbStore(storageSchema, contextBuilder, dbConfig, authDeduceRelationMap, selectFreeEntities, updateFreeDict);
+        if (ns) {
+            this.dataSubscriber = new DataSubscriber_1.default(ns, (scene) => this.contextBuilder(scene)(this.dbStore));
+            this.contextBuilder = (scene) => async (store) => {
+                const context = await contextBuilder(scene)(store);
+                // 注入在提交前向dataSubscribe
+                const originCommit = context.commit;
+                context.commit = async () => {
+                    this.dataSubscriber.onDataCommited(context);
+                    await originCommit.call(context);
+                };
+                return context;
+            };
+        }
+        else {
+            this.contextBuilder = contextBuilder;
+        }
+    }
+    initTriggers() {
+        const triggers = this.requireSth('lib/triggers/index');
+        const checkers = this.requireSth('lib/checkers/index');
+        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
+        const { triggers: adTriggers, checkers: adCheckers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
+        triggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
+        adTriggers.forEach((trigger) => this.dbStore.registerTrigger(trigger));
+        checkers.forEach((checker) => this.dbStore.registerChecker(checker));
+        adCheckers.forEach((checker) => this.dbStore.registerChecker(checker));
+    }
+    startWatchers() {
+        const watchers = this.requireSth('lib/watchers/index');
+        const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
+        const { watchers: adWatchers } = (0, actionDef_1.makeIntrinsicCTWs)(this.dbStore.getSchema(), ActionDefDict);
+        const totalWatchers = watchers.concat(adWatchers);
+        let count = 0;
+        const doWatchers = async () => {
+            count++;
+            const start = Date.now();
+            const context = await this.contextBuilder()(this.dbStore);
+            for (const w of totalWatchers) {
+                await context.begin();
+                try {
+                    if (w.hasOwnProperty('actionData')) {
+                        const { entity, action, filter, actionData } = w;
+                        const filter2 = typeof filter === 'function' ? await filter() : filter;
+                        const data = typeof actionData === 'function' ? await actionData() : actionData; // 这里有个奇怪的编译错误，不理解 by Xc
+                        const result = await this.dbStore.operate(entity, {
+                            id: await (0, uuid_1.generateNewIdAsync)(),
+                            action,
+                            data,
+                            filter: filter2
+                        }, context, {
+                            dontCollect: true,
+                        });
+                        console.log(`执行了watcher【${w.name}】，结果是：`, result);
+                    }
+                    else {
+                        const { entity, projection, fn, filter } = w;
+                        const filter2 = typeof filter === 'function' ? await filter() : filter;
+                        const projection2 = typeof projection === 'function' ? await projection() : projection;
+                        const rows = await this.dbStore.select(entity, {
+                            data: projection2,
+                            filter: filter2,
+                        }, context, {
+                            dontCollect: true,
+                            blockTrigger: true,
+                        });
+                        if (rows.length > 0) {
+                            const result = await fn(context, rows);
+                            console.log(`执行了watcher【${w.name}】，结果是：`, result);
+                        }
+                    }
+                    await context.commit();
+                }
+                catch (err) {
+                    await context.rollback();
+                    console.error(`执行了watcher【${w.name}】，发生错误：`, err);
+                }
+            }
+            const duration = Date.now() - start;
+            console.log(`第${count}次执行watchers，共执行${watchers.length}个，耗时${duration}毫秒`);
+            const now = Date.now();
+            try {
+                await this.dbStore.checkpoint(process.env.NODE_ENV === 'development' ? now - 30 * 1000 : now - 120 * 1000);
+            }
+            catch (err) {
+                console.error(`执行了checkpoint，发生错误：`, err);
+            }
+            setTimeout(() => doWatchers(), 120000);
+        };
+        doWatchers();
+    }
+    async mount(initialize) {
+        const { path } = this;
+        if (!initialize) {
+            this.initTriggers();
+        }
+        const { importations, exportations } = require(`${path}/lib/ports/index`);
+        (0, index_1.registerPorts)(importations || [], exportations || []);
+        this.dbStore.connect();
+    }
+    async unmount() {
+        (0, index_1.clearPorts)();
+        this.dbStore.disconnect();
+    }
+    async execAspect(name, header, contextString, params) {
+        const context = await this.contextBuilder(contextString)(this.dbStore, header);
+        const fn = this.aspectDict[name];
+        if (!fn) {
+            throw new Error(`不存在的接口名称: ${name}`);
+        }
+        await context.begin();
+        try {
+            const result = await fn(params, context);
+            await context.commit();
+            await context.refineOpRecords();
+            return {
+                opRecords: context.opRecords,
+                message: context.getMessage(),
+                result,
+            };
+        }
+        catch (err) {
+            await context.rollback();
+            throw err;
+        }
+    }
+    async initialize(dropIfExists) {
+        await this.dbStore.initialize(dropIfExists);
+        const data = this.requireSth('lib/data/index');
+        const context = await this.contextBuilder()(this.dbStore);
+        for (const entity in data) {
+            let rows = data[entity];
+            if (entity === 'area') {
+                //  对area暂时处理一下
+                rows = require('./data/area.json');
+            }
+            if (rows.length > 0) {
+                await context.begin();
+                try {
+                    await this.dbStore.operate(entity, {
+                        data: rows,
+                        action: 'create',
+                    }, context, {
+                        dontCollect: true,
+                        dontCreateOper: true,
+                    });
+                    await context.commit();
+                    console.log(`data in ${entity} initialized, ${rows.length} rows inserted`);
+                }
+                catch (err) {
+                    await context.rollback();
+                    console.error(`data on ${entity} initilization failed!`);
+                    throw err;
+                }
+            }
+        }
+        this.dbStore.disconnect();
+    }
+    getStore() {
+        return this.dbStore;
+    }
+    getEndpoints(prefix) {
+        const endpoints = this.requireSth('lib/endpoints/index');
+        const endPointRouters = [];
+        const endPointMap = {};
+        const transformEndpointItem = (key, item) => {
+            const { name, method, fn, params: itemParams } = item;
+            const k = `${key}-${name}-${method}`;
+            if (endPointMap[k]) {
+                throw new Error(`endpoint中，url为「${key}」、名为${name}的方法「${method}」存在重复定义`);
+            }
+            endPointMap[k] = true;
+            let url = `${prefix}/${key}`;
+            if (itemParams) {
+                for (const p of itemParams) {
+                    url += `/:${p}`;
+                }
+            }
+            endPointRouters.push([name, method, url, async (params, headers, req, body) => {
+                    const context = await this.contextBuilder()(this.dbStore);
+                    await context.begin();
+                    try {
+                        const result = await fn(context, params, headers, req, body);
+                        await context.commit();
+                        return result;
+                    }
+                    catch (err) {
+                        await context.rollback();
+                        console.error(`endpoint「${key}」方法「${method}」出错`, err);
+                        throw err;
+                    }
+                }]);
+        };
+        for (const router in endpoints) {
+            const item = endpoints[router];
+            if (item instanceof Array) {
+                item.forEach(ele => transformEndpointItem(router, ele));
+            }
+            else {
+                transformEndpointItem(router, item);
+            }
+        }
+        return endPointRouters;
+    }
+    startTimers() {
+        const timers = this.requireSth('lib/timers/index');
+        for (const timer of timers) {
+            const { cron, fn, name } = timer;
+            (0, node_schedule_1.scheduleJob)(name, cron, async (date) => {
+                const start = Date.now();
+                const context = await this.contextBuilder()(this.dbStore);
+                await context.begin();
+                console.log(`定时器【${name}】开始执行，时间是【${date.toLocaleTimeString()}】`);
+                try {
+                    const result = await fn(context);
+                    console.log(`定时器【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    await context.commit();
+                }
+                catch (err) {
+                    console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    await context.rollback();
+                }
+            });
+        }
+    }
+    async execStartRoutines() {
+        const routines = this.requireSth('lib/routines/start');
+        for (const routine of routines) {
+            const { name, fn } = routine;
+            const context = await this.contextBuilder()(this.dbStore);
+            const start = Date.now();
+            await context.begin();
+            try {
+                const result = await fn(context);
+                console.log(`例程【${name}】执行完成，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                await context.commit();
+            }
+            catch (err) {
+                console.warn(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                await context.rollback();
+            }
+        }
+    }
+    async execRoutine(routine) {
+        const context = await this.contextBuilder()(this.dbStore);
+        await routine(context);
+    }
+}
+exports.AppLoader = AppLoader;

package/lib/DataSubscriber.d.ts

@@ -0,0 +1,18 @@
+import { EntityDict } from 'oak-domain/lib/types';
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { BackendRuntimeContext } from 'oak-frontend-base';
+import { Namespace } from 'socket.io';
+export default class DataSubscriber<ED extends EntityDict & BaseEntityDict, Context extends BackendRuntimeContext<ED>> {
+    private ns;
+    private contextBuilder;
+    private filterMap;
+    private idEntityMap;
+    constructor(ns: Namespace, contextBuilder: (scene?: string) => Promise<Context>);
+    private formCreateRoomRoutine;
+    /**
+     * 来自外部的socket连接，监听数据变化
+     */
+    private startup;
+    private sendRecord;
+    onDataCommited(context: Context): void;
+}

package/lib/DataSubscriber.js

@@ -0,0 +1,148 @@
+"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('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 {
+                        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) => {
+                    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('remove filter', room);
+                (0, lodash_1.unset)(this.filterMap[entity], room);
+                (0, lodash_1.unset)(this.idEntityMap, room);
+            }
+        });
+    }
+    sendRecord(entity, filter, record, sid, 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) {
+                    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,16 +1,18 @@
-import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
-import { EntityDict, StorageSchema, Trigger, Checker, AuthDeduceRelationMap, SelectOption, AuthCascadePath } 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 { AsyncContext, AsyncRowStore } from 'oak-domain/lib/store/AsyncRowStore';
-export declare class DbStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends MysqlStore<ED, Cxt> implements AsyncRowStore<ED, Cxt> {
-    private executor;
-    private relationAuth;
-    constructor(storageSchema: StorageSchema<ED>, contextBuilder: (scene?: string) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, mysqlConfiguration: MySQLConfiguration, actionCascadeGraph: AuthCascadePath<ED>[], relationCascadeGraph: AuthCascadePath<ED>[], authDeduceRelationMap: AuthDeduceRelationMap<ED>, selectFreeEntities?: (keyof ED)[], createFreeEntities?: (keyof ED)[], updateFreeEntities?: (keyof ED)[]);
-    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;
-}
+import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
+import { EntityDict, StorageSchema, Trigger, Checker, SelectOption, SelectFreeEntities, UpdateFreeDict, AuthDeduceRelationMap } 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) => (store: DbStore<ED, Cxt>) => Promise<Cxt>, mysqlConfiguration: MySQLConfiguration, authDeduceRelationMap: AuthDeduceRelationMap<ED>, selectFreeEntities?: SelectFreeEntities<ED>, updateFreeDict?: UpdateFreeDict<ED>);
+    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;
+    checkpoint(ts: number): Promise<number>;
+}

package/lib/DbStore.js

@@ -1,112 +1,116 @@
-"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, actionCascadeGraph, relationCascadeGraph, authDeduceRelationMap, selectFreeEntities = [], createFreeEntities = [], updateFreeEntities = []) {
-        super(storageSchema, mysqlConfiguration);
-        this.executor = new TriggerExecutor_1.TriggerExecutor((scene) => contextBuilder(scene)(this));
-        this.relationAuth = new RelationAuth_1.RelationAuth(storageSchema, actionCascadeGraph, relationCascadeGraph, authDeduceRelationMap, selectFreeEntities, createFreeEntities, updateFreeEntities);
-    }
-    async cascadeUpdateAsync(entity, operation, context, option) {
-        // 如果是在modi处理过程中，所有的trigger也可以延时到apply时再处理（这时候因为modi中的数据并不实际存在，处理会有问题）
-        if (!option.blockTrigger && !option.modiParentEntity) {
-            await this.executor.preOperation(entity, operation, context, option);
-        }
-        const result = await super.cascadeUpdateAsync(entity, operation, context, option);
-        if (!option.blockTrigger && !option.modiParentEntity) {
-            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 {
-            // 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);
-    }
-}
-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 = {}) {
+        super(storageSchema, mysqlConfiguration);
+        this.executor = new TriggerExecutor_1.TriggerExecutor((scene) => contextBuilder(scene)(this));
+        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);
+    }
+    checkpoint(ts) {
+        return this.executor.checkpoint(ts);
+    }
+}
+exports.DbStore = DbStore;

package/lib/index.d.ts

@@ -1 +1 @@
-export { AppLoader } from './AppLoader';
+export { AppLoader } from './AppLoader';

package/lib/index.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppLoader = void 0;
-var AppLoader_1 = require("./AppLoader");
-Object.defineProperty(exports, "AppLoader", { enumerable: true, get: function () { return AppLoader_1.AppLoader; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLoader = void 0;
+var AppLoader_1 = require("./AppLoader");
+Object.defineProperty(exports, "AppLoader", { enumerable: true, get: function () { return AppLoader_1.AppLoader; } });

package/lib/polyfill.d.ts

@@ -1,3 +1,3 @@
-export declare type GenerateIdOption = {
-    shuffle?: boolean;
-};
+export type GenerateIdOption = {
+    shuffle?: boolean;
+};

package/lib/polyfill.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const uuid_1 = require("uuid");
-async function generateNewId(option) {
-    if (option?.shuffle && process.env.NODE_ENV === 'development') {
-        return (0, uuid_1.v4)();
-    }
-    return (0, uuid_1.v1)();
-}
-Object.assign(global, {
-    generateNewId,
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+async function generateNewId(option) {
+    if (option?.shuffle && process.env.NODE_ENV === 'development') {
+        return (0, uuid_1.v4)();
+    }
+    return (0, uuid_1.v1)();
+}
+Object.assign(global, {
+    generateNewId,
+});

package/package.json

@@ -1,37 +1,41 @@
-{
-  "name": "oak-backend-base",
-  "version": "3.0.0",
-  "description": "oak-backend-base",
-  "main": "lib/index",
-  "author": {
-    "name": "XuChang"
-  },
-  "files": [
-    "lib/**/*"
-  ],
-  "scripts": {
-    "copy-files": "copyfiles -u 1 src/**/*.json lib/",
-    "test": "ts-node test/test.ts",
-    "build": "tsc && npm run copy-files"
-  },
-  "dependencies": {
-    "@types/node-schedule": "^2.1.0",
-    "lodash": "^4.17.21",
-    "mysql": "^2.18.1",
-    "mysql2": "^2.3.3",
-    "node-schedule": "^2.1.0",
-    "oak-common-aspect": "^2.2.1",
-    "oak-db": "^3.0.0",
-    "oak-domain": "^3.0.0",
-    "uuid": "^8.3.2"
-  },
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^17.0.40",
-    "@types/uuid": "^8.3.4",
-    "copyfiles": "^2.4.1",
-    "ts-node": "~10.9.1",
-    "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
-  }
-}
+{
+    "name": "oak-backend-base",
+    "version": "3.1.0",
+    "description": "oak-backend-base",
+    "main": "lib/index",
+    "author": {
+        "name": "XuChang"
+    },
+    "files": [
+        "lib/**/*"
+    ],
+    "scripts": {
+        "copy-files": "copyfiles -u 1 src/**/*.json lib/",
+        "test": "ts-node test/test.ts",
+        "test2": "ts-node test/testDbStore.ts",
+        "build": "tsc && npm run copy-files"
+    },
+    "dependencies": {
+        "lodash": "^4.17.21",
+        "mysql": "^2.18.1",
+        "mysql2": "^2.3.3",
+        "node-schedule": "^2.1.0",
+        "oak-common-aspect": "^2,2,2",
+        "oak-frontend-base": "^3.0.5",
+        "oak-db": "^3.0.2",
+        "oak-domain": "^3.0.4",
+        "socket.io": "^4.7.2",
+        "uuid": "^8.3.2"
+    },
+    "license": "ISC",
+    "devDependencies": {
+        "@types/lodash": "^4.14.198",
+        "@types/node": "^20.6.0",
+        "@types/node-schedule": "^2.1.0",
+        "@types/uuid": "^8.3.4",
+        "copyfiles": "^2.4.1",
+        "ts-node": "^10.9.1",
+        "tslib": "^2.4.0",
+        "typescript": "^5.2.2"
+    }
+}