@cosmneo/onion-lasagna 0.2.0 → 0.3.0

package/dist/events/handler/index.d.ts

@@ -0,0 +1,153 @@
+import { SchemaAdapter, InferOutput } from '../../http/schema/types.js';
+import { E as EventHandlerDefinition, c as EventRouterConfig, d as EventRouterDefaults, e as EventRouterDefinition, D as DeepMergeTwo, l as DeepMergeAll } from '../../event-router-definition.type-D8CG-kjZ.js';
+export { a as EventHandlerDocumentation, b as EventRouterEntry, f as EventRouterKeys, F as FlattenEventRouter, G as GetEventHandler, h as InferEventContext, g as InferEventPayload, I as InferEventType, k as collectEventHandlers, i as isEventHandlerDefinition, j as isEventRouterDefinition } from '../../event-router-definition.type-D8CG-kjZ.js';
+
+/**
+ * @fileoverview Factory function for creating event handler definitions.
+ *
+ * The `defineEventHandler` function is the main entry point for defining
+ * event handlers. It mirrors `defineRoute` from the HTTP layer but is
+ * tailored for asynchronous event processing.
+ *
+ * @module events/handler/define-event-handler
+ */
+
+/**
+ * Input for defineEventHandler.
+ *
+ * @example Basic handler with payload schema
+ * ```typescript
+ * defineEventHandler({
+ *   eventType: 'ticket.created',
+ *   payload: zodSchema(z.object({ ticketId: z.string() })),
+ *   docs: { summary: 'Handle ticket creation', tags: ['ticket'] },
+ * })
+ * ```
+ *
+ * @example With context schema
+ * ```typescript
+ * defineEventHandler({
+ *   eventType: 'order.shipped',
+ *   payload: zodSchema(orderShippedSchema),
+ *   context: zodSchema(eventMetadataSchema),
+ * })
+ * ```
+ */
+interface DefineEventHandlerInput<TEventType extends string, TPayload extends SchemaAdapter | undefined = undefined, TContext extends SchemaAdapter | undefined = undefined> {
+    /** Event type string used for routing (e.g., 'ticket.created'). */
+    readonly eventType: TEventType;
+    /** Payload validation schema. */
+    readonly payload?: TPayload;
+    /** Context validation schema (validates event metadata). */
+    readonly context?: TContext;
+    /** Handler documentation. */
+    readonly docs?: {
+        readonly summary?: string;
+        readonly description?: string;
+        readonly tags?: readonly string[];
+        readonly deprecated?: boolean;
+    };
+}
+type ResolvePayload<T> = T extends SchemaAdapter ? InferOutput<T> : undefined;
+type ResolveContext<T> = T extends SchemaAdapter ? InferOutput<T> : undefined;
+/**
+ * Creates an event handler definition from the provided configuration.
+ *
+ * This is the main entry point for defining event handlers. The resulting
+ * definition can be used for type-safe handler registration, payload
+ * validation, and documentation generation.
+ *
+ * @param input - Event handler configuration with optional schemas
+ * @returns A frozen EventHandlerDefinition object with full type information
+ */
+declare function defineEventHandler<TEventType extends string, TPayload extends SchemaAdapter | undefined = undefined, TContext extends SchemaAdapter | undefined = undefined>(input: DefineEventHandlerInput<TEventType, TPayload, TContext>): EventHandlerDefinition<TEventType, ResolvePayload<TPayload>, ResolveContext<TContext>>;
+
+/**
+ * @fileoverview Factory function for creating event router definitions.
+ *
+ * The `defineEventRouter` function groups event handlers into a hierarchical
+ * structure with optional router-level defaults for context and tags.
+ *
+ * @module events/handler/define-event-router
+ */
+
+/**
+ * Options for event router definition.
+ */
+interface DefineEventRouterOptions {
+    /**
+     * Default values applied to all child handlers.
+     *
+     * @example
+     * ```typescript
+     * defineEventRouter({
+     *   created: onTicketCreated,
+     *   assigned: onTicketAssigned,
+     * }, {
+     *   defaults: {
+     *     context: zodSchema(eventMetadataSchema),
+     *     tags: ['ticket'],
+     *   },
+     * })
+     * ```
+     */
+    readonly defaults?: EventRouterDefaults;
+}
+/**
+ * Creates an event router definition from a configuration object.
+ *
+ * @param handlers - Object containing event handlers and nested routers
+ * @param options - Optional router configuration
+ * @returns A frozen EventRouterDefinition object
+ *
+ * @example Basic router
+ * ```typescript
+ * const ticketEvents = defineEventRouter({
+ *   created: onTicketCreated,
+ *   assigned: onTicketAssigned,
+ *   transferred: onTicketTransferred,
+ * });
+ * ```
+ *
+ * @example Nested router
+ * ```typescript
+ * const events = defineEventRouter({
+ *   ticket: {
+ *     created: onTicketCreated,
+ *     assigned: onTicketAssigned,
+ *   },
+ *   ecosystem: {
+ *     memberAdded: onMemberAdded,
+ *   },
+ * });
+ * ```
+ */
+declare function defineEventRouter<T extends EventRouterConfig>(handlers: T, options?: DefineEventRouterOptions): EventRouterDefinition<T>;
+type EventRouterInput<T extends EventRouterConfig> = T | EventRouterDefinition<T>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>): EventRouterDefinition<DeepMergeTwo<T1, T2>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3]>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig, T4 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>, r4: EventRouterInput<T4>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3, T4]>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig, T4 extends EventRouterConfig, T5 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>, r4: EventRouterInput<T4>, r5: EventRouterInput<T5>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3, T4, T5]>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig, T4 extends EventRouterConfig, T5 extends EventRouterConfig, T6 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>, r4: EventRouterInput<T4>, r5: EventRouterInput<T5>, r6: EventRouterInput<T6>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3, T4, T5, T6]>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig, T4 extends EventRouterConfig, T5 extends EventRouterConfig, T6 extends EventRouterConfig, T7 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>, r4: EventRouterInput<T4>, r5: EventRouterInput<T5>, r6: EventRouterInput<T6>, r7: EventRouterInput<T7>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3, T4, T5, T6, T7]>>;
+declare function mergeEventRouters<T1 extends EventRouterConfig, T2 extends EventRouterConfig, T3 extends EventRouterConfig, T4 extends EventRouterConfig, T5 extends EventRouterConfig, T6 extends EventRouterConfig, T7 extends EventRouterConfig, T8 extends EventRouterConfig>(r1: EventRouterInput<T1>, r2: EventRouterInput<T2>, r3: EventRouterInput<T3>, r4: EventRouterInput<T4>, r5: EventRouterInput<T5>, r6: EventRouterInput<T6>, r7: EventRouterInput<T7>, r8: EventRouterInput<T8>): EventRouterDefinition<DeepMergeAll<[T1, T2, T3, T4, T5, T6, T7, T8]>>;
+declare function mergeEventRouters(...routers: EventRouterInput<EventRouterConfig>[]): EventRouterDefinition<EventRouterConfig>;
+
+/**
+ * @fileoverview Utility functions for event handler routing.
+ *
+ * @module events/handler/utils
+ */
+/**
+ * Generates a handler ID from a dotted key path.
+ *
+ * Converts dot-separated keys to camelCase:
+ * - `"ticket.created"` → `"ticketCreated"`
+ * - `"ecosystem.member.added"` → `"ecosystemMemberAdded"`
+ *
+ * @param key - The dotted key path
+ * @returns A camelCase handler ID
+ */
+declare function generateHandlerId(key: string): string;
+
+export { DeepMergeAll, DeepMergeTwo, type DefineEventRouterOptions, EventHandlerDefinition, EventRouterConfig, EventRouterDefaults, EventRouterDefinition, defineEventHandler, defineEventRouter, generateHandlerId, mergeEventRouters };

