oak-domain 5.1.12 → 5.1.14

package/lib/store/CascadeStore.d.ts

@@ -69,6 +69,7 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
     protected preProcessDataUpdated(action: string, data: Record<string, any>, async?: true): void;
     judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0 | -1;
+    private tryMergeModi;
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
      * @param entity

package/lib/store/CascadeStore.js

@@ -247,7 +247,8 @@ class CascadeStore extends RowStore_1.RowStore {
                 assignNecessaryProjectionAttrs(projectionNode, necessaryAttrs);
             }
             // 如果对象中指向一对多的Modi，此时加上指向Modi的projection
-            if (this.getSchema()[entity2].toModi) {
+            // 此逻辑关闭，用户自己撰写去取modi     by Xc 20241207
+            /* if (this.getSchema()[entity2].toModi) {
                 Object.assign(projectionNode, {
                     modi$entity: {
                         $entity: 'modi',
@@ -268,7 +269,7 @@ class CascadeStore extends RowStore_1.RowStore {
                         },
                     }
                 });
-            }
+            } */
             // 如果对象上有relation关系，在此将本用户相关的relation和actionAuth全部取出
             // 还要将actionAuth上没有relation关系但destEntity为本对象的行也全部取出，这些是指向userId的可能路径
             // 放在这里有点怪异，暂先这样
@@ -1050,6 +1051,118 @@ class CascadeStore extends RowStore_1.RowStore {
     judgeRelation(entity, attr) {
         return (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
     }
+    async tryMergeModi(entity, operation, context, ids, option) {
+        const { action, data, filter, id: operId } = operation;
+        const [upsertModi] = await this.selectAbjointRowAsync('modi', {
+            data: {
+                id: 1,
+                data: 1,
+                action: 1,
+            },
+            filter: {
+                targetEntity: entity,
+                iState: 'active',
+                filter: ids.length > 0 ? {
+                    id: {
+                        $in: ids,
+                    },
+                } : {
+                    id: ids[0],
+                },
+            },
+            sorter: [
+                {
+                    $attr: {
+                        $$createAt$$: 1,
+                    },
+                    $direction: 'desc',
+                }
+            ],
+            indexFrom: 0,
+            count: 1,
+        }, context, option);
+        if (upsertModi) {
+            const { data: data2, id: id2, action: action2 } = upsertModi;
+            if (action === 'remove') {
+                // 之前的都不做数
+                if (action2 === 'create') {
+                    // 对冲掉
+                    return {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'remove',
+                        data: {},
+                        filter: {
+                            id: upsertModi.id,
+                        },
+                    };
+                }
+                else {
+                    // 直接把这个改成删除
+                    (0, assert_1.default)(action2 !== 'remove');
+                    return {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'update',
+                        data: {
+                            action,
+                            data,
+                        },
+                        filter: {
+                            id: upsertModi.id,
+                        },
+                    };
+                }
+            }
+            else {
+                // 是update，直接把原来的data覆盖掉
+                if (action !== action2 && process.env.NODE_ENV === 'development') {
+                    // 这种情况感觉是不会发生的
+                    console.warn('发生了同一行数据的modi的action不一致，请注意查看');
+                }
+                return {
+                    id: 'dummy',
+                    action: 'update',
+                    data: {
+                        data: Object.assign({}, data2, data),
+                    },
+                    filter: {
+                        id: id2,
+                    }
+                };
+            }
+        }
+        // 说明没有已有的modi，必须要创建新的，此时应当在option中有相应的parentEntity/Id
+        const { modiParentEntity, modiParentId } = option;
+        (0, assert_1.default)(modiParentEntity && modiParentId);
+        return {
+            id: 'dummy',
+            action: 'create',
+            data: {
+                id: operId,
+                targetEntity: entity,
+                entity: modiParentEntity,
+                entityId: modiParentId,
+                action,
+                data,
+                iState: 'active',
+                filter: ids.length > 0 ? {
+                    id: {
+                        $in: ids,
+                    },
+                } : {
+                    id: ids[0],
+                },
+                modiEntity$modi: {
+                    id: 'dummy',
+                    action: 'create',
+                    data: await Promise.all(ids.map(async (id) => ({
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        entity: entity,
+                        entityId: id,
+                    }))),
+                }
+            },
+        };
+    }
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
      * @param entity
@@ -1281,100 +1394,60 @@ class CascadeStore extends RowStore_1.RowStore {
                 if (data) {
                     this.preProcessDataUpdated(action, data, true);
                 }
-                if (option.modiParentEntity && !['modi', 'modiEntity'].includes(entity)) {
-                    // 延时更新，变成对modi的插入
-                    // 变成对modi的插入
-                    // 优化，这里如果是对同一个targetEntity反复update，则变成对最后一条create/update的modi进行update，以避免发布文章这样的需求时产生过多的modi
-                    let modiUpsert;
-                    if (action === 'update') {
-                        // 如果action本身是update，且没有实际update属性，这里可以忽略
-                        const updateAttrCount = Object.keys(data).length;
-                        if (updateAttrCount === 0) {
-                            return {};
-                        }
-                        // 尝试和当前targetEntity的最后一条create/update进行合并，优化modi的条数
-                        const upsertModis = await this.selectAbjointRowAsync('modi', {
-                            data: {
-                                id: 1,
-                                data: 1,
-                                action: 1,
-                            },
-                            filter: {
-                                targetEntity: entity,
-                                entity: option.modiParentEntity,
-                                entityId: option.modiParentId,
-                                iState: 'active',
-                                filter: ids.length > 0 ? {
-                                    id: {
-                                        $in: ids,
-                                    },
-                                } : filter,
-                            },
-                            sorter: [
-                                {
-                                    $attr: {
-                                        $$createAt$$: 1,
-                                    },
-                                    $direction: 'desc',
-                                }
-                            ],
-                            indexFrom: 0,
-                            count: 1,
-                        }, context, option);
-                        if (upsertModis.length > 0) {
-                            const { data: originData, id: originId, action } = upsertModis[0];
-                            if (['create', 'update'].includes(action)) {
-                                modiUpsert = {
-                                    id: 'dummy',
-                                    action: 'update',
-                                    data: {
-                                        data: Object.assign({}, originData, data),
-                                    },
-                                    filter: {
-                                        id: originId,
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if (!modiUpsert) {
-                        modiUpsert = {
-                            id: 'dummy',
-                            action: 'create',
-                            data: {
-                                id: operId,
-                                targetEntity: entity,
-                                entity: option.modiParentEntity,
-                                entityId: option.modiParentId,
-                                action,
-                                data,
-                                iState: 'active',
-                                filter,
-                            },
-                        };
-                        if (ids.length > 0) {
-                            modiUpsert.data.modiEntity$modi = {
-                                id: 'dummy',
-                                action: 'create',
-                                data: await Promise.all(ids.map(async (id) => ({
-                                    id: await (0, uuid_1.generateNewIdAsync)(),
-                                    entity: entity,
-                                    entityId: id,
-                                }))),
-                            };
-                        }
-                    }
+                const createModi = async () => {
+                    const modiOperation = await this.tryMergeModi(entity, operation, context, ids, option);
                     const closeRootMode = context.openRootMode();
-                    await this.cascadeUpdateAsync('modi', modiUpsert, context, option);
+                    await this.cascadeUpdateAsync('modi', modiOperation, context, option);
                     closeRootMode();
                     return {
                         modi: {
                             ['create']: 1,
                         },
                     };
+                };
+                if (option.modiParentEntity && !['modi', 'modiEntity'].includes(entity)) {
+                    // 延时更新，变成对modi的操作
+                    if (action === 'update' && Object.keys(data).length === 0) {
+                        return {};
+                    }
+                    return createModi();
                 }
                 else {
-                    const createOper = async () => {
+                    const saveRecordAndCreateOper = async () => {
+                        if (action === 'remove') {
+                            if (!option.dontCollect) {
+                                context.saveOpRecord(entity, {
+                                    id: operId,
+                                    action,
+                                    data: data,
+                                    filter: {
+                                        id: {
+                                            $in: ids,
+                                        }
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            const updateAttrCount = Object.keys(data).length;
+                            if (updateAttrCount > 0) {
+                                if (!option.dontCollect) {
+                                    context.saveOpRecord(entity, {
+                                        id: operId,
+                                        action,
+                                        data: data,
+                                        filter: {
+                                            id: {
+                                                $in: ids,
+                                            }
+                                        },
+                                    });
+                                }
+                            }
+                            else {
+                                return {};
+                            }
+                        }
                         if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi', 'log'].includes(entity) && ids.length > 0) {
                             // 按照框架要求生成Oper和OperEntity这两个内置的对象
                             (0, assert_1.default)(operId);
@@ -1411,48 +1484,21 @@ class CascadeStore extends RowStore_1.RowStore {
                             });
                             closeRootMode();
                         }
+                        return {
+                            [entity]: {
+                                [action]: ids.length,
+                            }
+                        };
                     };
-                    if (action === 'remove') {
-                        if (!option.dontCollect) {
-                            context.saveOpRecord(entity, {
-                                id: operId,
-                                action,
-                                data: data,
-                                filter: {
-                                    id: {
-                                        $in: ids,
-                                    }
-                                },
-                            });
-                        }
+                    const count = await this.updateAbjointRowAsync(entity, operation, context, option);
+                    if (count === ids.length) {
+                        return await saveRecordAndCreateOper();
                     }
                     else {
-                        const updateAttrCount = Object.keys(data).length;
-                        if (updateAttrCount > 0) {
-                            if (!option.dontCollect) {
-                                context.saveOpRecord(entity, {
-                                    id: operId,
-                                    action,
-                                    data: data,
-                                    filter: {
-                                        id: {
-                                            $in: ids,
-                                        }
-                                    },
-                                });
-                            }
-                        }
-                        else {
-                            return {};
-                        }
+                        // 如果没有更新到行，说明这些数据还在modi当中
+                        (0, assert_1.default)(count === 0, 'update成功的行数只能为id所在行数或者0');
+                        return await createModi();
                     }
-                    await this.updateAbjointRowAsync(entity, operation, context, option);
-                    await createOper();
-                    return {
-                        [entity]: {
-                            [action]: ids.length,
-                        }
-                    };
                 }
             }
         }

package/lib/store/RelationAuth.js

@@ -352,12 +352,47 @@ class RelationAuth {
                 const dealWithData = (rows) => {
                     // 这里如果entity指向不同的实体，一般出现这样的查询，则其权限应当不由这条deduce路径处理
                     // 同上，如果找到的行数大于1行，说明deduce路径上的对象不确定，也暂不处理  by Xc 20230725
-                    if (rows.length > 1 || rows.length === 0) {
+                    if (rows.length > 1) {
                         if (process.env.NODE_ENV === 'development') {
                             console.warn(`进行deduce推导时找到了${rows.length}行${entity}数据`);
                         }
                         return entityFilters;
                     }
+                    else if (rows.length === 0) {
+                        // 说明没有找到行，这时候有一种可能是modi。这时候只能假设是指定id更新了，其它情况很难处理。by Xc
+                        if (filter.id) {
+                            // 用modi对应的entity/entityId来判定
+                            const modies = context.select('modi', {
+                                data: {
+                                    id: 1,
+                                    data: 1,
+                                    entity: 1,
+                                    entityId: 1,
+                                },
+                                filter: {
+                                    filter,
+                                }
+                            }, {});
+                            const getModiEntity = (modies) => {
+                                if (modies[0]) {
+                                    const { entity, entityId } = modies[0];
+                                    entityFilters.push({
+                                        entity: entity,
+                                        filter: {
+                                            id: entityId,
+                                        },
+                                        actions: ['update'],
+                                    });
+                                }
+                                return entityFilters;
+                            };
+                            if (modies instanceof Promise) {
+                                return modies.then((modies2) => getModiEntity(modies2));
+                            }
+                            return getModiEntity(modies);
+                        }
+                        return entityFilters;
+                    }
                     const { entity: deducedEntity, entityId: deducedEntityId } = rows[0];
                     if (!deducedEntity || !deducedEntityId) {
                         // 这种情况会出现在前台缓存里
@@ -801,6 +836,7 @@ class RelationAuth {
      */
     findActionAuthsOnNode(node, context) {
         const { entity, filter, action, userRelations } = node;
+        (0, assert_1.default)(filter);
         const deducedEntityFilters2 = this.getDeducedEntityFilters(entity, filter, [action], context);
         /**
          * 搜索判定是否允许自建对象，自建的条件是 path = ''，destEntity === entity

package/lib/store/projection.d.ts

@@ -0,0 +1,2 @@
+import { Projection } from '../base-app-domain/Modi/Schema';
+export declare const fullModi: Projection;

package/lib/store/projection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullModi = void 0;
+exports.fullModi = {
+    id: 1,
+    targetEntity: 1,
+    entity: 1,
+    entityId: 1,
+    action: 1,
+    iState: 1,
+    data: 1,
+    filter: 1,
+    $$createAt$$: 1,
+    $$updateAt$$: 1,
+};

package/lib/store/relation.js

@@ -42,7 +42,7 @@ function judgeRelation(schema, entity, attr, allowUnrecognized) {
         }
         else {
             // 这种情况应该不会跑到
-            (0, assert_1.default)(false);
+            (0, assert_1.default)(false, `非法的属性名：[${attr}]`);
         }
     }
     else if ((attributes.hasOwnProperty(`${attr}Id`))) {

package/lib/types/Configuration.d.ts

@@ -65,6 +65,7 @@ export type AccessConfiguration = {
         path?: string;
     };
     timeout?: number;
+    clockDriftDuration?: number;
 };
 /**
  * 业务逻辑的通用配置
@@ -87,15 +88,3 @@ export type DependencyConfiguration = string[];
 export type RenderConfiguration<ED extends BaseEntityDict & EntityDict> = {
     styleDict: StyleDict<ED>;
 };
-/**
- * 编译环境配置
- */
-export type CompilerConfiguration = {
-    webpack?: {
-        resolve?: {
-            alias?: Record<string, string>;
-            fallback?: Record<string, string | false>;
-        };
-        extraOakModules?: (string | RegExp)[];
-    };
-};

package/lib/types/Entity.d.ts

@@ -25,7 +25,6 @@ type FilterPart<A extends string, F extends Object | undefined> = {
 export type SelectOption = {
     dontCollect?: boolean;
     blockTrigger?: true;
-    obscure?: boolean;
     forUpdate?: true | 'skip locked' | 'nowait';
     includedDeleted?: true;
     ignoreAttrMiss?: true;

package/lib/types/Exception.d.ts

@@ -77,6 +77,9 @@ export declare class OakServerProxyException<ED extends EntityDict & BaseEntityD
 }
 export declare class OakClockDriftException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
 }
+export declare class OakSignatureVerificationException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
+    constructor(message?: string);
+}
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
  *

package/lib/types/Exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeException = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakClockDriftException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakRequestTimeoutException = exports.OakException = void 0;
+exports.makeException = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakSignatureVerificationException = exports.OakClockDriftException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakRequestTimeoutException = exports.OakException = void 0;
 const relation_1 = require("../store/relation");
 const lodash_1 = require("../utils/lodash");
 class OakException extends Error {
@@ -188,6 +188,13 @@ exports.OakServerProxyException = OakServerProxyException;
 class OakClockDriftException extends OakException {
 }
 exports.OakClockDriftException = OakClockDriftException;
+// 验签失败
+class OakSignatureVerificationException extends OakException {
+    constructor(message) {
+        super(message || '验签失败');
+    }
+}
+exports.OakSignatureVerificationException = OakSignatureVerificationException;
 // 在系统更新数据时，以下三个异常应按规范依次抛出。
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
@@ -510,6 +517,10 @@ function makeException(data) {
             e = new OakRequestTimeoutException(data.message);
             break;
         }
+        case 'OakSignatureVerificationException': {
+            e = new OakSignatureVerificationException(data.message);
+            break;
+        }
         default:
             return;
     }

package/lib/types/Expression.d.ts

@@ -150,7 +150,7 @@ export declare function isStringExpression<A>(expression: any): expression is St
 export declare function isAggrExpression<A>(expression: any): expression is AggrExpression<A>;
 export declare function isExpression<A>(expression: any): expression is Expression<A>;
 export declare function opMultipleParams(op: string): boolean;
-export declare function execOp(op: string, params: any, obscure?: boolean): ExpressionConstant;
+export declare function execOp(op: string, params: any): ExpressionConstant;
 /**
  * 检查一个表达式，并分析其涉及到的属性
  * @param expression

package/lib/types/Expression.js

@@ -136,10 +136,7 @@ function opMultipleParams(op) {
         '$round', '$floor', '$ceil', '$$max', '$$min', '$$sum', '$$avg', '$$count'].includes(op);
 }
 exports.opMultipleParams = opMultipleParams;
-function execOp(op, params, obscure) {
-    if (obscure && (params === undefined || params.includes(undefined))) {
-        return true;
-    }
+function execOp(op, params) {
     switch (op) {
         case '$gt': {
             return params[0] > params[1];

package/lib/types/Sync.d.ts

@@ -77,6 +77,7 @@ export interface SyncRemoteConfig<ED extends EntityDict & BaseEntityDict, Cxt ex
         reason: Error;
     }, context: Cxt) => Promise<void>;
     timeout?: number;
+    clockDriftDuration?: number;
 }
 export interface SyncSelfConfigBase<ED extends EntityDict & BaseEntityDict> {
     endpoint?: string;

package/lib/utils/SimpleConnector.d.ts

@@ -18,6 +18,7 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
     private configuration;
     private makeException;
     private timeout;
+    private clockDriftDuration;
     constructor(configuration: AccessConfiguration, makeException: (exceptionData: any) => OakException<ED>);
     getCorsHeader(): string[];
     protected makeHeadersAndBody(name: string, data: any, context?: FrontCxt): Promise<{

package/lib/utils/SimpleConnector.js

@@ -19,10 +19,12 @@ class SimpleConnector {
     configuration;
     makeException;
     timeout;
+    clockDriftDuration;
     constructor(configuration, makeException) {
         this.configuration = configuration;
-        const { routerPrefixes, http, timeout } = configuration;
+        const { routerPrefixes, http, timeout, clockDriftDuration } = configuration;
         this.timeout = timeout || 5000;
+        this.clockDriftDuration = clockDriftDuration || 10000;
         const { ssl, hostname, port, path } = http;
         const protocol = ssl ? 'https:' : 'http:';
         let serverUrl = `${protocol}//${hostname}`;
@@ -77,7 +79,7 @@ class SimpleConnector {
     async parseAspectResult(response) {
         if (response.status > 299) {
             const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
-            throw err;
+            throw this.makeException(err);
         }
         const message = response.headers.get('oak-message');
         const responseType = response.headers.get('Content-Type') ||
@@ -118,10 +120,14 @@ class SimpleConnector {
         }
         catch (err) {
             // fetch返回异常一定是网络异常
+            let exception = err;
             if (err instanceof types_1.OakRequestTimeoutException) {
-                throw new types_1.OakNetworkException(`接口请求超时`);
+                exception = new types_1.OakNetworkException(`接口请求超时`);
             }
-            throw new types_1.OakNetworkException(`接口请求时发生网络异常`);
+            else {
+                exception = new types_1.OakNetworkException(`接口请求时发生网络异常`);
+            }
+            throw this.makeException(exception);
         }
         return this.parseAspectResult(response);
     }
@@ -143,14 +149,18 @@ class SimpleConnector {
             response = await this.fetchWithTimeout(this.serverSubscribePointUrl, {}, this.timeout);
         }
         catch (err) {
+            let exception = err;
             if (err instanceof types_1.OakRequestTimeoutException) {
-                throw new types_1.OakNetworkException(`接口请求超时`);
+                exception = new types_1.OakNetworkException(`接口请求超时`);
+            }
+            else {
+                exception = new types_1.OakNetworkException(`接口请求时发生网络异常`);
             }
-            throw new types_1.OakNetworkException(`接口请求时发生网络异常`);
+            throw this.makeException(exception);
         }
         if (response.status > 299) {
             const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
-            throw err;
+            throw this.makeException(err);
         }
         const message = response.headers.get('oak-message');
         const responseType = response.headers.get('Content-Type') ||
@@ -219,10 +229,6 @@ class SimpleConnector {
      * @param headers
      */
     makeBridgeUrl(url, headers) {
-        // if (process.env.PROD !== 'true') {
-        //     console.warn('在development下无法通过bridge访问资源，将直接访问，可能失败', url);
-        //     return url;
-        // }
         const encodeUrl = encodeURIComponent(url);
         return `${this.serverBridgeUrl}?url=${encodeUrl}`;
     }
@@ -240,28 +246,29 @@ class SimpleConnector {
         return {};
     }
     async fetchWithTimeout(url, options, timeout = 5000) {
-        if (typeof AbortController === 'undefined') {
-            return global.fetch(url, options);
-        }
-        const controller = new AbortController();
-        const signal = controller.signal;
-        // 设置超时
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, timeout);
-        // 发起 fetch 请求并传递 signal
-        return global.fetch(url, Object.assign({}, options, { signal }))
-            .then(response => {
-            clearTimeout(timeoutId); // 如果请求成功，清除超时
-            return response;
-        })
-            .catch(error => {
-            clearTimeout(timeoutId); // 如果请求失败，清除超时
-            if (error.name === 'AbortError') {
-                throw new types_1.OakRequestTimeoutException();
-            }
-            throw error; // 其他错误
-        });
+        return global.fetch(url, options);
+        // if (typeof AbortController === 'undefined' || timeout === 0) {
+        //     return global.fetch(url, options);
+        // }
+        // const controller = new AbortController();
+        // const signal = controller.signal;
+        // // 设置超时
+        // const timeoutId = setTimeout(() => {
+        //   controller.abort();
+        // }, timeout);
+        // // 发起 fetch 请求并传递 signal
+        // return global.fetch(url, Object.assign({}, options, { signal }))
+        //   .then(response => {
+        //     clearTimeout(timeoutId); // 如果请求成功，清除超时
+        //     return response;
+        //   })
+        //   .catch(error => {
+        //     clearTimeout(timeoutId); // 如果请求失败，清除超时
+        //     if (error.name === 'AbortError') {
+        //       throw new OakRequestTimeoutException();
+        //     }
+        //     throw error; // 其他错误
+        //   });
     }
 }
 exports.default = SimpleConnector;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "5.1.12",
+    "version": "5.1.14",
     "author": {
         "name": "XuChang"
     },