oak-domain 4.4.0 → 5.0.0

package/lib/store/TriggerExecutor.js

@@ -39,15 +39,21 @@ class TriggerExecutor {
         this.volatileEntities = [];
         this.counter = 0;
         this.onVolatileTrigger = onVolatileTrigger || (async (entity, trigger, ids, cxtStr, option) => {
-            const context = await this.contextBuilder(cxtStr);
-            await context.begin();
+            const context = this.contextBuilder();
+            if (!context.getCurrentTxnId()) {
+                await context.begin();
+            }
+            await context.initialize(JSON.parse(cxtStr));
             try {
                 await this.execVolatileTrigger(entity, trigger.name, ids, context, option);
                 await context.commit();
             }
             catch (err) {
                 await context.rollback();
-                this.logger.error('error on volatile trigger', entity, trigger.name, ids.join(','), err);
+                if (!(err instanceof types_1.OakMakeSureByMySelfException)) {
+                    this.logger.error('error on volatile trigger', entity, trigger.name, ids.join(','), err);
+                }
+                // throw err;
             }
         });
     }
@@ -271,8 +277,8 @@ class TriggerExecutor {
                         }
                     }
                     const number = trigger.fn({ operation: operation }, context, option);
-                    if (number > 0) {
-                        this.logger.info(`触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
+                    if (number > 0 && process.env.NODE_ENV === 'development') {
+                        this.logger.info(`前触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                     }
                 }
                 (0, assert_1.default)(commitTriggers.length === 0, `前台不应有commitTrigger`);
@@ -294,8 +300,8 @@ class TriggerExecutor {
                         }
                     }
                     const number = await trigger.fn({ operation: operation }, context, option);
-                    if (number > 0) {
-                        this.logger.info(`触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
+                    if (number > 0 && process.env.NODE_ENV === 'development') {
+                        this.logger.info(`前触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                     }
                     return execPreTrigger(idx + 1);
                 };
@@ -382,8 +388,8 @@ class TriggerExecutor {
                         operation: operation,
                         result: result,
                     }, context, option);
-                    if (number > 0) {
-                        this.logger.info(`触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
+                    if (number > 0 && process.env.NODE_ENV === 'development') {
+                        this.logger.info(`后触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                     }
                 }
             }
@@ -398,8 +404,8 @@ class TriggerExecutor {
                         operation: operation,
                         result: result,
                     }, context, option);
-                    if (number > 0) {
-                        this.logger.info(`触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
+                    if (number > 0 && process.env.NODE_ENV === 'development') {
+                        this.logger.info(`后触发器「${trigger.name}」成功触发了「${number}」行数据更改`);
                     }
                     return execPostTrigger(idx + 1);
                 };
@@ -441,7 +447,7 @@ class TriggerExecutor {
                     $lt: timestamp,
                 }
             };
-            const context = await this.contextBuilder();
+            const context = this.contextBuilder();
             if (context.clusterInfo?.usingCluster) {
                 const { instanceCount, instanceId } = context.clusterInfo;
                 filter.$$seq$$ = {

package/lib/store/checker.js

@@ -46,7 +46,7 @@ function translateCheckerInAsyncContext(checker, schema) {
         case 'row': {
             const { filter, errMsg, inconsistentRows } = checker;
             const fn = (async ({ operation }, context, option) => {
-                const { filter: operationFilter, data, action } = operation;
+                const { filter: operationFilter, data, action, bornAt } = operation;
                 const filter2 = typeof filter === 'function' ? await filter(operation, context, option) : filter;
                 if (['select', 'count', 'stat'].includes(action)) {
                     operation.filter = (0, filter_1.combineFilters)(entity, context.getSchema(), [operationFilter, filter2]);
@@ -88,11 +88,11 @@ function translateCheckerInAsyncContext(checker, schema) {
                         (0, assert_1.default)(data);
                         if (data instanceof Array) {
                             for (const d of data) {
-                                await checkSingle((0, filter_1.translateCreateDataToFilter)(schema, entity, d));
+                                await checkSingle((0, filter_1.translateCreateDataToFilter)(schema, entity, d, !!bornAt));
                             }
                         }
                         else {
-                            await checkSingle((0, filter_1.translateCreateDataToFilter)(schema, entity, data));
+                            await checkSingle((0, filter_1.translateCreateDataToFilter)(schema, entity, data, !!bornAt));
                         }
                         return;
                     }
@@ -139,7 +139,7 @@ function translateCheckerInSyncContext(checker, schema) {
         case 'row': {
             const { filter, errMsg, entity } = checker;
             const fn = (operation, context, option) => {
-                const { filter: operationFilter, data, action } = operation;
+                const { filter: operationFilter, data, action, bornAt } = operation;
                 const filter2 = typeof filter === 'function' ? filter(operation, context, option) : filter;
                 let operationFilter2 = operationFilter;
                 if (action === 'create') {
@@ -147,7 +147,7 @@ function translateCheckerInSyncContext(checker, schema) {
                         // 前端的策略是，有data用data，无data用filter
                         // 目前前端应该不可能制造出来createMultiple
                         (0, assert_1.default)(!(data instanceof Array));
-                        operationFilter2 = (0, filter_1.translateCreateDataToFilter)(schema, entity, data);
+                        operationFilter2 = (0, filter_1.translateCreateDataToFilter)(schema, entity, data, !!bornAt);
                     }
                 }
                 (0, assert_1.default)(!(filter2 instanceof Promise));

package/lib/store/filter.d.ts

@@ -2,8 +2,16 @@ import { EntityDict as BaseEntityDict, StorageSchema } from '../types';
 import { EntityDict } from "../base-app-domain";
 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']): ED[T]["Selection"]["filter"];
+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,15 +1,15 @@
 "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");
 const lodash_1 = require("../utils/lodash");
 const relation_1 = require("./relation");
-function translateCreateDataToFilter(schema, entity, data) {
+function translateCreateDataToFilter(schema, entity, data, allowUnrecoganized) {
     const data2 = {};
     for (const attr in data) {
-        const rel = (0, relation_1.judgeRelation)(schema, entity, attr);
+        const rel = (0, relation_1.judgeRelation)(schema, entity, attr, allowUnrecoganized);
         if (rel === 1) {
             // 只需要记住id和各种外键属性，不这样处理有些古怪的属性比如coordinate，其作为createdata和作为filter并不同构
             if (!['geometry', 'geography', 'st_geometry', 'st_point'].includes(schema[entity].attributes[attr]?.type)) {
@@ -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/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, };