oak-backend-base 4.1.28 → 4.1.29

package/lib/Synchronizer.d.ts

@@ -2,12 +2,21 @@ import { EntityDict, StorageSchema, EndpointItem, SyncConfig } from 'oak-domain/
 import { VolatileTrigger } from 'oak-domain/lib/types/Trigger';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
+export type FetchFn = (url: string, options: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}, timeout?: number) => Promise<{
+    status: number;
+    json: () => Promise<any>;
+}>;
 export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> {
     private config;
     private schema;
     private remotePullInfoMap;
     private channelDict;
     private contextBuilder;
+    private fetchFn;
     private pushAccessMap;
     private startChannel2;
     /**开始同步这些channel上的oper。注意，这时候即使某个channel上失败了，也不应影响本事务提交（其它的channel成功了） */
@@ -22,7 +31,7 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      */
     private trySynchronizeOpers;
     private makeCreateOperTrigger;
-    constructor(config: SyncConfig<ED, Cxt>, schema: StorageSchema<ED>, contextBuilder: () => Cxt);
+    constructor(config: SyncConfig<ED, Cxt>, schema: StorageSchema<ED>, contextBuilder: () => Cxt, fetchFn?: FetchFn);
     /**
      * 根据sync的定义，生成对应的 commit triggers
      * @returns

package/lib/Synchronizer.js

@@ -5,11 +5,11 @@ const crypto_1 = require("crypto");
 const types_1 = require("oak-domain/lib/types");
 const relationPath_1 = require("oak-domain/lib/utils/relationPath");
 const assert_1 = tslib_1.__importDefault(require("assert"));
-const path_1 = require("path");
 const lodash_1 = require("oak-domain/lib/utils/lodash");
 const filter_1 = require("oak-domain/lib/store/filter");
 const uuid_1 = require("oak-domain/lib/utils/uuid");
 const lodash_2 = require("lodash");
+const domain_1 = require("oak-domain/lib/utils/domain");
 const OAK_SYNC_HEADER_ENTITY = 'oak-sync-entity';
 const OAK_SYNC_HEADER_ENTITY_ID = 'oak-sync-entity-id';
 const OAK_SYNC_HEADER_TIMESTAMP = 'oak-sync-timestamp';
@@ -67,6 +67,7 @@ class Synchronizer {
     remotePullInfoMap = {};
     channelDict = {};
     contextBuilder;
+    fetchFn;
     pushAccessMap = {};
     async startChannel2(context, channel) {
         const { queue, api, selfEncryptInfo, entity, entityId, onFailed, timeout = 5000 } = channel;
@@ -78,12 +79,12 @@ class Synchronizer {
                 seq: ele.$$seq$$,
             }))), 'txnId:', context.getCurrentTxnId());
         }
-        const finalApi = (0, path_1.join)(api, selfEncryptInfo.id);
+        const finalApi = (0, domain_1.urlJoin)(api, selfEncryptInfo.id);
         channel.queue = [];
         try {
             const body = JSON.stringify(opers);
             const { ts, nonce, signature } = await sign(selfEncryptInfo.privateKey, body);
-            const res = await fetchWithTimeout(finalApi, {
+            const res = await this.fetchFn(finalApi, {
                 method: 'post',
                 headers: {
                     'Content-Type': 'application/json',
@@ -190,7 +191,7 @@ class Synchronizer {
         if (!this.channelDict[userId]) {
             // channel上缓存这些信息，暂不支持动态更新
             this.channelDict[userId] = {
-                api: (0, path_1.join)(url, 'endpoint', endpoint),
+                api: (0, domain_1.urlJoin)(url, 'endpoint', endpoint),
                 queue: [],
                 entity: remoteEntity,
                 entityId: remoteEntityId,
@@ -205,7 +206,7 @@ class Synchronizer {
             (0, assert_1.default)(this.channelDict[userId].onFailed === onFailed);
         }
         const channel = this.channelDict[userId];
-        (0, assert_1.default)(channel.api === (0, path_1.join)(url, 'endpoint', endpoint));
+        (0, assert_1.default)(channel.api === (0, domain_1.urlJoin)(url, 'endpoint', endpoint));
         (0, assert_1.default)(channel.entity === remoteEntity);
         (0, assert_1.default)(channel.entityId === remoteEntityId);
         if (channel.queue.find(ele => ele.oper.id === oper.id)) {
@@ -343,8 +344,19 @@ class Synchronizer {
             }, { dontCollect: true, forUpdate: true });
             dirtyOpers = dirtyOpers.filter(ele => !!ele[types_1.TriggerUuidAttribute]);
             if (dirtyOpers.length > 0) {
+                // 检查所有 channel 的 queue 是否已清空
                 for (const c in this.channelDict) {
-                    (0, assert_1.default)(this.channelDict[c].queue.length === 0);
+                    // 在生产环境不使用assert，而是清空队列，以防止脏数据堆积影响后续同步
+                    if (this.channelDict[c].queue.length > 0) {
+                        if (process.env.NODE_ENV !== 'production') {
+                            // 构建详细的错误信息
+                            const queuedOperIds = this.channelDict[c].queue.map(q => q.oper.id).join(', ');
+                            (0, assert_1.default)(false, `发现 channel ${c} 的 queue 未清空，包含 oper IDs: [${queuedOperIds}]`);
+                        }
+                        else {
+                            this.channelDict[c].queue = [];
+                        }
+                    }
                 }
                 const pushedIds = [];
                 const unPushedIds = [];
@@ -394,15 +406,45 @@ class Synchronizer {
     makeCreateOperTrigger() {
         const { config } = this;
         const { remotes, self } = config;
+        const entityActionMap = new Map();
         // 根据remotes定义，建立从entity到需要同步的远端结点信息的Map
         remotes.forEach((remote) => {
             const { getPushInfo, pushEntities: pushEntityDefs, endpoint, pathToUser, relationName: rnRemote, onFailed, timeout } = remote;
             if (pushEntityDefs) {
                 const pushEntities = [];
-                const endpoint2 = (0, path_1.join)(endpoint || 'sync', self.entity);
+                const endpoint2 = (0, domain_1.urlJoin)(endpoint || 'sync', self.entity);
                 for (const def of pushEntityDefs) {
                     const { pathToRemoteEntity, pathToSelfEntity, relationName, recursive, entity, actions, onSynchronized } = def;
                     pushEntities.push(entity);
+                    if (!entityActionMap.has(entity)) {
+                        entityActionMap.set(entity, {
+                            actions: new Set(),
+                            matchAllActions: false,
+                        });
+                    }
+                    const tracker = entityActionMap.get(entity);
+                    //如果当前定义是 wildcard（所有 action）
+                    if (!actions || actions.length === 0) {
+                        if (tracker.matchAllActions) {
+                            throw new Error(`PushEntityDef 配置错误：entity「${entity}」的所有 action 被定义了多次`);
+                        }
+                        if (tracker.actions.size > 0) {
+                            throw new Error(`PushEntityDef 配置错误：entity「${entity}」已定义特定 action「${Array.from(tracker.actions).join(', ')}」，不能再定义所有 action`);
+                        }
+                        tracker.matchAllActions = true;
+                    }
+                    else {
+                        // 如果当前定义是特定 action
+                        if (tracker.matchAllActions) {
+                            throw new Error(`PushEntityDef 配置错误：entity「${entity}」已定义所有 action，不能再定义特定 action「${actions.join(', ')}」`);
+                        }
+                        for (const action of actions) {
+                            if (tracker.actions.has(action)) {
+                                throw new Error(`PushEntityDef 配置错误：entity「${entity}」的action「${action}」被定义了多次`);
+                            }
+                            tracker.actions.add(action);
+                        }
+                    }
                     const relationName2 = relationName || rnRemote;
                     const path2 = pathToUser ? `${pathToRemoteEntity}.${pathToUser}` : pathToRemoteEntity;
                     (0, assert_1.default)(!recursive);
@@ -507,10 +549,11 @@ class Synchronizer {
         };
         return createOperTrigger;
     }
-    constructor(config, schema, contextBuilder) {
+    constructor(config, schema, contextBuilder, fetchFn) {
         this.config = config;
         this.schema = schema;
         this.contextBuilder = contextBuilder;
+        this.fetchFn = fetchFn || fetchWithTimeout;
     }
     /**
      * 根据sync的定义，生成对应的 commit triggers

package/lib/routines/update.d.ts

@@ -0,0 +1,65 @@
+import { EntityDict as TypeEntityDict, StorageSchema } from 'oak-domain/lib/types';
+import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
+import BackendRuntimeContext from 'oak-frontend-base/lib/context/BackendRuntimeContext';
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+type EntityDict = TypeEntityDict & BaseEntityDict;
+/**
+ * 反向引用描述
+ * 用于记录哪些实体引用了当前实体，便于在删除或更新时维护引用完整性
+ */
+export type ReverseRefDesc<ED extends EntityDict> = {
+    type: 'ref' | 'refs';
+    attrName: string;
+    sourceEntity: keyof ED;
+};
+/**
+ * 更新计划配置
+ * 定义了数据同步的完整策略和生命周期钩子
+ */
+export type UpdatePlan<ED extends EntityDict> = {
+    dontCreateOper?: boolean;
+    plan: {
+        [entityName in keyof ED]: {
+            /**
+             * 是否允许数据唯一性冲突时使用新数据覆盖旧数据（仅data中冲突）
+             * @deprecated ID必须相同但会导致ID检查不通过，弃用
+             */
+            allowDataUniqueReWrite?: boolean;
+            /**
+             * 在插入数据库遇到唯一性冲突时的处理方式（数据库和data冲突）
+             * skip表示跳过插入新数据，会将新数据的反指关系更新到已有数据上
+             * update表示使用新数据更新已有数据，会自动更新现有数据的所有反指关系
+             * error表示抛出错误
+             */
+            onUniqueViolation?: 'skip' | 'update' | 'error';
+            /**
+             * 处理数据库中存在但是数据文件中不存在的数据的方式
+             * skip表示跳过不处理
+             * delete表示做逻辑删除，可能导致插入新数据时id冲突
+             * 设置为physicalDelete可以保证最强的一致性
+             */
+            onOnlyExistingInDb?: 'skip' | 'delete' | 'physicalDelete';
+        };
+    };
+    beforeCheck?: (options: {
+        context: BackendRuntimeContext<ED>;
+        data: {
+            [entityName in keyof ED]?: Array<Partial<ED[entityName]['CreateOperationData']>>;
+        };
+        reverseRefs: {
+            [entityName in keyof ED]?: ReverseRefDesc<ED>[];
+        };
+    }) => Promise<void>;
+    afterUpdate?: (options: {
+        context: BackendRuntimeContext<ED>;
+        data: {
+            [entityName in keyof EntityDict]?: Array<Partial<EntityDict[entityName]['CreateOperationData']>>;
+        };
+        reverseRefs: {
+            [entityName in keyof EntityDict]?: ReverseRefDesc<ED>[];
+        };
+    }) => Promise<void>;
+};
+export declare const createUpdatePlan: <ED extends EntityDict>(options: UpdatePlan<ED>) => <Cxt extends AsyncContext<ED>>(context: Cxt) => Promise<void>;
+export declare function checkPathValue(itemId: string, destEntity: keyof EntityDict, path: string, storageSchema: StorageSchema<EntityDict>): boolean;
+export {};

package/lib/routines/update.js

@@ -0,0 +1,784 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUpdatePlan = void 0;
+exports.checkPathValue = checkPathValue;
+const tslib_1 = require("tslib");
+/**
+ * 数据同步工具
+ *
+ * 核心职责：将项目 lib/data 目录下的数据文件同步到数据库，同时处理数据冲突、引用关系和删除策略
+ *
+ * ==================== 配置项说明 ====================
+ *
+ * 1. allowDataUniqueReWrite（已弃用）
+ *    - 类型：boolean
+ *    - 默认：false
+ *    - 作用：当数据文件内部存在唯一索引冲突时，是否用后加载的数据覆盖先加载的数据
+ *    - 限制：要求冲突数据的 ID 必须完全相同，否则会抛出错误
+ *    - 弃用原因：ID 相同但会导致后续 ID 检查不通过
+ *
+ * 2. onUniqueViolation
+ *    - 类型：'skip' | 'update' | 'error'
+ *    - 默认：'error'
+ *    - 作用：当新数据的唯一索引与数据库已有数据冲突时的处理策略
+ *    - 行为说明：
+ *      - 'error': 直接抛出错误，终止执行
+ *      - 'skip': 跳过新数据的插入，但会将所有反向引用从旧数据 ID 更新到新数据 ID
+ *      - 'update': 插入新数据，将反向引用更新到新数据 ID，然后删除旧数据
+ *
+ * 3. onOnlyExistingInDb
+ *    - 类型：'skip' | 'delete' | 'physicalDelete'
+ *    - 默认：'skip'
+ *    - 作用：处理数据库中存在但数据文件中不存在的数据
+ *    - 行为说明：
+ *      - 'skip': 不处理，保留数据库中的数据
+ *      - 'delete': 执行逻辑删除（设置 $$deleteAt$$），可能在插入新数据时导致 ID 冲突
+ *      - 'physicalDelete': 执行物理删除，保证最强一致性，删除后可复用 ID
+ *
+ * 4. dontCreateOper
+ *    - 类型：boolean
+ *    - 作用：是否跳过创建操作记录（operation log）
+ *    - 适用场景：批量数据迁移、初始化等不需要记录操作历史的场景
+ *
+ * 5. beforeCheck
+ *    - 类型：异步函数
+ *    - 执行时机：在所有数据校验之后、数据库操作之前
+ *    - 参数：{ context, data, reverseRefs }
+ *    - 作用：执行自定义的业务校验逻辑
+ *
+ * 6. afterUpdate
+ *    - 类型：异步函数
+ *    - 执行时机：所有数据库操作完成之后
+ *    - 参数：{ context, data, reverseRefs }
+ *    - 作用：执行后置处理，如缓存刷新、通知发送等
+ *
+ * ==================== 执行流程 ====================
+ *
+ * 阶段 1：数据加载与校验
+ * ├─ 1.1 加载 lib/data 目录下的所有实体数据
+ * ├─ 1.2 执行实体级别的前置检查器（entityBeforeCheckers）
+ * │   └─ 示例：path 实体会校验路径格式和引用合法性
+ * └─ 1.3 分析所有实体的反向引用关系（reverseRefs）
+ *     ├─ 处理静态引用：xxxId 字段
+ *     └─ 处理动态引用：entity + entityId 字段组合
+ *
+ * 阶段 2：数据差异对比（按实体逐个处理）
+ * ├─ 2.1 校验配置项合法性
+ * ├─ 2.2 构建 ID → 数据对象映射，检查 ID 重复
+ * ├─ 2.3 校验引用完整性
+ * │   ├─ 检查 ref 类型字段指向的记录是否存在
+ * │   └─ 检查动态引用（entity/entityId）的完整性
+ * ├─ 2.4 从数据库查询所有已存在的记录（使用 forUpdate 锁定）
+ * ├─ 2.5 对比数据差异
+ * │   ├─ 已存在：使用 diffAttrs 对比属性，生成待更新列表
+ * │   ├─ 不存在：加入待新增列表
+ * │   └─ 特殊处理：physicalDelete 模式下，已删除数据视为新增
+ * └─ 2.6 校验唯一索引
+ *     ├─ 检查数据文件内部冲突（allowDataUniqueReWrite）
+ *     └─ 检查与数据库冲突（onUniqueViolation）
+ *
+ * 阶段 3：数据库写入（按实体逐个处理）
+ * ├─ 3.1 物理删除已标记删除的数据（如果需要）
+ * ├─ 3.2 执行新增操作
+ * │   ├─ 调用 context.operate 创建记录
+ * │   └─ 如果存在反向引用更新需求（toUpdateRefs）：
+ * │       ├─ 更新所有引用旧 ID 的记录为新 ID
+ * │       └─ 删除旧数据
+ * ├─ 3.3 执行更新操作
+ * │   └─ 仅更新有差异的字段
+ * └─ 3.4 收集待删除的数据 ID
+ *
+ * 阶段 4：依赖分析与删除
+ * ├─ 4.1 根据 reverseRefs 构建实体依赖图
+ * │   └─ 规则：引用方必须在被引用方之前删除
+ * ├─ 4.2 拓扑排序生成删除顺序
+ * └─ 4.3 按顺序执行删除操作
+ *     └─ 根据 onOnlyExistingInDb 决定逻辑删除或物理删除
+ *
+ * 阶段 5：后置处理
+ * └─ 5.1 执行 afterUpdate 钩子
+ *
+ * ==================== 关键决策点 ====================
+ *
+ * 1. 唯一索引冲突处理的选择
+ *    - skip: 适用于幂等性场景，多次执行不改变数据库状态
+ *    - update: 适用于数据迁移，需要用新数据完全替换旧数据
+ *    - error: 适用于严格模式，任何冲突都需要人工介入
+ *
+ * 2. 反向引用更新时机
+ *    - 在 skip 模式：新数据不插入，但引用关系需要指向已存在的旧数据
+ *    - 在 update 模式：新数据插入后，所有引用都需要更新到新数据
+ *
+ * 3. 删除顺序的必要性
+ *    - 必须先删除引用方，再删除被引用方，避免外键约束错误
+ *    - 使用拓扑排序保证删除的正确性
+ *
+ * ==================== 注意事项 ====================
+ *
+ * 1. 所有数据库操作都使用 blockTrigger: true 避免触发器干扰
+ * 2. 使用 forUpdate 锁定记录，避免并发修改导致的数据不一致
+ * 3. diffAttrs 会忽略系统字段（$$createAt$$、$$updateAt$$、$$deleteAt$$）
+ * 4. compareInner 会深度比较对象和数组，支持 null/undefined 互换
+ * 5. 反向引用分为静态引用（ref）和动态引用（refs），处理逻辑不同
+ */
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const path_1 = require("path");
+const dependencyBuilder_1 = require("oak-domain/lib/compiler/dependencyBuilder");
+const types_1 = require("oak-domain/lib/types");
+const uuid_1 = require("oak-domain/lib/utils/uuid");
+const requirePrj_1 = tslib_1.__importDefault(require("../utils/requirePrj"));
+const i18n_1 = tslib_1.__importDefault(require("oak-domain/lib/data/i18n"));
+/**
+ * 对比两个对象的属性差异，返回需要更新的属性集合
+ *
+ * 行为说明：
+ * - 忽略系统内置属性（$$createAt$$、$$updateAt$$、$$deleteAt$$）
+ * - 使用深度对比（compareInner）判断属性值是否真正发生变化
+ * - 只返回发生变化的属性，减少不必要的数据库更新
+ *
+ * @param oldData 旧数据（数据库中的数据）
+ * @param newData 新数据（数据文件中的数据）
+ * @returns 发生变化的属性集合
+ */
+const diffAttrs = (oldData, newData) => {
+    const compared = new Set();
+    const diffs = {};
+    for (const key in newData) {
+        // 忽略$$createAt$$和$$updateAt$$,$$deleteAt$$属性
+        if (types_1.initinctiveAttributes.includes(key)) {
+            compared.add(key);
+            continue;
+        }
+        if (newData[key] !== oldData[key]) {
+            if (!compareInner(newData[key], oldData[key])) {
+                diffs[key] = newData[key];
+            }
+            compared.add(key);
+        }
+    }
+    for (const key in oldData) {
+        if (types_1.initinctiveAttributes.includes(key)) {
+            continue;
+        }
+        if (compared.has(key)) {
+            continue;
+        }
+        // 这里表示之前有值在old里，但是新的里没有这个属性了，视为需要更新为null
+        if ((oldData[key] !== undefined && oldData[key] !== null) && newData[key] === undefined) {
+            diffs[key] = null; // 这里将undefined的属性更新为null，表示删除这个属性
+        }
+    }
+    return diffs;
+};
+/**
+ * 深度比较两个值是否相等
+ *
+ * 特殊处理：
+ * - null 和 undefined 视为相等
+ * - 递归比较对象和数组
+ * - 支持嵌套结构的完整对比
+ *
+ * @param a 值 A
+ * @param b 值 B
+ * @returns 是否相等
+ */
+const compareInner = (a, b) => {
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (typeof a === 'object' && a !== null && b !== null) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        for (const key of aKeys) {
+            if (!compareInner(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!compareInner(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else {
+        return (a === b) || (a === undefined && b === null) || (a === null && b === undefined);
+    }
+};
+const createUpdatePlan = (options) => {
+    const entityPlans = options.plan;
+    const beforeCheckFn = options.beforeCheck || (async () => { });
+    const afterUpdateFn = options.afterUpdate || (async () => { });
+    const globalOptions = Object.assign({}, options.dontCreateOper ? { dontCreateOper: true } : {});
+    const update = async (context) => {
+        const pwd = process.cwd();
+        const schema = context.getSchema();
+        const needUpdateEntities = Object.keys(options.plan);
+        const depGraph = (0, dependencyBuilder_1.analyzeDepedency)(pwd).ascOrder;
+        const data = (0, requirePrj_1.default)(pwd, (0, path_1.join)('lib', 'data', 'index'), depGraph);
+        data.i18n.push(...i18n_1.default); // 合并domain的i18n数据
+        for (const entityName in data) {
+            if (!needUpdateEntities.includes(entityName)) {
+                continue;
+            }
+            (0, assert_1.default)(schema[entityName], `Entity ${entityName} not found in schema`);
+            if (entityBeforeCheckers[entityName]) {
+                const checkers = entityBeforeCheckers[entityName];
+                const entityDataArray = data[entityName];
+                for (const item of entityDataArray) {
+                    for (const checker of checkers) {
+                        await checker.check({
+                            context: context,
+                            item: item,
+                            schema
+                        });
+                    }
+                }
+            }
+        }
+        // 所有的反指关系
+        const reverseRefs = {};
+        for (const entityName in schema) {
+            const storageDesc = schema[entityName];
+            for (const attrName in storageDesc.attributes) {
+                const columnDesc = storageDesc.attributes[attrName];
+                (0, assert_1.default)(columnDesc, `Attribute ${attrName} not found in entity ${entityName}`);
+                if (columnDesc.type === 'ref' && attrName.endsWith('Id')) {
+                    (0, assert_1.default)(columnDesc.ref, `Attribute ${attrName} in entity ${entityName} is ref type but missing ref`);
+                    if (!reverseRefs[columnDesc.ref]) {
+                        reverseRefs[columnDesc.ref] = [];
+                    }
+                    reverseRefs[columnDesc.ref].push({
+                        type: 'ref',
+                        attrName,
+                        sourceEntity: entityName,
+                    });
+                }
+                else if (attrName === 'entity' && columnDesc.params?.length === 32) {
+                    if (!columnDesc.ref) {
+                        console.log(`Attribute entity in entity ${entityName} has no ref, skipping dynamic reverse ref analysis`);
+                        continue;
+                    }
+                    const columnDesc2 = (storageDesc.attributes)['entityId'];
+                    if (columnDesc2.params?.length === 64) {
+                        // 这个情况说明是动态反指
+                        (0, assert_1.default)(Array.isArray(columnDesc.ref), `Attribute entityId in entity ${entityName} should have array ref`);
+                        for (const refEntity of columnDesc.ref) {
+                            if (!reverseRefs[refEntity]) {
+                                reverseRefs[refEntity] = [];
+                            }
+                            reverseRefs[refEntity].push({
+                                type: 'refs',
+                                attrName: 'entityId',
+                                sourceEntity: entityName,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // 先执行前置检查
+        await beforeCheckFn({ context, data, reverseRefs });
+        const toDelete = {};
+        const needPhysicalDelete = {};
+        for (const entityName of needUpdateEntities) {
+            const entityPlan = entityPlans[entityName];
+            // 先确保配置是正确的
+            if (entityPlan.onUniqueViolation) {
+                (0, assert_1.default)(['skip', 'update', 'error'].includes(entityPlan.onUniqueViolation), `Invalid onUniqueViolation option for entity ${entityName}`);
+            }
+            if (entityPlan.onOnlyExistingInDb) {
+                (0, assert_1.default)(['skip', 'delete', 'physicalDelete'].includes(entityPlan.onOnlyExistingInDb), `Invalid onOnlyExistingInDb option for entity ${entityName}`);
+            }
+            (0, assert_1.default)(!entityPlan.allowDataUniqueReWrite || typeof entityPlan.allowDataUniqueReWrite === 'boolean', `Invalid allowDataUniqueReWrite option for entity ${entityName}`);
+            const storageDesc = schema[entityName];
+            (0, assert_1.default)(storageDesc, `Entity ${entityName} not found in schema`);
+            const entityDataArray = data[entityName];
+            (0, assert_1.default)(Array.isArray(entityDataArray), `Data for entity ${entityName} should be an array`);
+            const idToDataMap = new Map();
+            for (const item of entityDataArray) {
+                (0, assert_1.default)(item.id, `Item in entity ${entityName} is missing id`);
+                // ID不允许重复
+                if (idToDataMap.has(item.id)) {
+                    throw new Error(`Duplicate id ${item.id} in entity ${entityName}`);
+                }
+                idToDataMap.set(item.id, item);
+            }
+            const fullProjection = {};
+            for (const attrName in storageDesc.attributes) {
+                Object.assign(fullProjection, { [attrName]: 1 });
+                // 检查指针关系
+                const columnDesc = storageDesc.attributes[attrName];
+                (0, assert_1.default)(columnDesc, `Attribute ${attrName} not found in entity ${entityName}`);
+                if (columnDesc.notNull) {
+                    for (const item of entityDataArray) {
+                        const value = item[attrName];
+                        (0, assert_1.default)(value !== null && value !== undefined, `In entity ${entityName}, item id ${item.id} attribute ${attrName} is notNull but missing in data`);
+                    }
+                }
+                if (columnDesc.type === 'ref' && attrName.endsWith('Id')) {
+                    (0, assert_1.default)(columnDesc.ref, `Attribute ${attrName} in entity ${entityName} is ref type but missing ref`);
+                    // 在现有数据中查找entity为ref，id为属性值的记录
+                    const exEntityData = data[columnDesc.ref] || [];
+                    for (const item of entityDataArray) {
+                        const value = item[attrName];
+                        if (!value && !columnDesc.notNull) {
+                            continue;
+                        }
+                        const findRecord = exEntityData.find(rec => rec.id === item[attrName]);
+                        if (findRecord) {
+                            continue;
+                        }
+                        // 查询数据库
+                        const count = await context.count(columnDesc.ref, {
+                            filter: {
+                                id: value
+                            }
+                        }, { blockTrigger: true, dontCollect: true });
+                        (0, assert_1.default)(count === 1, `In entity ${entityName}, item id ${item.id} attribute ${attrName} references non-existing record id ${value} in entity ${columnDesc.ref}`);
+                    }
+                }
+                else if (attrName === 'entity' && columnDesc.params?.length === 32) {
+                    const allowNullEntity = columnDesc.notNull === false;
+                    if (storageDesc.attributes['entityId']) {
+                        const columnDesc2 = storageDesc.attributes['entityId'];
+                        if (columnDesc2.params?.length === 64) {
+                            // 这个情况说明是动态反指
+                            for (const item of entityDataArray) {
+                                if (allowNullEntity && !item['entity']) {
+                                    continue;
+                                }
+                                const entityName = item['entity'];
+                                const entityId = item['entityId'];
+                                if (!columnDesc2.notNull && (!entityName || !entityId)) {
+                                    continue;
+                                }
+                                (0, assert_1.default)(entityName && entityId, `In entity ${entityName}, item id ${item.id} dynamic attribute entity/entityId is missing`);
+                                const exEntityData = data[entityName] || [];
+                                const findRecord = exEntityData.find(rec => rec.id === entityId);
+                                if (findRecord) {
+                                    continue;
+                                }
+                                // 查询数据库
+                                const count = await context.count(entityName, {
+                                    filter: {
+                                        id: entityId
+                                    }
+                                }, { blockTrigger: true, dontCollect: true });
+                                (0, assert_1.default)(count === 1, `In entity ${entityName}, item id ${item.id} dynamic attribute entity/entityId references non-existing record id ${entityId} in entity ${entityName}`);
+                            }
+                        }
+                    }
+                }
+                // 通用的检查
+                switch (columnDesc.type) {
+                    case 'varchar': {
+                        const length = columnDesc.params?.length || 0;
+                        for (const item of entityDataArray) {
+                            const value = item[attrName];
+                            if (value && value.length > length) {
+                                throw new Error(`In entity ${entityName}, item id ${item.id} attribute ${attrName} exceeds varchar length ${length}`);
+                            }
+                        }
+                        break;
+                    }
+                    case 'object': {
+                        // 这种情况说明是一个合法的json对象即可
+                        for (const item of entityDataArray) {
+                            const value = item[attrName];
+                            if (value !== null && value !== undefined) {
+                                (0, assert_1.default)(typeof value === 'object', `In entity ${entityName}, item id ${item.id} attribute ${attrName} should be an object`);
+                            }
+                        }
+                    }
+                }
+            }
+            const existingRecords = await context.select(entityName, {
+                filter: {
+                    id: { $in: Array.from(idToDataMap.keys()) }
+                },
+                data: {
+                    id: 1,
+                    ...fullProjection,
+                    ...(entityPlan.onOnlyExistingInDb === 'physicalDelete' ? { $$deleteAt$$: 1 } : {})
+                }
+            }, {
+                blockTrigger: true,
+                dontCollect: true,
+                forUpdate: true,
+                ...(entityPlan.onOnlyExistingInDb === 'physicalDelete' ? { includedDeleted: true } : {})
+            });
+            const toAdd = [];
+            const toUpdate = [];
+            for (const item of entityDataArray) {
+                const existing = existingRecords.find(rec => rec.id === item.id);
+                if (existing) {
+                    if (entityPlan.onOnlyExistingInDb === 'physicalDelete' && existing['$$deleteAt$$']) {
+                        // 视为新增，但是在新增之前就需要物理删除
+                        if (!needPhysicalDelete[entityName]) {
+                            needPhysicalDelete[entityName] = [];
+                        }
+                        needPhysicalDelete[entityName].push(item.id);
+                        toAdd.push(item);
+                        continue;
+                    }
+                    // 对比属性差异
+                    const diffs = diffAttrs(existing, item);
+                    if (Object.keys(diffs).length > 0) {
+                        const updateData = Object.assign({ id: item.id }, diffs);
+                        toUpdate.push(updateData);
+                    }
+                }
+                else {
+                    (0, assert_1.default)(item.id, `New item in entity ${entityName} missing id`);
+                    toAdd.push(item);
+                }
+            }
+            const toUpdateRefs = {};
+            // 检查所有unique的属性在新增和更新中的唯一性
+            for (const i in storageDesc.indexes) {
+                const indexDesc = storageDesc.indexes[i];
+                const indexName = indexDesc.name;
+                (0, assert_1.default)(indexDesc, `Index ${indexName} not found in entity ${entityName}`);
+                (0, assert_1.default)(typeof indexDesc !== 'number', `Index ${indexName} in entity ${entityName} should not be a number`);
+                (0, assert_1.default)(typeof indexDesc !== 'function', `Index ${indexName} in entity ${entityName} should not be a function`);
+                if (!indexDesc?.config?.unique) {
+                    continue;
+                }
+                const projection = {};
+                for (const attr of indexDesc.attributes) {
+                    (0, assert_1.default)(attr.name, `Index attribute name missing in index ${indexName} of entity ${entityName}`);
+                    Object.assign(projection, { [attr.name]: 1 });
+                }
+                // 这里对每一条数据进行检查unique索引
+                const toCheck = [...toAdd];
+                for (const item of toCheck) {
+                    // 检查toCheck列表内部是否有重复
+                    const duplicates = entityDataArray.filter(dataItem => {
+                        let allMatch = true;
+                        for (const attr of indexDesc.attributes) {
+                            if (!compareInner(dataItem[attr.name], item[attr.name])) {
+                                allMatch = false;
+                                break;
+                            }
+                        }
+                        return allMatch;
+                    });
+                    if (duplicates.length > 1) {
+                        if (!entityPlan.allowDataUniqueReWrite) {
+                            throw new Error(`Unique index violation on entity ${entityName} for index ${indexName} when adding id ${item.id}`);
+                        }
+                        else {
+                            // 必须id一样，不然不允许覆盖
+                            const allSameId = duplicates.every(dup => dup.id === item.id);
+                            (0, assert_1.default)(allSameId, `当允许唯一性冲突覆盖时，冲突的数据ID必须相同，实体 ${entityName} 索引 ${indexName} 冲突数据ID列表: ${duplicates.map(d => d.id).join(', ')}`);
+                            console.log(`发现实体 ${entityName} 唯一性索引${indexName}冲突，将保留数据 ${duplicates[duplicates.length - 1]}`);
+                            for (let i = 0; i < duplicates.length - 2; i++) { // 保留最后一条,因为在requireSth时，是先加载依赖，再加载项目，所以后面的数据应该是项目自己的
+                                const indexInAdd = toAdd.findIndex(dataItem => dataItem.id === duplicates[i].id);
+                                if (indexInAdd >= 0) {
+                                    toAdd.splice(indexInAdd, 1);
+                                }
+                            }
+                        }
+                    }
+                    // 检查数据库中是否有重复
+                    const filter = {};
+                    for (const attr of indexDesc.attributes) {
+                        Object.assign(filter, { [attr.name]: item[attr.name] });
+                    }
+                    const count = await context.count(entityName, {
+                        filter,
+                    }, { blockTrigger: true, dontCollect: true });
+                    if (count > 0) {
+                        if (!entityPlan.onUniqueViolation || entityPlan.onUniqueViolation === 'error') {
+                            throw new Error(`Unique index violation on entity ${entityName} for index ${indexName} when adding id ${item.id}, attr is ${JSON.stringify(filter)}`);
+                        }
+                        else if (entityPlan.onUniqueViolation === 'skip') {
+                            // 从待添加列表中移除
+                            const indexInAdd = toAdd.findIndex(dataItem => dataItem.id === item.id);
+                            if (indexInAdd >= 0) {
+                                toAdd.splice(indexInAdd, 1);
+                            }
+                            // 查出老数据ID,放到toUpdateRefs更新列表中
+                            const sexistingRecords = await context.select(entityName, {
+                                filter,
+                                data: { id: 1 }
+                            }, { blockTrigger: true, dontCollect: true });
+                            (0, assert_1.default)(sexistingRecords.length === 1, `Existing record not found for unique violation skip on entity ${entityName}`);
+                            // 是要在全部完成插入之后，把新id都更新成旧id，其实就说明新数据不会被新增，直接复用老数据
+                            toUpdateRefs[sexistingRecords[0].id] = {
+                                entityId: item.id,
+                            };
+                        }
+                        else if (entityPlan.onUniqueViolation === 'update') {
+                            // 查询出原始数据ID，放到toUpdateRefs更新列表中
+                            const sexistingRecords = await context.select(entityName, {
+                                filter,
+                                data: { id: 1 }
+                            }, { blockTrigger: true, dontCollect: true });
+                            for (const existingRecord of sexistingRecords) {
+                                (0, assert_1.default)(existingRecord, `Existing record not found for unique violation update on entity ${entityName}`);
+                                (0, assert_1.default)(existingRecord.id !== item.id, `Existing record id should be different from new item id for unique violation update on entity ${entityName}`);
+                                toUpdateRefs[item.id] = {
+                                    entityId: existingRecord.id,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            if (needPhysicalDelete[entityName]) {
+                console.log(`将物理删除实体 ${entityName} ID列表:`, needPhysicalDelete[entityName]);
+                await context.operate(entityName, {
+                    id: await (0, uuid_1.generateNewIdAsync)(),
+                    action: "remove",
+                    data: {},
+                    filter: {
+                        id: {
+                            $in: needPhysicalDelete[entityName]
+                        },
+                    }
+                }, { dontCollect: true, blockTrigger: true, ...globalOptions, deletePhysically: true, includedDeleted: true });
+            }
+            // 检查完毕数据正确性，开始检查更新
+            if (toAdd.length > 0) {
+                console.log(`将新增实体 ${entityName} ID列表:`, toAdd.map(item => item.id));
+                for (const item of toAdd) {
+                    await context.operate(entityName, {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: "create",
+                        data: item,
+                    }, { dontCollect: true, blockTrigger: true, ...globalOptions });
+                    // 是否需要更新反指
+                    if (toUpdateRefs[item.id]) {
+                        console.log(`在实体 ${entityName} 中需要将旧的引用ID ${toUpdateRefs[item.id].entityId} 的所有反指针更新为新的ID ${item.id} `);
+                        const reverseRefDescs = reverseRefs[entityName];
+                        if (reverseRefDescs) {
+                            for (const reverseRefDesc of reverseRefDescs) {
+                                if (reverseRefDesc.type === 'ref') {
+                                    // 单指
+                                    const updateData = {
+                                        [reverseRefDesc.attrName]: item.id,
+                                    };
+                                    console.log(`Updating reverse ref in entity ${String(reverseRefDesc.sourceEntity)} attr ${reverseRefDesc.attrName} to new id ${item.id} for original id ${toUpdateRefs[item.id].entityId}`);
+                                    await context.operate(reverseRefDesc.sourceEntity, {
+                                        id: await (0, uuid_1.generateNewIdAsync)(),
+                                        action: "update",
+                                        data: updateData,
+                                        filter: {
+                                            [reverseRefDesc.attrName]: toUpdateRefs[item.id].entityId,
+                                        }
+                                    }, { dontCollect: true, blockTrigger: true, ...globalOptions });
+                                }
+                                else {
+                                    (0, assert_1.default)(reverseRefDesc.type === 'refs', `Unknown reverse ref type ${reverseRefDesc.type} in entity ${entityName}`);
+                                    // 动态反指
+                                    const existingRecords = await context.select(reverseRefDesc.sourceEntity, {
+                                        filter: {
+                                            entity: entityName,
+                                            entityId: toUpdateRefs[item.id].entityId,
+                                        },
+                                        data: {
+                                            id: 1,
+                                            entityId: 1,
+                                        }
+                                    }, { blockTrigger: true, dontCollect: true });
+                                    const updateData = {
+                                        entityId: item.id,
+                                    };
+                                    console.log(`Updating reverse refs in entity ${String(reverseRefDesc.sourceEntity)} attr ${reverseRefDesc.attrName} to new id ${item.id} for original id ${toUpdateRefs[item.id].entityId}`);
+                                    await context.operate(reverseRefDesc.sourceEntity, {
+                                        id: await (0, uuid_1.generateNewIdAsync)(),
+                                        action: "update",
+                                        data: updateData,
+                                        filter: {
+                                            id: {
+                                                $in: existingRecords.map(rec => rec.id)
+                                            },
+                                        }
+                                    }, { dontCollect: true, blockTrigger: true, ...globalOptions });
+                                }
+                            }
+                            // 删除已存在的数据
+                            console.log(`Deleting original record id ${toUpdateRefs[item.id].entityId} in entity ${entityName} after reverse ref update`);
+                            await context.operate(entityName, {
+                                id: await (0, uuid_1.generateNewIdAsync)(),
+                                action: "remove",
+                                data: {},
+                                filter: {
+                                    id: toUpdateRefs[item.id].entityId,
+                                }
+                            }, { dontCollect: true, blockTrigger: true, ...globalOptions });
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(`实体 ${entityName} 无需新增数据`);
+            }
+            if (toUpdate.length > 0) {
+                console.log(`将更新实体 ${entityName} ID列表:`, toUpdate.map(item => item.id));
+                for (const item of toUpdate) {
+                    (0, assert_1.default)(item.id, `Update item in entity ${entityName} missing id`);
+                    await context.operate(entityName, {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: "update",
+                        data: item,
+                        filter: {
+                            id: item.id,
+                        }
+                    }, { dontCollect: true, blockTrigger: true, ...globalOptions });
+                }
+            }
+            else {
+                console.log(`实体 ${entityName} 无需更新数据`);
+            }
+            // 需要删除的数据
+            if (entityPlan.onOnlyExistingInDb === 'delete' || entityPlan.onOnlyExistingInDb === 'physicalDelete') {
+                const nonExistingRecords = await context.select(entityName, {
+                    filter: {
+                        id: { $nin: Array.from(idToDataMap.keys()) }
+                    },
+                    data: { id: 1 }
+                }, { blockTrigger: true, dontCollect: true, ...entityPlan.onOnlyExistingInDb === 'physicalDelete' ? { includedDeleted: true } : {} });
+                if (nonExistingRecords.length > 0) {
+                    toDelete[entityName] = nonExistingRecords.map(rec => rec.id);
+                }
+            }
+            else {
+                console.log(`实体 ${entityName} 无需删除数据`);
+            }
+        }
+        // 执行删除操作，根据 reverseRefs 构建删除顺序
+        // 构建每个实体被哪些实体依赖的映射（被引用方 -> 引用方列表）
+        const entityDeps = new Map();
+        const entitiesToDelete = new Set(Object.keys(toDelete));
+        // 初始化所有待删除实体
+        entitiesToDelete.forEach(entityName => {
+            if (!entityDeps.has(entityName)) {
+                entityDeps.set(entityName, new Set());
+            }
+        });
+        // 根据 reverseRefs 构建依赖关系
+        for (const [targetEntity, refList] of Object.entries(reverseRefs)) {
+            if (!entitiesToDelete.has(targetEntity)) {
+                continue;
+            }
+            for (const refDesc of refList || []) {
+                if (entitiesToDelete.has(refDesc.sourceEntity)) {
+                    // sourceEntity 引用了 targetEntity
+                    // 删除时应该先删除 sourceEntity
+                    if (!entityDeps.has(targetEntity)) {
+                        entityDeps.set(targetEntity, new Set());
+                    }
+                    entityDeps.get(targetEntity).add(refDesc.sourceEntity);
+                }
+            }
+        }
+        // 拓扑排序：优先删除没有依赖的实体（引用方）
+        const deleteOrder = [];
+        const visited = new Set();
+        const visit = (entityName) => {
+            if (visited.has(entityName)) {
+                return;
+            }
+            visited.add(entityName);
+            const deps = entityDeps.get(entityName);
+            if (deps) {
+                deps.forEach(dep => {
+                    visit(dep);
+                });
+            }
+            deleteOrder.push(entityName);
+        };
+        entitiesToDelete.forEach(entityName => {
+            visit(entityName);
+        });
+        // 按照拓扑排序的顺序执行删除
+        for (const entityName of deleteOrder) {
+            const idsToDelete = toDelete[entityName];
+            if (!idsToDelete || idsToDelete.length === 0) {
+                continue;
+            }
+            console.log(`删除实体 ${String(entityName)}，ID 列表:`, idsToDelete);
+            await context.operate(entityName, {
+                id: await (0, uuid_1.generateNewIdAsync)(),
+                action: "remove",
+                data: {},
+                filter: {
+                    id: { $in: idsToDelete }
+                }
+            }, { dontCollect: true, blockTrigger: true, ...globalOptions, ...entityPlans[entityName].onOnlyExistingInDb === 'physicalDelete' ? { deletePhysically: true, includedDeleted: true } : {} });
+        }
+        // 执行后置处理
+        await afterUpdateFn({ context, data, reverseRefs });
+        console.log('数据更新完成', JSON.stringify(context.opResult, null, 2));
+    };
+    return update;
+};
+exports.createUpdatePlan = createUpdatePlan;
+/**
+ *  这里做一些特殊的检查，比如path的合法性检查等，通用的检查放在update函数里
+ */
+const entityBeforeCheckers = {
+    'path': [
+        {
+            check: async ({ context, item, schema }) => {
+                (0, assert_1.default)(item.destEntity, `Path item id ${item.id} missing destEntity`);
+                (0, assert_1.default)(item.value !== undefined && item.value !== null, `Path item id ${item.id} missing value`);
+                (0, assert_1.default)(schema[item.sourceEntity], `Path item id ${item.id} has invalid sourceEntity ${item.sourceEntity}`);
+                checkPathValue(item.id, item.destEntity, item.value, schema);
+            }
+        }
+    ]
+};
+function checkPathValue(itemId, destEntity, path, storageSchema) {
+    const checkInner = (currentEntity, subPath, schema) => {
+        if (!subPath) {
+            return true;
+        }
+        // 第一层path   
+        const pathParts = subPath.split('.');
+        const firstPart = pathParts[0];
+        (0, assert_1.default)(firstPart, `[Path校验失败] 数据 ${itemId} 路径格式错误，路径 "${subPath}" 不能为空或无效`);
+        if (firstPart.includes("$")) {
+            const [entity, attr] = firstPart.split('$');
+            const entitySchema = schema[entity];
+            (0, assert_1.default)(entitySchema, `[Path校验失败] 数据 ${itemId} 引用路径错误：实体 "${entity}" 在 schema 中不存在，请检查路径 "${path}" 中的实体名称是否正确`);
+            const attrDesc = entitySchema.attributes[`${attr}Id`];
+            (0, assert_1.default)(attrDesc, `[Path校验失败] 数据 ${itemId} 引用路径错误：实体 "${entity}" 中不存在属性 "${attr}"，请检查 schema 定义`);
+            (0, assert_1.default)(attrDesc.type === 'ref', `[Path校验失败] 数据 ${itemId} 引用路径错误：实体 "${entity}" 的属性 "${attr}" 不是引用类型 （ref），实际类型为 ${attrDesc.type}，请检查 schema 定义`);
+            return checkInner(entity, pathParts.slice(1).join('.'), schema);
+        }
+        else {
+            const entitySchema = schema[currentEntity];
+            (0, assert_1.default)(entitySchema, `[Path校验失败] 数据 ${itemId} 引用路径错误：实体 "${currentEntity}" 在 schema 中不存在`);
+            const attrDesc = entitySchema.attributes[`${firstPart}Id`];
+            if (!attrDesc) {
+                // 尝试查找entity和entityId的动态反指
+                const entityDesc = entitySchema.attributes['entity'];
+                const entityIdDesc = entitySchema.attributes['entityId'];
+                if (entityDesc && entityIdDesc && entityDesc.params?.length === 32 && entityIdDesc.params?.length === 64) {
+                    (0, assert_1.default)(entityDesc.ref?.includes(firstPart), `[Path校验失败] 数据 ${itemId} 引用路径错误：实体中的entity多态反指不包含 "${firstPart}"，无法建立到 "${firstPart}" 的引用关系`);
+                    // 这是动态反指
+                    return checkInner(firstPart, pathParts.slice(1).join('.'), schema);
+                }
+            }
+            (0, assert_1.default)(attrDesc, `[Path校验失败] 数据 ${itemId} 引用路径错误：实体中不存在属性 "${firstPart}Id"，无法建立到 "${firstPart}" 的引用关系`);
+            (0, assert_1.default)(attrDesc.type === 'ref', `[Path校验失败] 数据 ${itemId} 引用路径错误：属性 "${firstPart}Id" 不是引用类型（ref），实际类型为 ${attrDesc.type}`);
+            const distEntity = attrDesc.ref;
+            (0, assert_1.default)(distEntity, `[Path校验失败] 数据 ${itemId} 引用路径错误：属性 "${firstPart}Id" 的 ref 配置为空，无法确定目标实体`);
+            return checkInner(distEntity, pathParts.slice(1).join('.'), schema);
+        }
+    };
+    return checkInner(destEntity, path, storageSchema);
+}

package/lib/utils/dbPriority.js

@@ -38,7 +38,7 @@ const getDbConfig = (path) => {
             // do nothing
         }
     }
-    throw new Error(`没有找到数据库配置文件，请在configuration目录下添加任一配置文件：${Object.keys(exports.dbList).map(ele => `${ele}.json`).join('、')}`);
+    throw new Error(`没有找到数据库配置文件，请在configuration目录下添加任一配置文件：${Object.keys(exports.dbList).map(ele => `${ele}.json`).join('、')}, 当前环境: ${process.env.NODE_ENV}`);
 };
 exports.getDbConfig = getDbConfig;
 const getDbStoreClass = (config) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.28",
+    "version": "4.1.29",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -13,7 +13,10 @@
         "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"
+        "test:sync": "vitest run",
+        "test:sync:ui": "vitest --ui",
+        "build": "node ./scripts/build.js && npm run copy-files",
+        "make:test:domain": "ts-node scripts/makeTestDomain.ts"
     },
     "dependencies": {
         "@types/koa": "^2.15.0",
@@ -21,10 +24,10 @@
         "mysql": "^2.18.1",
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
-        "oak-common-aspect": "^3.0.5",
-        "oak-db": "^3.3.13",
-        "oak-domain": "^5.1.35",
-        "oak-frontend-base": "^5.3.45",
+        "oak-common-aspect": "^3.0.6",
+        "oak-db": "^3.3.14",
+        "oak-domain": "^5.1.36",
+        "oak-frontend-base": "^5.3.46",
         "socket.io": "^4.8.1",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"
@@ -35,9 +38,10 @@
         "@types/node": "^20.6.0",
         "@types/node-schedule": "^2.1.0",
         "@types/uuid": "^8.3.4",
+        "@vitest/ui": "^4.0.18",
         "copyfiles": "^2.4.1",
-        "ts-node": "^10.9.1",
         "tslib": "^2.4.0",
-        "typescript": "^5.2.2"
+        "typescript": "^5.2.2",
+        "vitest": "^4.0.18"
     }
 }