@zucker-framework/event 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1034 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/entity-events.ts
+var EntityEventType = /* @__PURE__ */ (function(EntityEventType2) {
+  EntityEventType2["CREATE"] = "create";
+  EntityEventType2["MODIFY"] = "modify";
+  EntityEventType2["DELETE"] = "delete";
+  EntityEventType2["SAVE"] = "save";
+  EntityEventType2["QUERY"] = "query";
+  EntityEventType2["UPDATE"] = "modify";
+  return EntityEventType2;
+})({});
+var EntityEventPhase = /* @__PURE__ */ (function(EntityEventPhase2) {
+  EntityEventPhase2["PREPARE"] = "prepare";
+  EntityEventPhase2["BEFORE"] = "before";
+  EntityEventPhase2["AFTER"] = "after";
+  return EntityEventPhase2;
+})({});
+var ALL_EVENT_PHASES = [
+  "prepare",
+  "before",
+  "after"
+];
+function createEntityEvent(type, phase, entityType, entity, before) {
+  let _cancelled = false;
+  let _cancelReason;
+  return {
+    type,
+    phase,
+    entityType,
+    entity,
+    timestamp: Date.now(),
+    before,
+    get cancelled() {
+      return _cancelled;
+    },
+    cancel(reason) {
+      _cancelled = true;
+      _cancelReason = reason;
+    },
+    get cancelReason() {
+      return _cancelReason;
+    }
+  };
+}
+__name(createEntityEvent, "createEntityEvent");
+function getEntityEventName(entityType, type, phase) {
+  return `entity/${entityType}/${type}/${phase}`;
+}
+__name(getEntityEventName, "getEntityEventName");
+
+// src/entity-event-listener.ts
+var CreatorEventListener = class {
+  static {
+    __name(this, "CreatorEventListener");
+  }
+  getCurrentUser;
+  order = -Infinity;
+  constructor(getCurrentUser) {
+    this.getCurrentUser = getCurrentUser;
+  }
+  async onEvent(event) {
+    if (event.phase !== EntityEventPhase.PREPARE) return;
+    const user = this.getCurrentUser();
+    if (!user) return;
+    const entities = Array.isArray(event.entity) ? event.entity : [
+      event.entity
+    ];
+    const now = /* @__PURE__ */ new Date();
+    const isCreate = event.type === EntityEventType.CREATE || event.type === EntityEventType.SAVE;
+    const isModify = event.type === EntityEventType.MODIFY || event.type === EntityEventType.SAVE;
+    for (const entity of entities) {
+      if (typeof entity !== "object" || entity === null) continue;
+      const rec = entity;
+      if (isCreate) {
+        rec.creatorId ??= user.id;
+        if (user.name !== void 0) {
+          rec.creatorName ??= user.name;
+        }
+        rec.createdAt ??= now;
+      }
+      if (isModify || isCreate) {
+        if (rec.modifierId == null || rec.modifierId === "" || rec.modifierId === void 0) {
+          rec.modifierId = user.id;
+        }
+        if (user.name !== void 0) {
+          if (rec.modifierName == null || rec.modifierName === "" || rec.modifierName === void 0) {
+            rec.modifierName = user.name;
+          }
+        }
+        rec.updatedAt ??= now;
+      }
+    }
+  }
+};
+var CompositeEventListener = class {
+  static {
+    __name(this, "CompositeEventListener");
+  }
+  listeners = [];
+  addListener(listener) {
+    this.listeners.push(listener);
+    this.listeners.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  removeListener(listener) {
+    const idx = this.listeners.indexOf(listener);
+    if (idx >= 0) this.listeners.splice(idx, 1);
+  }
+  async onEvent(event) {
+    for (const listener of this.listeners) {
+      await listener.onEvent(event);
+    }
+  }
+  getListeners() {
+    return this.listeners;
+  }
+};
+
+// src/topic-event-bus.ts
+import { Logger } from "@nestjs/common";
+
+// src/subscribe.decorator.ts
+var SUBSCRIBE_KEY = "zucker:event:subscribe";
+var SUBSCRIBE_METHODS_KEY = "zucker:event:subscribeMethods";
+var SubscribeFeature = /* @__PURE__ */ (function(SubscribeFeature2) {
+  SubscribeFeature2["LOCAL"] = "local";
+  SubscribeFeature2["CLUSTER"] = "cluster";
+  SubscribeFeature2["SHARED"] = "shared";
+  SubscribeFeature2["BROKER"] = "broker";
+  return SubscribeFeature2;
+})({});
+function Subscribe(topicsOrOptions) {
+  let options;
+  if (typeof topicsOrOptions === "string") {
+    options = {
+      topics: [
+        topicsOrOptions
+      ]
+    };
+  } else if (Array.isArray(topicsOrOptions)) {
+    options = {
+      topics: topicsOrOptions
+    };
+  } else {
+    options = topicsOrOptions;
+  }
+  return (target, propertyKey, _descriptor) => {
+    const metadata = {
+      ...options,
+      id: options.id ?? String(propertyKey),
+      features: options.features ?? [
+        "local"
+      ],
+      priority: options.priority ?? Infinity
+    };
+    Reflect.defineMetadata(SUBSCRIBE_KEY, metadata, target, propertyKey);
+    const existing = Reflect.getMetadata(SUBSCRIBE_METHODS_KEY, target.constructor) ?? [];
+    existing.push({
+      propertyKey: String(propertyKey),
+      options: metadata
+    });
+    Reflect.defineMetadata(SUBSCRIBE_METHODS_KEY, existing, target.constructor);
+  };
+}
+__name(Subscribe, "Subscribe");
+function getSubscriptions(target) {
+  return Reflect.getMetadata(SUBSCRIBE_METHODS_KEY, target) ?? [];
+}
+__name(getSubscriptions, "getSubscriptions");
+
+// src/topic-event-bus.ts
+function createTopicPayload(topic, payload, headers) {
+  const headerMap = headers instanceof Map ? headers : new Map(Object.entries(headers ?? {}));
+  return {
+    topic,
+    payload,
+    headers: headerMap
+  };
+}
+__name(createTopicPayload, "createTopicPayload");
+var SubscriptionBuilder = {
+  /**
+  * Quick factory — 参考 jetlinks Subscription.of(subscriberId, topic, ...features)
+  */
+  of(subscriberId, topics, ...features) {
+    return {
+      subscriberId,
+      topics: Array.isArray(topics) ? topics : [
+        topics
+      ],
+      features: features.length > 0 ? features : [
+        SubscribeFeature.LOCAL
+      ]
+    };
+  },
+  /**
+  * Builder pattern — 参考 jetlinks Subscription.builder()
+  */
+  builder() {
+    const info = {
+      subscriberId: "",
+      topics: [],
+      features: [
+        SubscribeFeature.LOCAL
+      ]
+    };
+    return {
+      subscriberId(id) {
+        info.subscriberId = id;
+        return this;
+      },
+      topics(...topics) {
+        info.topics = topics;
+        return this;
+      },
+      features(...features) {
+        info.features = features;
+        return this;
+      },
+      priority(p) {
+        info.priority = p;
+        return this;
+      },
+      build() {
+        return {
+          ...info
+        };
+      }
+    };
+  }
+};
+function normalizeTopic(topic) {
+  if (topic.includes("#") || topic.includes("+")) {
+    return topic.replace(/#/g, "**").replace(/\+/g, "*");
+  }
+  return topic;
+}
+__name(normalizeTopic, "normalizeTopic");
+var DefaultTopicEventBus = class _DefaultTopicEventBus {
+  static {
+    __name(this, "DefaultTopicEventBus");
+  }
+  logger = new Logger(_DefaultTopicEventBus.name);
+  handlersByPattern = /* @__PURE__ */ new Map();
+  async publish(topic, payload, headers) {
+    if (!topic) {
+      throw new Error("Topic must not be empty");
+    }
+    const topicPayload = createTopicPayload(topic, payload, headers);
+    const matchingHandlers = [];
+    for (const [pattern, handlers] of this.handlersByPattern) {
+      if (matchesTopic(pattern, topic)) {
+        matchingHandlers.push(...handlers);
+      }
+    }
+    matchingHandlers.sort((a, b) => a.priority - b.priority);
+    for (const { handler } of matchingHandlers) {
+      try {
+        await handler(topicPayload);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Subscriber error on topic "${topic}": ${errorMsg}`);
+      }
+    }
+  }
+  subscribe(subscriptionOrPattern, handler, priority) {
+    if (typeof subscriptionOrPattern === "string") {
+      if (!subscriptionOrPattern) {
+        throw new Error("Topic pattern must not be empty");
+      }
+      return this._subscribeSingle(normalizeTopic(subscriptionOrPattern), wrapLegacyHandler(handler), priority ?? Infinity);
+    }
+    const sub = subscriptionOrPattern;
+    if (!sub.subscriberId) {
+      throw new Error("SubscriptionInfo.subscriberId must not be empty");
+    }
+    if (!sub.topics || sub.topics.length === 0) {
+      throw new Error("SubscriptionInfo.topics must not be empty");
+    }
+    const resolvedPriority = sub.priority ?? Infinity;
+    const subscriptions = [];
+    for (const rawTopic of sub.topics) {
+      const topic = normalizeTopic(rawTopic);
+      subscriptions.push(this._subscribeSingle(topic, handler, resolvedPriority));
+    }
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => {
+        for (const s of subscriptions) {
+          s.unsubscribe();
+        }
+      }, "unsubscribe")
+    };
+  }
+  _subscribeSingle(topicPattern, handler, priority) {
+    const entry = {
+      handler,
+      priority
+    };
+    const handlers = this.handlersByPattern.get(topicPattern) ?? [];
+    handlers.push(entry);
+    this.handlersByPattern.set(topicPattern, handlers);
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => {
+        const list = this.handlersByPattern.get(topicPattern);
+        if (list) {
+          const idx = list.indexOf(entry);
+          if (idx >= 0) list.splice(idx, 1);
+          if (list.length === 0) this.handlersByPattern.delete(topicPattern);
+        }
+      }, "unsubscribe")
+    };
+  }
+  /**
+  * Remove all handlers — used during module shutdown to prevent leaks.
+  */
+  removeAllListeners() {
+    this.handlersByPattern.clear();
+  }
+};
+function wrapLegacyHandler(handler) {
+  if (handler.length >= 2) {
+    return (msg) => handler(msg.payload, msg.topic);
+  }
+  return handler;
+}
+__name(wrapLegacyHandler, "wrapLegacyHandler");
+var MATCH_CACHE_MAX_SIZE = 1024;
+var matchCache = /* @__PURE__ */ new Map();
+function matchesTopic(pattern, topic) {
+  if (!pattern || !topic) return false;
+  const cacheKey = pattern + "\0" + topic;
+  const cached = matchCache.get(cacheKey);
+  if (cached !== void 0) {
+    matchCache.delete(cacheKey);
+    matchCache.set(cacheKey, cached);
+    return cached;
+  }
+  const patternParts = pattern.split("/");
+  const topicParts = topic.split("/");
+  const result = matchParts(patternParts, 0, topicParts, 0);
+  if (matchCache.size >= MATCH_CACHE_MAX_SIZE) {
+    const firstKey = matchCache.keys().next().value;
+    matchCache.delete(firstKey);
+  }
+  matchCache.set(cacheKey, result);
+  return result;
+}
+__name(matchesTopic, "matchesTopic");
+function matchParts(pattern, pi, topic, ti) {
+  while (pi < pattern.length && ti < topic.length) {
+    if (pattern[pi] === "**") {
+      if (pi === pattern.length - 1) return true;
+      for (let i = ti; i <= topic.length; i++) {
+        if (matchParts(pattern, pi + 1, topic, i)) return true;
+      }
+      return false;
+    }
+    if (pattern[pi] === "*") {
+      pi++;
+      ti++;
+      continue;
+    }
+    if (pattern[pi].includes(",")) {
+      const alternatives = pattern[pi].split(",");
+      if (!alternatives.includes(topic[ti])) {
+        return false;
+      }
+      pi++;
+      ti++;
+      continue;
+    }
+    if (pattern[pi] !== topic[ti]) {
+      return false;
+    }
+    pi++;
+    ti++;
+  }
+  while (pi < pattern.length && pattern[pi] === "**") pi++;
+  return pi === pattern.length && ti === topic.length;
+}
+__name(matchParts, "matchParts");
+
+// src/async-event.ts
+function createAsyncEvent(payload) {
+  const firstTasks = [];
+  const asyncTasks = [];
+  let _hasListener = false;
+  let _firstTransform;
+  let _asyncTransform;
+  const event = {
+    payload,
+    timestamp: Date.now(),
+    handled: false,
+    markHandled() {
+      this.handled = true;
+    },
+    first(fn) {
+      _hasListener = true;
+      firstTasks.unshift(fn);
+    },
+    async(fn) {
+      _hasListener = true;
+      asyncTasks.push(fn);
+    },
+    transformFirst(mapper) {
+      _hasListener = true;
+      const prev = _firstTransform;
+      _firstTransform = prev ? (p) => mapper(prev(p)) : mapper;
+    },
+    transform(mapper) {
+      _hasListener = true;
+      const prev = _asyncTransform;
+      _asyncTransform = prev ? (p) => mapper(prev(p)) : mapper;
+    },
+    get hasListener() {
+      return _hasListener;
+    },
+    async getAsync() {
+      let firstChain = (async () => {
+        for (const fn of firstTasks) {
+          await fn();
+        }
+      })();
+      if (_firstTransform) {
+        firstChain = _firstTransform(firstChain);
+      }
+      await firstChain;
+      let asyncChain = (async () => {
+        for (const fn of asyncTasks) {
+          await fn();
+        }
+      })();
+      if (_asyncTransform) {
+        asyncChain = _asyncTransform(asyncChain);
+      }
+      await asyncChain;
+    }
+  };
+  return event;
+}
+__name(createAsyncEvent, "createAsyncEvent");
+
+// src/validate-event-listener.ts
+import { validate } from "class-validator";
+import { plainToInstance } from "class-transformer";
+var CREATE_GROUP = "create";
+var UPDATE_GROUP = "update";
+var SAVE_GROUP = "save";
+var ValidateEventListener = class {
+  static {
+    __name(this, "ValidateEventListener");
+  }
+  entityClass;
+  options;
+  constructor(entityClass, options) {
+    this.entityClass = entityClass;
+    this.options = options;
+  }
+  async onEvent(event) {
+    if (event.phase !== EntityEventPhase.PREPARE) return;
+    if (this.options?.skipTypes?.includes(event.type)) return;
+    const groups = this.options?.groups ?? this.resolveGroups(event.type);
+    const skipMissing = this.options?.skipMissingProperties ?? event.type === EntityEventType.MODIFY;
+    const entities = Array.isArray(event.entity) ? event.entity : [
+      event.entity
+    ];
+    for (const entity of entities) {
+      if (typeof entity !== "object" || entity === null) continue;
+      const instance = plainToInstance(this.entityClass, entity);
+      const errors = await validate(instance, {
+        skipMissingProperties: skipMissing,
+        groups: groups.length > 0 ? groups : void 0,
+        whitelist: false,
+        forbidNonWhitelisted: false
+      });
+      if (errors.length > 0) {
+        const message = formatValidationErrors(errors);
+        event.cancel(`Validation failed: ${message}`);
+        return;
+      }
+    }
+  }
+  /**
+  * 根据事件类型解析默认的校验分组
+  */
+  resolveGroups(type) {
+    switch (type) {
+      case EntityEventType.CREATE:
+        return [
+          CREATE_GROUP
+        ];
+      case EntityEventType.SAVE:
+        return [
+          CREATE_GROUP,
+          SAVE_GROUP
+        ];
+      case EntityEventType.MODIFY:
+        return [
+          UPDATE_GROUP
+        ];
+      default:
+        return [];
+    }
+  }
+};
+function formatValidationErrors(errors) {
+  return errors.map((e) => {
+    const constraints = e.constraints ? Object.values(e.constraints).join(", ") : "invalid";
+    return `${e.property}: ${constraints}`;
+  }).join("; ");
+}
+__name(formatValidationErrors, "formatValidationErrors");
+
+// src/enable-entity-event.ts
+var ENTITY_EVENT_CONFIG_KEY = "zucker:event:entityEventConfig";
+var DEFAULT_CONFIG = {
+  [EntityEventType.CREATE]: true,
+  [EntityEventType.MODIFY]: true,
+  [EntityEventType.DELETE]: true,
+  [EntityEventType.SAVE]: true,
+  [EntityEventType.QUERY]: false
+};
+function EnableEntityEvent(config) {
+  return function(target) {
+    const merged = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    Reflect.defineMetadata(ENTITY_EVENT_CONFIG_KEY, merged, target);
+  };
+}
+__name(EnableEntityEvent, "EnableEntityEvent");
+function getEntityEventConfig(target) {
+  return Reflect.getMetadata(ENTITY_EVENT_CONFIG_KEY, target) ?? DEFAULT_CONFIG;
+}
+__name(getEntityEventConfig, "getEntityEventConfig");
+function isEntityEventEnabled(target, type) {
+  const config = getEntityEventConfig(target);
+  return config[type] !== false;
+}
+__name(isEntityEventEnabled, "isEntityEventEnabled");
+
+// src/entity-event-listener-configure.ts
+import { Injectable } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function toKey(entityType, eventType, phase) {
+  if (!eventType) return entityType;
+  return phase ? `${entityType}:${eventType}:${phase}` : `${entityType}:${eventType}`;
+}
+__name(toKey, "toKey");
+var EntityEventListenerConfigure = class {
+  static {
+    __name(this, "EntityEventListenerConfigure");
+  }
+  enabled = /* @__PURE__ */ new Map();
+  disabled = /* @__PURE__ */ new Map();
+  enable(entityType, eventType, ...phases) {
+    if (!eventType) {
+      const key = toKey(entityType);
+      this.enabled.set(key, true);
+      this.disabled.delete(key);
+      return;
+    }
+    const targetPhases = phases.length > 0 ? phases : ALL_EVENT_PHASES;
+    for (const phase of targetPhases) {
+      const key = toKey(entityType, eventType, phase);
+      this.enabled.set(key, true);
+      this.disabled.delete(key);
+    }
+    const typeKey = toKey(entityType, eventType);
+    this.enabled.set(typeKey, true);
+    this.disabled.delete(typeKey);
+  }
+  disable(entityType, eventType, ...phases) {
+    if (!eventType) {
+      const key = toKey(entityType);
+      this.disabled.set(key, true);
+      this.enabled.delete(key);
+      return;
+    }
+    const targetPhases = phases.length > 0 ? phases : ALL_EVENT_PHASES;
+    for (const phase of targetPhases) {
+      const key = toKey(entityType, eventType, phase);
+      this.disabled.set(key, true);
+      this.enabled.delete(key);
+    }
+    if (phases.length === 0) {
+      const typeKey = toKey(entityType, eventType);
+      this.disabled.set(typeKey, true);
+      this.enabled.delete(typeKey);
+    }
+  }
+  isEnabled(entityType, eventType, phase) {
+    const entityKey = toKey(entityType);
+    if (this.disabled.has(entityKey)) return false;
+    if (!eventType) {
+      return this.enabled.has(entityKey) || !this.disabled.has(entityKey);
+    }
+    if (phase) {
+      const phaseKey = toKey(entityType, eventType, phase);
+      if (this.disabled.has(phaseKey)) return false;
+      if (this.enabled.has(phaseKey)) return true;
+    }
+    const typeKey = toKey(entityType, eventType);
+    if (this.disabled.has(typeKey)) return false;
+    if (this.enabled.has(typeKey)) return true;
+    return true;
+  }
+  /**
+  * 清除指定实体的运行时覆盖配置
+  */
+  reset(entityType, eventType, phase) {
+    const key = toKey(entityType, eventType, phase);
+    this.enabled.delete(key);
+    this.disabled.delete(key);
+  }
+  /**
+  * 清除所有运行时覆盖配置
+  */
+  resetAll() {
+    this.enabled.clear();
+    this.disabled.clear();
+  }
+};
+EntityEventListenerConfigure = _ts_decorate([
+  Injectable()
+], EntityEventListenerConfigure);
+
+// src/entity-event-listener-customizer.ts
+var ENTITY_EVENT_LISTENER_CUSTOMIZER = "ENTITY_EVENT_LISTENER_CUSTOMIZER";
+
+// src/entity-event-helper.ts
+import { AsyncLocalStorage } from "async_hooks";
+var fireEventStorage = new AsyncLocalStorage();
+function isDoFireEvent(defaultIfEmpty = true) {
+  const store = fireEventStorage.getStore();
+  return store ? store.flag : defaultIfEmpty;
+}
+__name(isDoFireEvent, "isDoFireEvent");
+async function withoutFireEvent(fn) {
+  return fireEventStorage.run({
+    flag: false
+  }, fn);
+}
+__name(withoutFireEvent, "withoutFireEvent");
+async function withFireEvent(fn) {
+  return fireEventStorage.run({
+    flag: true
+  }, fn);
+}
+__name(withFireEvent, "withFireEvent");
+async function tryFireEvent(task) {
+  if (isDoFireEvent(true)) {
+    await task();
+  }
+}
+__name(tryFireEvent, "tryFireEvent");
+function createSingleEntityEvent(type, phase, entityType, entity) {
+  return createEntityEvent(type, phase, entityType, entity);
+}
+__name(createSingleEntityEvent, "createSingleEntityEvent");
+function createBatchEntityEvent(type, phase, entityType, entities) {
+  return createEntityEvent(type, phase, entityType, entities);
+}
+__name(createBatchEntityEvent, "createBatchEntityEvent");
+function createModifyEntityEvent(phase, entityType, before, after) {
+  if (before.length === 0) {
+    return null;
+  }
+  return createEntityEvent(EntityEventType.MODIFY, phase, entityType, after, before);
+}
+__name(createModifyEntityEvent, "createModifyEntityEvent");
+function createCreatedEntityEvent(phase, entityType, entities) {
+  return createEntityEvent(EntityEventType.CREATE, phase, entityType, entities);
+}
+__name(createCreatedEntityEvent, "createCreatedEntityEvent");
+function createDeletedEntityEvent(phase, entityType, entities) {
+  return createEntityEvent(EntityEventType.DELETE, phase, entityType, entities);
+}
+__name(createDeletedEntityEvent, "createDeletedEntityEvent");
+function createSavedEntityEvent(phase, entityType, entities) {
+  return createEntityEvent(EntityEventType.SAVE, phase, entityType, entities);
+}
+__name(createSavedEntityEvent, "createSavedEntityEvent");
+
+// src/event.module.ts
+import { Module, Global, Inject, Optional } from "@nestjs/common";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var TOPIC_EVENT_BUS = "TOPIC_EVENT_BUS";
+var ZuckerEventModule = class _ZuckerEventModule {
+  static {
+    __name(this, "ZuckerEventModule");
+  }
+  listenerConfigure;
+  eventBus;
+  customizers;
+  constructor(listenerConfigure, eventBus, customizers) {
+    this.listenerConfigure = listenerConfigure;
+    this.eventBus = eventBus;
+    this.customizers = customizers;
+  }
+  /**
+  * 模块初始化时执行所有 EntityEventListenerCustomizer
+  * 通过 EntityEventListenerCustomizer 进行运行时配置
+  */
+  onModuleInit() {
+    if (this.customizers) {
+      for (const customizer of this.customizers) {
+        customizer.customize(this.listenerConfigure);
+      }
+    }
+  }
+  onModuleDestroy() {
+    if (this.eventBus instanceof DefaultTopicEventBus) {
+      this.eventBus.removeAllListeners();
+    }
+  }
+  static forRoot() {
+    return {
+      module: _ZuckerEventModule,
+      global: true,
+      providers: [
+        {
+          provide: TOPIC_EVENT_BUS,
+          useClass: DefaultTopicEventBus
+        },
+        EntityEventListenerConfigure
+      ],
+      exports: [
+        TOPIC_EVENT_BUS,
+        EntityEventListenerConfigure
+      ]
+    };
+  }
+};
+ZuckerEventModule = _ts_decorate2([
+  Global(),
+  Module({}),
+  _ts_param(1, Inject(TOPIC_EVENT_BUS)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(ENTITY_EVENT_LISTENER_CUSTOMIZER)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof EntityEventListenerConfigure === "undefined" ? Object : EntityEventListenerConfigure,
+    typeof TopicEventBus === "undefined" ? Object : TopicEventBus,
+    Array
+  ])
+], ZuckerEventModule);
+
+// src/event-store.ts
+var EVENT_STORE = "EVENT_STORE";
+
+// src/unified-event-bus.ts
+import { Injectable as Injectable2, Optional as Optional2, Inject as Inject2, Logger as Logger2 } from "@nestjs/common";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var CLUSTER_TRANSPORT = /* @__PURE__ */ Symbol("CLUSTER_TRANSPORT");
+var UnifiedEventBus = class _UnifiedEventBus {
+  static {
+    __name(this, "UnifiedEventBus");
+  }
+  cluster;
+  logger = new Logger2(_UnifiedEventBus.name);
+  localBus;
+  constructor(localBus, cluster) {
+    this.cluster = cluster;
+    this.localBus = localBus;
+    if (this.cluster) {
+      this.cluster.onRemoteEvent((topic, payload) => {
+        this.localBus.publish(topic, payload).catch((err) => {
+          this.logger.error(`Failed to replay remote event [${topic}]: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+  * 发布事件（本地 + 集群）
+  * @param topic 事件主题
+  * @param payload 事件负载
+  */
+  async publish(topic, payload) {
+    await this.localBus.publish(topic, payload);
+    if (this.cluster) {
+      this.cluster.broadcast(topic, payload).catch((err) => {
+        this.logger.warn(`Cluster broadcast failed for [${topic}]: ${err}`);
+      });
+    }
+  }
+  /**
+  * 仅发布到本地（不广播到集群）
+  * 适用于访问日志等高频、无需跨节点的事件
+  */
+  async publishLocal(topic, payload) {
+    await this.localBus.publish(topic, payload);
+  }
+  /**
+  * 订阅事件（支持 wildcard 模式）
+  * @param pattern 主题匹配模式（支持 * 和 **）
+  * @param handler 事件处理函数
+  */
+  subscribe(pattern, handler) {
+    return this.localBus.subscribe(pattern, handler);
+  }
+  /**
+  * 发布并等待所有处理完成
+  * 用于需要确保所有 listener 执行完毕的场景（如事务内事件）
+  */
+  async publishAndWait(topic, payload) {
+    await this.localBus.publish(topic, payload);
+  }
+};
+UnifiedEventBus = _ts_decorate3([
+  Injectable2(),
+  _ts_param2(0, Inject2(TOPIC_EVENT_BUS)),
+  _ts_param2(1, Optional2()),
+  _ts_param2(1, Inject2(CLUSTER_TRANSPORT)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof TopicEventBus === "undefined" ? Object : TopicEventBus,
+    typeof ClusterTransport === "undefined" ? Object : ClusterTransport
+  ])
+], UnifiedEventBus);
+
+// src/operation-hooks.ts
+import { Logger as Logger3 } from "@nestjs/common";
+function matchesOperation(pattern, operation) {
+  if (pattern === "*") return true;
+  if (pattern === operation) return true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return operation.startsWith(prefix + ".") || operation === prefix;
+  }
+  if (pattern.endsWith(".**")) {
+    const prefix = pattern.slice(0, -3);
+    return operation.startsWith(prefix + ".") || operation === prefix;
+  }
+  return false;
+}
+__name(matchesOperation, "matchesOperation");
+var OperationHookRegistry = class _OperationHookRegistry {
+  static {
+    __name(this, "OperationHookRegistry");
+  }
+  logger = new Logger3(_OperationHookRegistry.name);
+  hooks = [];
+  /**
+  * 注册操作 hook
+  * @param operation 操作名称模式（支持 * 和 ** 通配符）
+  * @param phase 执行阶段
+  * @param handler hook 处理函数
+  * @param options 可选配置
+  * @returns 取消注册的函数
+  */
+  register(operation, phase, handler, options) {
+    const hook = {
+      operation,
+      phase,
+      handler,
+      priority: options?.priority ?? 0,
+      name: options?.name
+    };
+    this.hooks.push(hook);
+    this.hooks.sort((a, b) => b.priority - a.priority);
+    return () => {
+      const idx = this.hooks.indexOf(hook);
+      if (idx !== -1) this.hooks.splice(idx, 1);
+    };
+  }
+  /**
+  * 创建操作上下文
+  */
+  createContext(operation, data) {
+    return {
+      operation,
+      data,
+      cancelled: false,
+      cancelReason: void 0,
+      result: void 0,
+      attributes: /* @__PURE__ */ new Map(),
+      cancel(reason) {
+        this.cancelled = true;
+        this.cancelReason = reason;
+      }
+    };
+  }
+  /**
+  * 执行 before 阶段的所有 hook
+  * 如果任意 hook 取消了操作，后续 hook 不再执行
+  */
+  async executeBefore(ctx) {
+    await this.executePhase(ctx, "before");
+  }
+  /**
+  * 执行 after 阶段的所有 hook
+  */
+  async executeAfter(ctx) {
+    await this.executePhase(ctx, "after");
+  }
+  async executePhase(ctx, phase) {
+    const matching = this.hooks.filter((h) => h.phase === phase && matchesOperation(h.operation, ctx.operation));
+    for (const hook of matching) {
+      if (phase === "before" && ctx.cancelled) break;
+      try {
+        await hook.handler(ctx);
+      } catch (error) {
+        const hookName = hook.name ?? hook.operation;
+        this.logger.error(`Hook "${hookName}" (${phase}) failed for operation "${ctx.operation}": ${error}`);
+        if (phase === "before") {
+          ctx.cancel(`Hook "${hookName}" failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  }
+  /**
+  * 获取已注册的 hook 数量
+  */
+  get size() {
+    return this.hooks.length;
+  }
+  /**
+  * 清除所有 hook
+  */
+  clear() {
+    this.hooks.length = 0;
+  }
+};
+export {
+  ALL_EVENT_PHASES,
+  CLUSTER_TRANSPORT,
+  CREATE_GROUP,
+  CompositeEventListener,
+  CreatorEventListener,
+  DefaultTopicEventBus,
+  ENTITY_EVENT_CONFIG_KEY,
+  ENTITY_EVENT_LISTENER_CUSTOMIZER,
+  EVENT_STORE,
+  EnableEntityEvent,
+  EntityEventListenerConfigure,
+  EntityEventPhase,
+  EntityEventType,
+  OperationHookRegistry,
+  SAVE_GROUP,
+  SUBSCRIBE_KEY,
+  SUBSCRIBE_METHODS_KEY,
+  Subscribe,
+  SubscribeFeature,
+  SubscriptionBuilder,
+  TOPIC_EVENT_BUS,
+  UPDATE_GROUP,
+  UnifiedEventBus,
+  ValidateEventListener,
+  ZuckerEventModule,
+  createAsyncEvent,
+  createBatchEntityEvent,
+  createCreatedEntityEvent,
+  createDeletedEntityEvent,
+  createEntityEvent,
+  createModifyEntityEvent,
+  createSavedEntityEvent,
+  createSingleEntityEvent,
+  createTopicPayload,
+  getEntityEventConfig,
+  getEntityEventName,
+  getSubscriptions,
+  isDoFireEvent,
+  isEntityEventEnabled,
+  matchesTopic,
+  tryFireEvent,
+  withFireEvent,
+  withoutFireEvent
+};