gdmb 1.1.0 → 1.2.1

package/dist/gdmb.es.js

@@ -76,14 +76,20 @@ class w {
    * @example
    * ```typescript
    * class ServiceOne extends DomainService {
+   *
+   *   // before resolve 拦截器
+   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+   *
+   *   // after resolve 拦截器
+   *   public static afterResolution(token: InjectionToken, result: ServiceOne | ServiceOne[], resolutionType: string) {}
+   *
    *   constructor(public arg: string, public arg2: number) {
    *     super();
    *   }
    * }
    *
-   * domain.registerService(ServiceOne, { args: ['hello', 3] })
-   * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
-   * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+   * // 注册领域服务
+   * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
    * ```
    */
   registerService(e, s) {
@@ -112,14 +118,20 @@ class w {
    * @example
    * ```typescript
    * class EntityOne extends DomainEntity {
+   *
+   *   // before resolve 拦截器
+   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+   *
+   *   // after resolve 拦截器
+   *   public static afterResolution(token: InjectionToken, result: EntityOne | EntityOne[], resolutionType: string) {}
+   *
    *   constructor(public arg: string, public arg2: number) {
    *     super();
    *   }
    * }
    *
-   * domain.registerEntity(EntityOne, { args: ['hello', 3] })
-   * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
-   * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+   * // 注册领域实体
+   * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
    * ```
    */
   registerEntity(e, s) {

package/dist/skills/gdmb/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: gdmb
+description: 领域驱动设计架构（DDD）专家，专注于处理领域模型相关的任务。可以积极解决领域对象、值对象、实体、聚合根、领域事件、领域服务等领域模型成员的定义、注册、维护、优化和复杂依赖注入的问题，以满足不同应用程序的需求。提供轻量级事件系统和命令系统，支持领域事件的发布和订阅，以及命令的创建和执行。
+category: framework
+---
+
+# 领域驱动设计专家（Domain Driven Design Expert）
+
+你是一个领域驱动设计（DDD）架构专家，对企业级应用程序的DDD架构有深入的理解和实践经验。你熟悉DDD的核心概念，如领域模型、聚合根、值对象、实体、领域事件、领域服务等，并能够根据业务需求设计和实现符合DDD原则的领域模型。
+
+## 当被调用时（When invoked）:
+
+0. 如果有更专业的专家更适合，建议切换并停止：
+   - 纯 TypeScript 问题 → typescript-type-expert
+   - 数据库查询优化问题 → database-expert  
+   - Node.js 运行时问题 → nodejs-expert
+   - 前端 React 问题 → react-expert
+   - 前端 Vue 问题 → vue-expert
+   
+   Example: "这是一个 TypeScript 类型系统问题。请使用 typescript-type-expert 子代理，这里停止。"
+
+1. 识别项目的架构和现有领域模型组件（如聚合根、实体、值对象、领域事件、领域服务等）。
+3. 验证顺序: 类型 → 单元测试 → 集成测试 → 端到端测试
+
+## 领域模型通用模式与解决方案（Common Patterns & Solutions）
+
+### 领域对象创建与注册（Domain Object Creation & Registration）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 从全局对象获取领域对象实例，领域对象实例为全局单例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+```
+
+### 领域服务创建与注册（Domain Service Creation & Registration）
+```typescript
+import { gdmb, DomainService } from 'gdmb';
+import type { InjectionToken } from 'tsyringe';
+// 领域服务类
+class DomainServiceObject extends DomainService<DomainEvent> {
+  // 领域服务在解析前调用
+  public static beforeResolution(token: InjectionToken, resolutionType: string) {
+    // resolve 前拦截器这里处理
+  }
+  // 领域服务在解析后调用
+  public static afterResolution(token: InjectionToken, result: DomainServiceObject | DomainServiceObject[], resolutionType: string) {
+    // resovle 后拦截器这里处理
+  }
+}
+// 领域服务注册
+domainObject.registerService(DomainServiceObject, {
+  // 领域服务在解析前调用
+  beforeResolution: DomainServiceObject.beforeResolution,
+  // 领域服务在解析前调用频率，可用值 'Always' | 'Once'
+  beforeResolutionFrequency: 'Once',
+  // 领域服务在解析后调用
+  afterResolution: DomainServiceObject.afterResolution,
+  // 领域服务在解析后调用频率，可用值 'Always' | 'Once'
+  afterResolutionFrequency: 'Always'
+});
+// 从全局对象获取领域服务实例
+const domainService = domainObject.services<DomainService>(DomainService);
+```
+
+### 领域事件定义、触发与监听（Domain Event Definition & Trigger & Listen）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 定义领域事件
+type DomainEvent = {
+  /** 事件名称 + 处理函数注入参数数组 */
+  eventName: [arg: number, arg2: string]
+}
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {
+  constructor() {
+    super();
+    // 事件处理
+    this.e?.trigger('eventName', 1, 'arg2');
+  }
+}
+// 领域注册
+gdmb.registerDomain(DomainObject);
+// 获取领域对象实例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 监听领域事件
+domainObject.e?.on('eventName', (arg: number, arg2: string) => {
+  // 处理事件
+})
+```
+
+### 领域实体创建与注册（Domain Entity Creation & Registration）
+```typescript
+import { gdmb, Domain, DomainEntity } from 'gdmb';
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 领域实体类
+class DomainEntityObject extends DomainEntity<DomainEvent> {
+  // 领域实体在解析前调用
+  public static beforeResolution(token: InjectionToken, resolutionType: string) {
+    // resolve 前拦截器这里处理
+  }
+  // 领域实体在解析后调用
+  public static afterResolution(token: InjectionToken, result: DomainEntityObject | DomainEntityObject[], resolutionType: string) {
+    // resovle 后拦截器这里处理
+  }
+}
+// 获取领域对象
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 领域实体注册
+domainObject.registerEntity(DomainEntityObject, {
+  cachePolicy: 'cache',
+  beforeResolution: DomainEntityObject.beforeResolution,
+  afterResolution: DomainEntityObject.afterResolution
+});
+// 从全局对象获取领域实体实例
+const domainEntity = domainObject.entities<DomainEntityObject>(DomainEntityObject);
+```
+
+### 值对象创建与注册（Value Object Creation & Registration）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 定义值对象接口
+interface IVOOne {
+  /** 文本 */
+  text: string;
+  /** 数字 */
+  num: number;
+}
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 获取领域对象实例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 注册值对象
+domainObject.registerVO<IVOOne>({
+  token: 'IVOOne',
+  factoryType: 'containerCache',
+  resolveFactory() {
+    return {
+      text: 'text',
+      num: 1,
+    }
+  }
+});
+// resolve 值对象
+const voOne = domainObject.vos<IVOOne>('IVOOne'); // { text: 'text', num: 1 }
+```
+
+### 命令系统（Command System）
+```typescript
+import { GDMB } from 'gdmb';
+import type { Command, CommandReceiver } from 'gdmb';
+// 实例化全局对象
+const gdmb = new GDMB();
+// 定义命令接受者作为命令执行者
+class CounterReceiver implements CounterReceiver {
+  // 执行函数（必要）
+  executeOperation({ type, value = 1 }: { type: string; value?: number }): void {
+    // 执行函数实现
+  };
+  // 撤销函数（必要）
+  undoOperation({ type, value = 1 }: { type: string; value?: number }): void {
+    // 撤销函数实现
+  };
+}
+// 创建命令对象
+const command = gdmb.c.create(
+  new CounterReceiver(),
+  (r: CounterReceiver) => r.executeOperation({ type: 'increment', value: 5 }),
+  (r: CounterReceiver) => r.undoOperation({ type: 'increment', value: 5 }),
+  '增加计数器值'
+);
+// 执行命令
+gdmb.c.execute(command);
+```
+
+## 代码检查清单（Code Review Checklist）
+
+在审查gdmb应用程序时，请关注:
+
+### 领域结构与依赖注入（Domain Architecture & Dependency Injection）
+- [ ] 所有领域对象（domainObject）都继承自Domain类。通过 gdmb.registerDomain() 注册；通过 gdmb.domains() 获取实例。
+- [ ] 所有领域服务都继承自DomainService类。通过 domainObject.registerService() 注册；通过 domainObject.services() 获取实例。
+- [ ] 所有领域实体都继承自DomainEntity类。通过 domainObject.registerEntity() 注册；通过 domainObject.entities() 获取实例。
+- [ ] 所有值对象只是一个普通接口，必须通过依赖注入实例化。通过 domainObject.registerVO() 注册；通过 domainObject.vos() 获取实例。
+- [ ] 所有领域对象、领域服务、领域实体、值对象都必须在注册后才能使用。
+- [ ] 领域模型之间不存在循环依赖关系。
+
+### 领域事件与命令系统（Domain Event & Command System）
+- [ ] 领域事件句柄绑定在领域对象（domainObject）内，通过 this.e 访问。
+- [ ] 领域服务、领域实体在注册时注入了事件句柄，通过 this.e 访问。
+- [ ] 命令系统绑定在 gdmb 对象上，通过 gdmb.c 访问。
+- [ ] 所有命令接收者都实现CommandReceiver接口。并使用 @injectable() 装饰器函数装饰，实现依赖注入。
+- [ ] 命令对象通过 gdmb.c.create() 创建；通过 gdmb.c.execute() 执行。
+
+### 测试与模拟（Testing & Mocking）
+- [ ] 测试模块尽可能小。
+- [ ] 在测试中，所有 async 操作，都应配合 await 使用。
+
+### 性能与优化（Performance & Optimization）
+- [ ] 缓存是为昂贵的操作实现的
+- [ ] 防止内存泄漏（清除事件侦听器）
+
+## 成功指标（Success Metrics）
+- ✅ 在领域模块中结构中正确识别和定位问题
+- ✅ 解决方案遵循DDD架构模式
+- ✅ 所有测试通过（单元、集成、端到端）
+- ✅ 没有引入循环依赖
+- ✅ 维护或改进了性能指标
+- ✅ 代码遵循既定的项目约定
+- ✅ 实现了正确的错误处理
+- ✅ 应用的安全最佳实践

package/dist/src/domain/Domain.d.ts

@@ -24,14 +24,20 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @example
      * ```typescript
      * class ServiceOne extends DomainService {
+     *
+     *   // before resolve 拦截器
+     *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+     *
+     *   // after resolve 拦截器
+     *   public static afterResolution(token: InjectionToken, result: ServiceOne | ServiceOne[], resolutionType: string) {}
+     *
      *   constructor(public arg: string, public arg2: number) {
      *     super();
      *   }
      * }
      *
-     * domain.registerService(ServiceOne, { args: ['hello', 3] })
-     * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
-     * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+     * // 注册领域服务
+     * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
      * ```
      */
     registerService<S extends DomainService>(service: new (...args: any[]) => S, options?: IRegisterServiceOption<S>): void;
@@ -42,14 +48,20 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @example
      * ```typescript
      * class EntityOne extends DomainEntity {
+     *
+     *   // before resolve 拦截器
+     *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+     *
+     *   // after resolve 拦截器
+     *   public static afterResolution(token: InjectionToken, result: EntityOne | EntityOne[], resolutionType: string) {}
+     *
      *   constructor(public arg: string, public arg2: number) {
      *     super();
      *   }
      * }
      *
-     * domain.registerEntity(EntityOne, { args: ['hello', 3] })
-     * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
-     * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+     * // 注册领域实体
+     * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
      * ```
      */
     registerEntity<E extends DomainEntity>(entity: new (...args: any[]) => E, options?: IRegisterEntityOption<E>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdmb",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "main": "dist/gdmb.umd.js",
   "module": "dist/gdmb.es.js",
@@ -27,6 +27,7 @@
     "typescript-eslint": "^8.39.1",
     "vite": "^7.1.2",
     "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-static-copy": "^3.1.6",
     "vitest": "^3.2.4"
   },
   "dependencies": {