oak-domain 4.5.0 → 5.0.0

package/lib/store/filter.d.ts

@@ -4,6 +4,14 @@ import { AsyncContext } from './AsyncRowStore';
 import { SyncContext } from './SyncRowStore';
 export declare function translateCreateDataToFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, data: ED[T]['CreateSingle']['data'], allowUnrecoganized: boolean): ED[T]["Selection"]["filter"];
 export declare function combineFilters<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filters: Array<ED[T]['Selection']['filter']>, union?: true): ED[T]["Selection"]["filter"] | undefined;
+type DeducedFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = {
+    entity: T;
+    filter: ED[T]['Selection']['filter'];
+};
+type DeducedFilterCombination<ED extends EntityDict & BaseEntityDict> = {
+    $or?: (DeducedFilterCombination<ED> | DeducedFilter<ED, keyof ED>)[];
+    $and?: (DeducedFilterCombination<ED> | DeducedFilter<ED, keyof ED>)[];
+};
 /**
  * 在以下判断相容或相斥的过程中，相容/相斥的事实标准是：满足两个条件的查询集合是否被包容/互斥，但如果两个filter在逻辑上相容或者相斥，在事实上不一定相容或者相斥
  * 例如：{ a: 1 } 和 { a: { $ne: 1 } } 是明显不相容的查询，但如果数据为空集，则这两个查询并不能否定其相容
@@ -35,6 +43,44 @@ export declare function combineFilters<ED extends EntityDict & BaseEntityDict, T
  * @attention: 1)这里的测试不够充分，有些算子之间的相容或相斥可能有遗漏, 2)有新的算子加入需要修改代码
  */
 export declare function judgeValueRelation(value1: any, value2: any, contained: boolean): boolean | undefined;
+/**
+ * 根据filter对compared查询的各个条件进行逐项分析
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param compared
+ * @param contained
+ * @returns
+ * sureAttributes中包含被判定肯定相容或肯定不相斥的属性（不用再继续判定了）
+ * uncertainAttributes中包含的是无法判定结果的属性
+ * totalAndDeducedFilters包含的是判定过程中推论的相容的充分条件（and关系）
+ * totalOrDeducedFilters包含的是判定过程中推论的相斥的充分条件（or关系）
+ */
+export declare function analyzeFilterRelation<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: NonNullable<ED[T]['Selection']['filter']>, compared: NonNullable<ED[T]['Selection']['filter']>, contained: boolean): boolean | {
+    totalAndDeducedFilters: (DeducedFilterCombination<ED> | DeducedFilter<ED, T>)[];
+    totalOrDeducedFilters: (DeducedFilterCombination<ED> | DeducedFilter<ED, T>)[];
+    uncertainAttributes: string[];
+    sureAttributes: string[];
+};
+/**
+ *
+ * 判断filter是否包含contained中的查询条件，即filter查询的结果一定是contained查询结果的子集
+ * filter = {
+ *      a: 1
+ *      b: 2,
+ *      c: 3,
+ * },
+ * conditionalFilter = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param contained
+ * @returns
+ */
+export declare function contains<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Selection']['filter'], contained: ED[T]['Selection']['filter']): boolean | DeducedFilterCombination<ED>;
 /**
  * 从filter中判断是否有确定的id对象，如果有则返回这些id，没有返回空数组
  * @param filter
@@ -84,3 +130,4 @@ export declare function checkFilterRepel<ED extends EntityDict & BaseEntityDict,
  * @param filter
  */
 export declare function translateFilterToObjectPredicate(filter: Record<string, any>): {};
+export {};