package/dist/events/handler/index.js

@@ -0,0 +1,21 @@
+import {
+  defineEventHandler,
+  defineEventRouter,
+  mergeEventRouters
+} from "../../chunk-36IO4BM7.js";
+import {
+  collectEventHandlers,
+  generateHandlerId,
+  isEventHandlerDefinition,
+  isEventRouterDefinition
+} from "../../chunk-CBTICRSM.js";
+export {
+  collectEventHandlers,
+  defineEventHandler,
+  defineEventRouter,
+  generateHandlerId,
+  isEventHandlerDefinition,
+  isEventRouterDefinition,
+  mergeEventRouters
+};
+//# sourceMappingURL=index.js.map

package/dist/events/handler/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/events/index.cjs

@@ -0,0 +1,497 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/presentation/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  collectEventHandlers: () => collectEventHandlers,
+  defineEventHandler: () => defineEventHandler,
+  defineEventRouter: () => defineEventRouter,
+  eventRoutes: () => eventRoutes,
+  generateAsyncAPI: () => generateAsyncAPI,
+  generateHandlerId: () => generateHandlerId,
+  isEventHandlerDefinition: () => isEventHandlerDefinition,
+  isEventRouterDefinition: () => isEventRouterDefinition,
+  isSimpleEventHandlerConfig: () => isSimpleEventHandlerConfig,
+  mapErrorToEventResult: () => mapErrorToEventResult,
+  mergeEventRouters: () => mergeEventRouters
+});
+module.exports = __toCommonJS(events_exports);
+
+// src/presentation/events/handler/define-event-handler.ts
+function defineEventHandler(input) {
+  const definition = {
+    eventType: input.eventType,
+    payload: input.payload ?? void 0,
+    context: input.context ?? void 0,
+    docs: {
+      summary: input.docs?.summary,
+      description: input.docs?.description,
+      tags: input.docs?.tags,
+      deprecated: input.docs?.deprecated ?? false
+    },
+    _types: void 0
+  };
+  return Object.freeze(definition);
+}
+
+// src/presentation/events/handler/types/event-router-definition.type.ts
+function isEventHandlerDefinition(value) {
+  return typeof value === "object" && value !== null && "eventType" in value && "_types" in value;
+}
+function isEventRouterDefinition(value) {
+  return typeof value === "object" && value !== null && "_isEventRouter" in value && value._isEventRouter === true;
+}
+function collectEventHandlers(config, basePath = "") {
+  const handlers = [];
+  for (const [key, value] of Object.entries(config)) {
+    const fullKey = basePath ? `${basePath}.${key}` : key;
+    if (isEventHandlerDefinition(value)) {
+      handlers.push({ key: fullKey, handler: value });
+    } else if (isEventRouterDefinition(value)) {
+      handlers.push(...collectEventHandlers(value.handlers, fullKey));
+    } else if (typeof value === "object" && value !== null) {
+      handlers.push(...collectEventHandlers(value, fullKey));
+    }
+  }
+  return handlers;
+}
+
+// src/presentation/events/handler/define-event-router.ts
+function defineEventRouter(handlers, options) {
+  const defaults = options?.defaults;
+  const processedHandlers = defaults?.context || defaults?.tags ? applyEventRouterDefaults(handlers, defaults) : handlers;
+  const definition = {
+    handlers: processedHandlers,
+    defaults,
+    _isEventRouter: true
+  };
+  return deepFreeze(definition);
+}
+function applyEventRouterDefaults(handlers, defaults) {
+  const result = {};
+  for (const [key, value] of Object.entries(handlers)) {
+    if (isEventHandlerDefinition(value)) {
+      result[key] = applyDefaultsToEventHandler(value, defaults);
+    } else if (isEventRouterDefinition(value)) {
+      result[key] = {
+        ...value,
+        handlers: applyEventRouterDefaults(value.handlers, defaults)
+      };
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = applyEventRouterDefaults(value, defaults);
+    }
+  }
+  return result;
+}
+function applyDefaultsToEventHandler(handler, defaults) {
+  const needsContext = defaults.context && !handler.context;
+  const needsTags = defaults.tags && defaults.tags.length > 0;
+  if (!needsContext && !needsTags) return handler;
+  return Object.freeze({
+    ...handler,
+    context: handler.context ?? defaults.context ?? void 0,
+    docs: {
+      ...handler.docs,
+      tags: mergeTags(defaults.tags, handler.docs.tags)
+    }
+  });
+}
+function mergeTags(routerTags, handlerTags) {
+  if (!routerTags || routerTags.length === 0) return handlerTags;
+  if (!handlerTags || handlerTags.length === 0) return routerTags;
+  const merged = [...routerTags];
+  for (const tag of handlerTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
+function deepFreeze(obj) {
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+function extractHandlers(input) {
+  return isEventRouterDefinition(input) ? input.handlers : input;
+}
+function isSubRouter(value) {
+  return typeof value === "object" && value !== null && !isEventHandlerDefinition(value) && !isEventRouterDefinition(value);
+}
+function deepMergeConfigs(a, b) {
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    const aVal = result[key];
+    const bVal = b[key];
+    if (isSubRouter(aVal) && isSubRouter(bVal)) {
+      result[key] = deepMergeConfigs(aVal, bVal);
+    } else {
+      result[key] = bVal;
+    }
+  }
+  return result;
+}
+function mergeEventRouters(...routers) {
+  const merged = routers.map(extractHandlers).reduce(deepMergeConfigs);
+  return defineEventRouter(merged);
+}
+
+// src/presentation/events/handler/utils.ts
+function generateHandlerId(key) {
+  return key.replace(/\.(\w)/g, (_, char) => char.toUpperCase());
+}
+
+// src/presentation/http/shared/error-mapping.ts
+function isErrorType(error, typeName) {
+  if (!error || typeof error !== "object") return false;
+  const constructor = Object.prototype.hasOwnProperty.call(error, "constructor") ? error.constructor : Object.getPrototypeOf(error)?.constructor;
+  if (!constructor) return false;
+  const name = constructor.name;
+  return name === typeName || name === `_${typeName}`;
+}
+
+// src/presentation/events/shared/error-mapping.ts
+var DLQ_ERROR_TYPES = [
+  "ObjectValidationError",
+  "InvalidRequestError",
+  "UseCaseError",
+  "DomainError",
+  "UnprocessableError",
+  "AccessDeniedError",
+  "ForbiddenError",
+  "UnauthorizedError",
+  "InvariantViolationError"
+];
+var RETRY_ERROR_TYPES = [
+  "NotFoundError",
+  "ConflictError",
+  "InfraError",
+  "DbError",
+  "NetworkError",
+  "TimeoutError",
+  "ExternalServiceError",
+  "PersistenceError"
+];
+function mapErrorToEventResult(error) {
+  for (const typeName of DLQ_ERROR_TYPES) {
+    if (isErrorType(error, typeName)) {
+      return {
+        outcome: "dlq",
+        reason: error.message
+      };
+    }
+  }
+  for (const typeName of RETRY_ERROR_TYPES) {
+    if (isErrorType(error, typeName)) {
+      return {
+        outcome: "retry",
+        reason: error.message
+      };
+    }
+  }
+  const message = error instanceof Error ? error.message : "Unknown error occurred during event processing";
+  return {
+    outcome: "retry",
+    reason: message
+  };
+}
+
+// src/presentation/events/server/types.ts
+function isSimpleEventHandlerConfig(config) {
+  return "handler" in config && typeof config.handler === "function";
+}
+
+// src/presentation/events/server/create-event-routes.ts
+function createEventRoutesInternal(router, handlers, options) {
+  const config = isEventRouterDefinition(router) ? router.handlers : router;
+  const collectedHandlers = collectEventHandlers(config);
+  const result = [];
+  const resolvedOptions = {
+    ...options,
+    validatePayload: options?.validatePayload ?? true,
+    allowPartial: options?.allowPartial ?? false
+  };
+  for (const { key, handler: handlerDef } of collectedHandlers) {
+    const handlerConfig = handlers[key];
+    if (!handlerConfig) {
+      if (resolvedOptions.allowPartial) {
+        continue;
+      }
+      throw new Error(
+        `Missing handler for event "${key}". All event handlers must have a handler configuration.`
+      );
+    }
+    result.push(createEventHandler(key, handlerDef, handlerConfig, resolvedOptions));
+  }
+  return result;
+}
+function createEventHandler(key, handlerDef, config, options) {
+  const middleware = config.middleware ?? [];
+  const globalMiddleware = options?.middleware ?? [];
+  const allMiddleware = [...globalMiddleware, ...middleware];
+  const shouldValidatePayload = options.validatePayload ?? true;
+  const errorMapper = options.errorMapper ?? mapErrorToEventResult;
+  return {
+    eventType: handlerDef.eventType,
+    metadata: {
+      handlerId: generateHandlerId(key),
+      summary: handlerDef.docs.summary,
+      description: handlerDef.docs.description,
+      tags: handlerDef.docs.tags,
+      deprecated: handlerDef.docs.deprecated
+    },
+    handler: async (rawEvent) => {
+      try {
+        let validatedContext = rawEvent.metadata;
+        if (handlerDef.context) {
+          const contextResult = validateContextData(handlerDef, rawEvent.metadata);
+          if (!contextResult.success) {
+            const errors = contextResult.errors ?? [];
+            return {
+              outcome: "dlq",
+              reason: `Context validation failed: ${errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ")}`
+            };
+          }
+          validatedContext = contextResult.data;
+        }
+        let validatedPayload = rawEvent.payload;
+        if (shouldValidatePayload && handlerDef.payload) {
+          const payloadResult = validatePayloadData(handlerDef, rawEvent.payload);
+          if (!payloadResult.success) {
+            const errors = payloadResult.errors ?? [];
+            return {
+              outcome: "dlq",
+              reason: `Payload validation failed: ${errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ")}`
+            };
+          }
+          validatedPayload = payloadResult.data;
+        }
+        const validatedEvent = {
+          payload: validatedPayload,
+          raw: rawEvent
+        };
+        const executePipeline = async () => {
+          if (isSimpleEventHandlerConfig(config)) {
+            return config.handler(
+              validatedEvent,
+              validatedContext
+            );
+          } else {
+            const { payloadMapper, useCase, resultMapper } = config;
+            const input = payloadMapper(
+              validatedEvent,
+              validatedContext
+            );
+            const output = await useCase.execute(input);
+            return resultMapper ? resultMapper(output) : { outcome: "ack" };
+          }
+        };
+        if (allMiddleware.length === 0) {
+          return await executePipeline();
+        }
+        let index = 0;
+        const next = async () => {
+          if (index >= allMiddleware.length) {
+            return executePipeline();
+          }
+          const mw = allMiddleware[index++];
+          return mw(rawEvent, next);
+        };
+        return await next();
+      } catch (error) {
+        return errorMapper(error);
+      }
+    }
+  };
+}
+function validatePayloadData(handler, payload) {
+  const schema = handler.payload;
+  if (!schema) return { success: true, data: payload };
+  const result = schema.validate(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["payload", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function validateContextData(handler, metadata) {
+  const schema = handler.context;
+  if (!schema) return { success: true, data: metadata };
+  const result = schema.validate(metadata);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["context", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+
+// src/presentation/events/server/event-routes-builder.ts
+var EventRoutesBuilderImpl = class _EventRoutesBuilderImpl {
+  router;
+  handlers;
+  constructor(router, handlers) {
+    this.router = router;
+    this.handlers = handlers ?? /* @__PURE__ */ new Map();
+  }
+  handle(key, handlerOrConfig) {
+    const config = typeof handlerOrConfig === "function" ? { handler: handlerOrConfig } : handlerOrConfig;
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(key, config);
+    return new _EventRoutesBuilderImpl(
+      this.router,
+      newHandlers
+    );
+  }
+  handleWithUseCase(key, config) {
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(
+      key,
+      config
+    );
+    return new _EventRoutesBuilderImpl(
+      this.router,
+      newHandlers
+    );
+  }
+  build(options) {
+    return createEventRoutesInternal(this.router, Object.fromEntries(this.handlers), options);
+  }
+  buildPartial(options) {
+    return createEventRoutesInternal(this.router, Object.fromEntries(this.handlers), {
+      ...options,
+      allowPartial: true
+    });
+  }
+};
+function eventRoutes(router) {
+  return new EventRoutesBuilderImpl(router);
+}
+
+// src/presentation/events/asyncapi/generate.ts
+function generateAsyncAPI(router, config) {
+  const routerConfig = isEventRouterDefinition(router) ? router.handlers : router;
+  const handlers = collectEventHandlers(routerConfig);
+  const channels = {};
+  const operations = {};
+  const allTags = /* @__PURE__ */ new Set();
+  for (const { key, handler } of handlers) {
+    const handlerId = generateHandlerId(key);
+    const channelId = handler.eventType;
+    const message = buildMessage(handler.eventType, handler.payload, handler.docs);
+    if (!channels[channelId]) {
+      channels[channelId] = {
+        address: handler.eventType,
+        messages: {}
+      };
+    }
+    const channelMessages = { ...channels[channelId].messages ?? {} };
+    channelMessages[handlerId] = message;
+    channels[channelId] = { ...channels[channelId], messages: channelMessages };
+    const operation = {
+      action: "receive",
+      channel: { $ref: `#/channels/${channelId}` },
+      messages: [{ $ref: `#/channels/${channelId}/messages/${handlerId}` }]
+    };
+    if (handler.docs.summary) {
+      operation.summary = handler.docs.summary;
+    }
+    if (handler.docs.description) {
+      operation.description = handler.docs.description;
+    }
+    if (handler.docs.deprecated) {
+      operation.deprecated = true;
+    }
+    if (handler.docs.tags && handler.docs.tags.length > 0) {
+      operation.tags = handler.docs.tags.map((t) => ({
+        name: t
+      }));
+      for (const tag of handler.docs.tags) {
+        allTags.add(tag);
+      }
+    }
+    operations[handlerId] = operation;
+  }
+  const tags = config.tags ? [...config.tags] : [];
+  for (const tagName of allTags) {
+    if (!tags.some((t) => t.name === tagName)) {
+      tags.push({ name: tagName });
+    }
+  }
+  const info = tags.length > 0 ? { ...config.info, tags } : config.info;
+  const spec = {
+    asyncapi: config.asyncapi ?? "3.0.0",
+    info,
+    defaultContentType: config.defaultContentType ?? "application/json",
+    channels,
+    operations
+  };
+  if (config.servers && Object.keys(config.servers).length > 0) {
+    spec.servers = config.servers;
+  }
+  if (config.externalDocs) {
+    spec.externalDocs = config.externalDocs;
+  }
+  return spec;
+}
+function buildMessage(eventType, payload, docs) {
+  const message = {
+    name: eventType
+  };
+  if (docs.summary) {
+    message.summary = docs.summary;
+  }
+  if (docs.description) {
+    message.description = docs.description;
+  }
+  if (docs.deprecated) {
+    message.deprecated = true;
+  }
+  if (payload) {
+    const schema = payload.toJsonSchema();
+    message.payload = schema;
+  }
+  return message;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectEventHandlers,
+  defineEventHandler,
+  defineEventRouter,
+  eventRoutes,
+  generateAsyncAPI,
+  generateHandlerId,
+  isEventHandlerDefinition,
+  isEventRouterDefinition,
+  isSimpleEventHandlerConfig,
+  mapErrorToEventResult,
+  mergeEventRouters
+});
+//# sourceMappingURL=index.cjs.map