package/lib/store/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateFilterToObjectPredicate = exports.checkFilterRepel = exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.judgeValueRelation = exports.combineFilters = exports.translateCreateDataToFilter = void 0;
+exports.translateFilterToObjectPredicate = exports.checkFilterRepel = exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.contains = exports.analyzeFilterRelation = exports.judgeValueRelation = exports.combineFilters = exports.translateCreateDataToFilter = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const types_1 = require("../types");
@@ -43,9 +43,24 @@ function addFilterSegment(entity, schema, ...filters) {
         if (!filter[attr]) {
             filter[attr] = value;
         }
-        // 只优化一种情况，就是两个都等值且相等
+        // 优化两个都等值且相等
         else if (filter[attr] === value) {
         }
+        // value定义的查询被当前查询包含
+        else if (contains(entity, schema, {
+            [attr]: value,
+        }, {
+            [attr]: filter[attr],
+        }) === true) {
+            filter[attr] = value;
+        }
+        // 当前查询被value所定义的查询包含
+        else if (contains(entity, schema, {
+            [attr]: filter[attr],
+        }, {
+            [attr]: value
+        }) == true) {
+        }
         else {
             addIntoAnd({
                 [attr]: value,
@@ -1041,15 +1056,20 @@ function judgeFilterSingleAttrRelation(entity, schema, attr, filter, compared, c
     // 到这里说明无法直接判断此attr上的相容或者相斥，也无法把判定推断到更深层的算子之上
     return;
 }
-/** 判断filter条件对compared条件是否相容或相斥
+/**
+ * 根据filter对compared查询的各个条件进行逐项分析
  * @param entity
  * @param schema
  * @param filter
  * @param compared
- * @param contained: true代表判定filter包容compared(filter的查询结果是compared查询结果的子集), false代表判定filter与compared相斥（filter的查询结果与compared没有交集）
- * @returns 返回true说明肯定相容（相斥），返回false说明无法判定相容（相斥），返回DeducedFilterCombination说明需要进一步判断此推断的条件
+ * @param contained
+ * @returns
+ * sureAttributes中包含被判定肯定相容或肯定不相斥的属性（不用再继续判定了）
+ * uncertainAttributes中包含的是无法判定结果的属性
+ * totalAndDeducedFilters包含的是判定过程中推论的相容的充分条件（and关系）
+ * totalOrDeducedFilters包含的是判定过程中推论的相斥的充分条件（or关系）
  */
-function judgeFilterRelation(entity, schema, filter, compared, contained) {
+function analyzeFilterRelation(entity, schema, filter, compared, contained) {
     const totalAndDeducedFilters = [];
     const totalOrDeducedFilters = [];
     const uncertainAttributes = [];
@@ -1239,6 +1259,28 @@ function judgeFilterRelation(entity, schema, filter, compared, contained) {
             }
         }
     }
+    return {
+        totalAndDeducedFilters,
+        totalOrDeducedFilters,
+        uncertainAttributes,
+        sureAttributes,
+    };
+}
+exports.analyzeFilterRelation = analyzeFilterRelation;
+/** 判断filter条件对compared条件是否相容或相斥
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param compared
+ * @param contained: true代表判定filter包容compared(filter的查询结果是compared查询结果的子集), false代表判定filter与compared相斥（filter的查询结果与compared没有交集）
+ * @returns 返回true说明肯定相容（相斥），返回false说明无法判定相容（相斥），返回DeducedFilterCombination说明需要进一步判断此推断的条件
+ */
+function judgeFilterRelation(entity, schema, filter, compared, contained) {
+    const result = analyzeFilterRelation(entity, schema, filter, compared, contained);
+    if (typeof result === 'boolean') {
+        return result;
+    }
+    const { sureAttributes, uncertainAttributes, totalAndDeducedFilters, totalOrDeducedFilters, } = result;
     if (contained) {
         if (sureAttributes.length === Object.keys(compared).length) {
             return true;
@@ -1296,6 +1338,7 @@ function contains(entity, schema, filter, contained) {
     return judgeFilterRelation(entity, schema, filter, contained, true);
     // return false;
 }
+exports.contains = contains;
 /**
  * 判断filter1和filter2是否相斥，即filter1和filter2查询的结果一定没有交集
  * filter1 = {

package/lib/types/Action.d.ts

@@ -8,7 +8,7 @@ export type ActionDef<A extends Action, S extends State> = {
     };
     is?: S;
 };
-export type ActionDictOfEntityDict<E extends EntityDict> = {
+export type ActionDefDict<E extends EntityDict> = {
     [T in keyof E]?: {
         [A in keyof E[T]['OpSchema']]?: ActionDef<string, string>;
     };

package/lib/types/Configuration.d.ts

@@ -1,25 +1,33 @@
+import { AuthDeduceRelationMap, EntityDict } from './Entity';
+import { EntityDict as BaseEntityDict } from "../base-app-domain";
+import { AsyncContext } from '../store/AsyncRowStore';
+import { SyncConfig } from "./Sync";
+import { AttrUpdateMatrix } from './EntityDesc';
+import { ActionDefDict } from './Action';
+import { StyleDict } from './Style';
 /**
- *  后台环境配置
+ *  后台配置
  */
-export type ServerConfiguration = {
+export type ServerConfiguration<ED extends BaseEntityDict & EntityDict, Cxt extends AsyncContext<ED>> = {
     database: {
         type: 'mysql';
         host: string;
         database: string;
-        port: number;
+        port?: number;
         user: string;
         password?: string;
         connectionLimit: number;
         charset: "utf8mb4_general_ci";
     };
-    http: {
-        port: number;
+    workDir: {
+        path: string;
     };
+    sync?: SyncConfig<ED, Cxt>;
 };
 /**
- * 前后台共用的配置
+ * 前后台访问配置
  */
-export type ProjectConfiguration = {
+export type AccessConfiguration = {
     routerPrefixes?: {
         aspect?: string;
         endpoint?: string;
@@ -27,6 +35,33 @@ export type ProjectConfiguration = {
         getSubscribePoint?: string;
         bridge?: string;
     };
+    http: {
+        hostname: string;
+        port?: number;
+        ssl?: boolean;
+        path?: string;
+    };
+};
+/**
+ * 业务逻辑的通用配置
+ */
+export type CommonConfiguration<ED extends BaseEntityDict & EntityDict> = {
+    attrUpdateMatrix: AttrUpdateMatrix<ED>;
+    actionDefDict: ActionDefDict<ED>;
+    authDeduceRelationMap: AuthDeduceRelationMap<ED>;
+    selectFreeEntities?: (keyof ED)[];
+    updateFreeDict?: {
+        [A in keyof ED]?: string[];
+    };
+    cacheSavedEntities?: (keyof ED)[];
+    cacheKeepFreshPeriod?: number;
+};
+export type DependencyConfiguration = string[];
+/**
+ * 渲染相关定义
+ */
+export type RenderConfiguration<ED extends BaseEntityDict & EntityDict> = {
+    styleDict: StyleDict<ED>;
 };
 /**
  * 编译环境配置

package/lib/types/Configuration.js

@@ -1,3 +1,2 @@
 "use strict";
-// 将项目的所有配置规范化到一起（未完成）by Xc 20240207
 Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Connector.d.ts

@@ -36,4 +36,7 @@ export interface Connector<ED extends EntityDict, FrontCxt extends SyncContext<E
         url: string;
         headers?: Record<string, string>;
     };
+    getFullData: (keys?: (keyof ED)[]) => Promise<{
+        [T in keyof ED]?: ED[T]['OpSchema'][];
+    }>;
 }

package/lib/types/EntityDesc.d.ts

@@ -1,12 +1,19 @@
 import { LocaleDef } from './Locale';
 import { Index } from './Storage';
 import { EntityShape, Configuration, EntityDict } from './Entity';
-export type EntityDesc<Schema extends EntityShape, Action extends string = '', Relation extends string = '', V extends Record<string, string> = {}> = {
-    locales: LocaleDef<Schema, Action, Relation, V>;
+import { StyleDesc } from './Style';
+export type EntityDesc<Schema extends EntityShape, Action extends string = '', Relation extends string = '', V extends Record<string, string> = {
+    ['##oak_illegal##']: '';
+}> = {
+    locales: LocaleDef<Schema, Action, Relation, keyof V extends '##oak_illegal##' ? {} : V>;
     indexes?: Index<Schema>[];
     configuration?: Configuration;
     recursiveDepth?: number;
-};
+} & (Action extends '' ? (keyof V extends '##oak_illegal##' ? {} : {
+    style: StyleDesc<Action, V>;
+}) : {
+    style: StyleDesc<Action, V>;
+});
 export type AttrUpdateMatrix<ED extends EntityDict> = {
     [T in keyof ED]?: {
         [A in keyof ED[T]['Update']['data']]?: {

package/lib/types/Style.d.ts

@@ -1,11 +1,40 @@
-import { EntityDict } from './Entity';
+import { EntityDict, GeneralEntityShape } from './Entity';
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
-type ThemeColor = 'default' | 'success' | 'warning' | 'error' | 'primary' | 'danger';
-export type ColorDict<ED extends BaseEntityDict & EntityDict> = {
-    [T in keyof ED]?: {
-        [A in keyof ED[T]['OpSchema']]?: {
-            [E in ED[T]['OpSchema'][A]]?: ThemeColor | `#${string}`;
+type Color = `#${string}`;
+type IconName = string;
+export type StyleDesc<Action extends string = '', V extends Record<string, string> = {
+    ['##oak_illegal##']: '';
+}> = Action extends '' ? (keyof V extends '##oak_illegal##' ? {} : {
+    color: {
+        [A in keyof V]: {
+            [E in V[A]]: Color;
         };
     };
+}) : (keyof V extends '##oak_illegal##' ? {
+    icon: {
+        [A in Action]?: IconName;
+    };
+} : {
+    icon: {
+        [A in Action]?: IconName;
+    };
+    color: {
+        [A in keyof V]: {
+            [E in V[A]]: Color;
+        };
+    };
+});
+export type StyleDef<ED extends GeneralEntityShape, Action extends string> = {
+    color?: {
+        [A in keyof ED]?: {
+            [E in ED[A]]?: Color;
+        };
+    };
+    icon?: {
+        [A in Action]?: IconName;
+    };
+};
+export type StyleDict<ED extends BaseEntityDict & EntityDict> = {
+    [T in keyof ED]?: StyleDef<ED[T]['OpSchema'], ED[T]['Action']>;
 };
 export {};

package/lib/utils/SimpleConnector.d.ts

@@ -2,24 +2,20 @@
 import { IncomingHttpHeaders } from "http";
 import { SyncContext } from '../store/SyncRowStore';
 import { Connector, EntityDict, OakException, OpRecord } from "../types";
-type ServerOption = {
-    protocol: string;
-    hostname: string;
-    port?: number;
-    apiPath?: string;
-};
-export declare class SimpleConnector<ED extends EntityDict, FrontCxt extends SyncContext<ED>> implements Connector<ED, FrontCxt> {
+import { AccessConfiguration } from '../types/Configuration';
+export default class SimpleConnector<ED extends EntityDict, FrontCxt extends SyncContext<ED>> implements Connector<ED, FrontCxt> {
     static ASPECT_ROUTER: string;
     static BRIDGE_ROUTER: string;
     static SUBSCRIBE_ROUTER: string;
     static SUBSCRIBE_POINT_ROUTER: string;
     static ENDPOINT_ROUTER: string;
+    private serverUrl;
     private serverAspectUrl;
     private serverBridgeUrl;
     private serverSubscribePointUrl;
-    private option;
+    private configuration;
     private makeException;
-    constructor(option: ServerOption, makeException: (exceptionData: any) => OakException<ED>);
+    constructor(configuration: AccessConfiguration, makeException: (exceptionData: any) => OakException<ED>);
     protected makeHeadersAndBody(name: string, data: any, context?: FrontCxt): Promise<{
         headers: Record<string, string>;
         body: FormData;
@@ -77,5 +73,5 @@ export declare class SimpleConnector<ED extends EntityDict, FrontCxt extends Syn
         url: string;
         headers?: Record<string, string> | undefined;
     };
+    getFullData(): Promise<{}>;
 }
-export {};

package/lib/utils/SimpleConnector.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleConnector = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const stream_1 = require("stream");
@@ -12,25 +11,34 @@ class SimpleConnector {
     static SUBSCRIBE_ROUTER = process.env.OAK_SUBSCRIBE_ROUTER || '/subscribe';
     static SUBSCRIBE_POINT_ROUTER = '/subscribePoint';
     static ENDPOINT_ROUTER = '/endpoint';
+    serverUrl;
     serverAspectUrl;
     serverBridgeUrl;
     serverSubscribePointUrl;
-    option;
+    configuration;
     makeException;
-    constructor(option, makeException) {
-        this.option = option;
-        const { protocol, hostname, port, apiPath } = option;
+    constructor(configuration, makeException) {
+        this.configuration = configuration;
+        const { routerPrefixes, http } = configuration;
+        const { ssl, hostname, port, path } = http;
+        const protocol = ssl ? 'https:' : 'http:';
         let serverUrl = `${protocol}//${hostname}`;
+        this.serverUrl = serverUrl;
         if (typeof port === 'number') {
             serverUrl += `:${port}`;
         }
-        if (apiPath) {
-            (0, assert_1.default)(apiPath.startsWith('/'), 'apiPath前缀必须存在/');
-            serverUrl += apiPath;
+        if (path) {
+            if (path.startsWith('/')) {
+                serverUrl += path;
+            }
+            else {
+                serverUrl += `/${path}`;
+            }
         }
-        this.serverAspectUrl = `${serverUrl}${SimpleConnector.ASPECT_ROUTER}`;
-        this.serverBridgeUrl = `${serverUrl}${SimpleConnector.BRIDGE_ROUTER}`;
-        this.serverSubscribePointUrl = `${serverUrl}${SimpleConnector.SUBSCRIBE_POINT_ROUTER}`;
+        this.serverAspectUrl = `${serverUrl}${routerPrefixes?.aspect || SimpleConnector.ASPECT_ROUTER}`;
+        this.serverBridgeUrl = `${serverUrl}${routerPrefixes?.bridge || SimpleConnector.BRIDGE_ROUTER}`;
+        this.serverSubscribePointUrl = `${serverUrl}${routerPrefixes?.getSubscribePoint ||
+            SimpleConnector.SUBSCRIBE_POINT_ROUTER}`;
         this.makeException = makeException;
     }
     async makeHeadersAndBody(name, data, context) {
@@ -100,18 +108,18 @@ class SimpleConnector {
         }
         catch (err) {
             // fetch返回异常一定是网络异常
-            throw new types_1.OakNetworkException(`请求[${this.serverAspectUrl}]，发生网络异常`);
+            throw new types_1.OakNetworkException(`接口请求时发生网络异常`);
         }
         return this.parseAspectResult(response);
     }
     getRouter() {
-        return SimpleConnector.ASPECT_ROUTER;
+        return this.configuration.routerPrefixes?.aspect || SimpleConnector.ASPECT_ROUTER;
     }
     getSubscribeRouter() {
-        return SimpleConnector.SUBSCRIBE_ROUTER;
+        return this.configuration.routerPrefixes?.subscribe || SimpleConnector.SUBSCRIBE_ROUTER;
     }
     getSubscribePointRouter() {
-        return SimpleConnector.SUBSCRIBE_POINT_ROUTER;
+        return this.configuration.routerPrefixes?.getSubscribePoint || SimpleConnector.SUBSCRIBE_POINT_ROUTER;
     }
     async getSubscribePoint() {
         let response;
@@ -130,9 +138,10 @@ class SimpleConnector {
             response.headers.get('content-type');
         if (responseType?.toLocaleLowerCase().match(/application\/json/i)) {
             const { url, path, port, namespace } = await response.json();
-            let url2 = url || `${this.option.protocol}//${this.option.hostname}`;
-            (0, assert_1.default)(port);
-            url2 += `:${port}`;
+            let url2 = url || this.serverUrl;
+            if (port) {
+                url2 += `:${port}`;
+            }
             if (namespace) {
                 url2 += namespace;
             }
@@ -146,7 +155,7 @@ class SimpleConnector {
         }
     }
     getEndpointRouter() {
-        return SimpleConnector.ENDPOINT_ROUTER;
+        return this.configuration.routerPrefixes?.endpoint || SimpleConnector.ENDPOINT_ROUTER;
     }
     parseRequest(headers, body, files) {
         const { 'oak-cxt': oakCxtStr, 'oak-aspect': aspectName } = headers;
@@ -213,5 +222,9 @@ class SimpleConnector {
             headers: headers && JSON.parse(headers),
         };
     }
+    async getFullData() {
+        console.error('前后台模式下暂时不支持此操作，请到数据库查看数据');
+        return {};
+    }
 }
-exports.SimpleConnector = SimpleConnector;
+exports.default = SimpleConnector;

package/lib/utils/assert.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /**
  * 防止assert打包体积过大，从这里引用
  */

package/lib/utils/lodash.d.ts

@@ -12,6 +12,7 @@ import intersection from 'lodash/intersection';
 import intersectionBy from 'lodash/intersectionBy';
 import omit from 'lodash/omit';
 import merge from 'lodash/merge';
+import mergeWith from 'lodash/mergeWith';
 import cloneDeep from 'lodash/cloneDeep';
 import pick from 'lodash/pick';
 import isEqual from 'lodash/isEqual';
@@ -21,4 +22,12 @@ import differenceBy from 'lodash/differenceBy';
 import groupBy from 'lodash/groupBy';
 import unionBy from 'lodash/unionBy';
 import pullAll from 'lodash/pullAll';
-export { unset, pull, uniq, uniqBy, get, set, intersection, intersectionBy, omit, merge, cloneDeep, pick, isEqual, union, difference, differenceBy, groupBy, unionBy, pullAll, };
+/**
+ * merge两个对象，遇到array时使用连接合并
+ * @param object
+ * @param source
+ * @returns
+ */
+declare function mergeConcatArray(object: any, source: any): any;
+declare function mergeConcatMany<T>(array: Array<T>): T;
+export { unset, pull, uniq, uniqBy, get, set, intersection, intersectionBy, omit, merge, mergeWith, mergeConcatArray, mergeConcatMany, cloneDeep, pick, isEqual, union, difference, differenceBy, groupBy, unionBy, pullAll, };

package/lib/utils/lodash.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pullAll = exports.unionBy = exports.groupBy = exports.differenceBy = exports.difference = exports.union = exports.isEqual = exports.pick = exports.cloneDeep = exports.merge = exports.omit = exports.intersectionBy = exports.intersection = exports.set = exports.get = exports.uniqBy = exports.uniq = exports.pull = exports.unset = void 0;
+exports.pullAll = exports.unionBy = exports.groupBy = exports.differenceBy = exports.difference = exports.union = exports.isEqual = exports.pick = exports.cloneDeep = exports.mergeConcatMany = exports.mergeConcatArray = exports.mergeWith = exports.merge = exports.omit = exports.intersectionBy = exports.intersection = exports.set = exports.get = exports.uniqBy = exports.uniq = exports.pull = exports.unset = void 0;
 const tslib_1 = require("tslib");
 /**
  * 避免lodash打包体积过大
@@ -26,6 +26,8 @@ const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
 exports.omit = omit_1.default;
 const merge_1 = tslib_1.__importDefault(require("lodash/merge"));
 exports.merge = merge_1.default;
+const mergeWith_1 = tslib_1.__importDefault(require("lodash/mergeWith"));
+exports.mergeWith = mergeWith_1.default;
 const cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
 exports.cloneDeep = cloneDeep_1.default;
 const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
@@ -44,3 +46,27 @@ const unionBy_1 = tslib_1.__importDefault(require("lodash/unionBy"));
 exports.unionBy = unionBy_1.default;
 const pullAll_1 = tslib_1.__importDefault(require("lodash/pullAll"));
 exports.pullAll = pullAll_1.default;
+const assert_1 = tslib_1.__importDefault(require("assert"));
+/**
+ * merge两个对象，遇到array时使用连接合并
+ * @param object
+ * @param source
+ * @returns
+ */
+function mergeConcatArray(object, source) {
+    if (object instanceof Array) {
+        (0, assert_1.default)(source instanceof Array, '合并的对象必须结构一致');
+        return (0, uniq_1.default)(object.concat(source));
+    }
+    return (0, mergeWith_1.default)(object, source, (objValue, srcValue) => {
+        if (objValue instanceof Array) {
+            (0, assert_1.default)(srcValue instanceof Array, '合并的对象必须结构一致');
+            return (0, uniq_1.default)(objValue.concat(srcValue));
+        }
+    });
+}
+exports.mergeConcatArray = mergeConcatArray;
+function mergeConcatMany(array) {
+    return array.reduce((prev, current) => mergeConcatArray(prev, current));
+}
+exports.mergeConcatMany = mergeConcatMany;

package/lib/utils/module/combine.common.d.ts

@@ -0,0 +1,15 @@
+import { AsyncContext } from "../../store/AsyncRowStore";
+import { SyncContext } from "../../store/SyncRowStore";
+import { EntityDict } from "../../types/Entity";
+import { EntityDict as BaseEntityDict } from '../../base-app-domain';
+import { Checker } from '../../types/Auth';
+import { CommonConfiguration } from '../../types/Configuration';
+/**
+ * 合并引入模块中的checker和common
+ * @param modules
+ * @returns
+ */
+export default function combineBaseModules<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(...modules: string[]): {
+    checkers: Array<Checker<ED, keyof ED, Cxt>>;
+    common: CommonConfiguration<ED>;
+};

package/lib/utils/module/combine.common.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lodash_1 = require("../../utils/lodash");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+/**
+ * 合并引入模块中的checker和common
+ * @param modules
+ * @returns
+ */
+function combineBaseModules(...modules) {
+    // 合并模块中的checker/common
+    return modules.map((module) => {
+        const checkers = require(`${module}/lib/checkers`).default;
+        const common = require(`${module}/lib/configuration`).default;
+        (0, assert_1.default)(checkers instanceof Array, `${module}模块中的checkers不是数组`);
+        (0, assert_1.default)(typeof common === 'object', `${module}模块中的common配置不是对象`);
+        return {
+            checkers,
+            common,
+        };
+    }).reduce((prev, current) => ({
+        checkers: (0, lodash_1.mergeConcatArray)(prev.checkers, current.checkers),
+        common: (0, lodash_1.mergeConcatArray)(prev.common, current.common),
+    }));
+}
+exports.default = combineBaseModules;

package/lib/utils/module/combine.d.ts

@@ -0,0 +1 @@
+export * from './combine.dev';

package/lib/utils/module/combine.dev.d.ts

@@ -0,0 +1,17 @@
+import { AsyncContext } from "../../store/AsyncRowStore";
+import { SyncContext } from "../../store/SyncRowStore";
+import { EntityDict } from "../../types/Entity";
+import { EntityDict as BaseEntityDict } from '../../base-app-domain';
+import { Aspect, Exportation, Importation, Routine, Timer, Trigger, Watcher } from '../../types';
+export default function combineModuleDev<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>>(...modules: string[]): {
+    aspectDict: Record<string, Aspect<ED, Cxt>>;
+    data: { [T in keyof ED]?: ED[T]["OpSchema"][] | undefined; };
+    importations: Importation<ED, keyof ED, string, Cxt>;
+    exportations: Exportation<ED, keyof ED, string, Cxt>;
+    watchers: Watcher<ED, keyof ED, Cxt>[];
+    timers: Timer<ED, keyof ED, Cxt>[];
+    startRoutines: Routine<ED, keyof ED, Cxt>[];
+    triggers: Trigger<ED, keyof ED, Cxt>[];
+    checkers: import("../../types").Checker<ED, keyof ED, never>[];
+    common: import("../../types/Configuration").CommonConfiguration<ED>;
+};