@crossdelta/cloudevents 0.1.1

package/README.md

@@ -0,0 +1,125 @@
+# Orderboss CloudEvents Toolkit
+
+[![Architecture](https://img.shields.io/badge/architecture-arc42-blue?style=flat-square&logo=gitbook)](docs/architecture.md)
+
+CloudEvents middleware, publishers, and consumers that integrate cleanly with [Hono](https://hono.dev/). Ship handler discovery, DLQ-safe processing for Google Pub/Sub & Eventarc, and NATS utilities without wiring everything yourself.
+
+## Features
+
+- Automatic handler discovery for `*.event.(ts|js)` files with caching
+- CloudEvents parsing for structured, binary, Pub/Sub push, and raw payloads
+- DLQ-safe mode that quarantines invalid messages and reports recoverable errors
+- First-class Zod support with optional safe-parse fallback
+- Shared tooling for Google Pub/Sub and NATS (publish & consume)
+
+## Getting started
+
+### 1. Install the package
+
+```bash
+bun add @orderboss/cloudevents
+```
+
+### 2. Define a typed event handler
+
+```typescript
+import { z } from 'zod'
+import { eventSchema, handleEvent } from '@orderboss/cloudevents'
+
+const CustomerCreatedSchema = eventSchema({
+  type: z.literal('customer.created'),
+  payload: z.object({
+    id: z.string(),
+    email: z.string().email(),
+  }),
+})
+
+export const CustomerCreatedHandler = handleEvent(CustomerCreatedSchema, async ({ payload }) => {
+  await provisionAccount(payload)
+})
+```
+
+> Need a softer failure mode? Set `CustomerCreatedHandler.__eventarcMetadata.safeParse = true` before registering it to skip invalid payloads in favour of quarantine logs.
+
+### 3. Register the middleware in Hono
+
+```typescript
+import { Hono } from 'hono'
+import { cloudEvents } from '@orderboss/cloudevents'
+
+const app = new Hono()
+
+app.use('/events', cloudEvents({
+  discover: 'src/events/**/*.event.{ts,js}',
+  quarantineTopic: process.env.QUARANTINE_TOPIC,
+  errorTopic: process.env.ERROR_TOPIC,
+  projectId: process.env.GCP_PROJECT_ID,
+  log: process.env.NODE_ENV === 'production' ? 'structured' : 'pretty',
+}))
+```
+
+DLQ-safe mode activates automatically when `quarantineTopic` or `errorTopic` is provided.
+
+## Publishing events
+
+```typescript
+import {
+  publishEvent,
+  publishRawEvent,
+  publishNatsEvent,
+  publishNatsRawEvent,
+} from '@orderboss/cloudevents'
+
+// Google Pub/Sub
+await publishEvent('customer-events', CustomerCreatedSchema, {
+  payload: { id: 'cust_1', email: 'jane@example.com' },
+})
+
+await publishRawEvent('customer-events', 'customer.deleted', { id: 'cust_1' }, {
+  source: 'orderboss://customers',
+  projectId: 'my-project',
+})
+
+// NATS Streaming (reuse the schema you defined for your handler)
+await publishNatsEvent('orders.placed', OrderPlacedSchema, {
+  payload: { id: 'ord_42', total: 149.9 },
+})
+
+await publishNatsRawEvent('orders.canceled', 'order.canceled', { id: 'ord_42' }, {
+  servers: process.env.NATS_URL,
+})
+```
+
+## Consuming from NATS
+
+```typescript
+import { consumeNatsEvents } from '@orderboss/cloudevents/transports/nats'
+
+await consumeNatsEvents({
+  servers: process.env.NATS_URL,
+  subject: 'orders.placed',
+  discover: 'dist/events/*.event.js',
+  consumerName: 'orders-api',
+  quarantineTopic: 'projects/my-app/topics/nats-quarantine',
+  errorTopic: 'projects/my-app/topics/nats-errors',
+})
+```
+
+The consumer reuses your handler definitions, honours `safeParse`, and mirrors the DLQ-safe behaviour of the middleware.
+
+## API surface
+
+- `cloudEvents(options)` – Hono middleware with discovery, dedupe, and DLQ-safe semantics
+- `clearHandlerCache()` – resets the discovery cache (tests, hot reload)
+- `eventSchema(schema)` – wraps a Zod object that includes a `type` literal
+- `handleEvent(schemaOrOptions, handler)` – builds discovery-ready handler classes
+- `parseEventFromContext(ctx)` – normalises incoming CloudEvents for manual flows
+- `publishEvent` / `publishRawEvent` – publish to Google Pub/Sub
+- `publishNatsEvent` / `publishNatsRawEvent` – publish to NATS subjects
+- `consumeNatsEvents` – subscribe to NATS and execute discovered handlers
+
+## Further reading
+
+- [Architecture notes](docs/architecture.md)
+- Examples in `packages/cloudevents/test`
+- Project changelog in the repository root

package/dist/src/adapters/cloudevents/cloudevents.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from 'hono';
+import type { CloudEventParseResult } from './types';
+/**
+ * Parses CloudEvent from Hono context with automatic format detection.
+ *
+ * Supports:
+ * 1. Structured CloudEvent (body with specversion)
+ * 2. Pub/Sub push message format (body with message field)
+ * 3. Binary CloudEvent (CloudEvent headers)
+ * 4. Raw event data (fallback)
+ *
+ * Uses dynamic imports to load only necessary parsers for optimal performance.
+ */
+export declare const parseEventFromContext: (context: Context) => Promise<CloudEventParseResult>;

package/dist/src/adapters/cloudevents/cloudevents.js

@@ -0,0 +1,58 @@
+import { logger } from '../../infrastructure';
+/**
+ * Checks if request has CloudEvent headers (for binary mode)
+ */
+const hasCloudEventHeaders = (headers) => Object.keys(headers).some((key) => key.toLowerCase().startsWith('ce-'));
+const isRecord = (value) => typeof value === 'object' && value !== null;
+/**
+ * Parses CloudEvent from Hono context with automatic format detection.
+ *
+ * Supports:
+ * 1. Structured CloudEvent (body with specversion)
+ * 2. Pub/Sub push message format (body with message field)
+ * 3. Binary CloudEvent (CloudEvent headers)
+ * 4. Raw event data (fallback)
+ *
+ * Uses dynamic imports to load only necessary parsers for optimal performance.
+ */
+export const parseEventFromContext = async (context) => {
+    try {
+        const headers = context.req.header();
+        const rawBody = await context.req.text();
+        let parsedBody;
+        if (rawBody?.length) {
+            try {
+                parsedBody = JSON.parse(rawBody);
+            }
+            catch {
+                parsedBody = undefined;
+            }
+        }
+        const bodyObject = isRecord(parsedBody) ? parsedBody : undefined;
+        // 1. Structured CloudEvent (has specversion in body)
+        if (bodyObject && 'specversion' in bodyObject) {
+            const { parseStructuredMode } = await import('./parsers/structured-mode');
+            return parseStructuredMode(bodyObject);
+        }
+        // 2. PubSub message format (has message field)
+        if (bodyObject && 'message' in bodyObject) {
+            const { parsePubSubMessage } = await import('./parsers/pubsub');
+            return await parsePubSubMessage(bodyObject, headers);
+        }
+        // 3. Binary CloudEvent (CloudEvent headers, no specversion in body)
+        if (hasCloudEventHeaders(headers)) {
+            const { parseBinaryMode } = await import('./parsers/binary-mode');
+            return await parseBinaryMode(headers, rawBody);
+        }
+        // 4. Raw event data (fallback)
+        const { parseRawEvent } = await import('./parsers/raw-event');
+        if (bodyObject) {
+            return parseRawEvent(bodyObject);
+        }
+        return parseRawEvent({ raw: rawBody });
+    }
+    catch (error) {
+        logger.error('Failed to parse event:', error);
+        throw new Error(`Failed to parse CloudEvent: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};

package/dist/src/adapters/cloudevents/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapters Module - External Protocol Handlers
+ *
+ * Entry point for all protocol adapters with automatic format detection
+ * and dynamic loading for optimal performance.
+ */
+export * from './cloudevents';
+export type { CloudEventParseResult, EventContext } from './types';

package/dist/src/adapters/cloudevents/index.js

@@ -0,0 +1,7 @@
+/**
+ * Adapters Module - External Protocol Handlers
+ *
+ * Entry point for all protocol adapters with automatic format detection
+ * and dynamic loading for optimal performance.
+ */
+export * from './cloudevents';

package/dist/src/adapters/cloudevents/parsers/binary-mode.d.ts

@@ -0,0 +1,5 @@
+import type { CloudEventParseResult } from '../types';
+/**
+ * Parse binary mode CloudEvent using CloudEvents SDK
+ */
+export declare const parseBinaryMode: (headers: Record<string, string | undefined>, rawBody: string) => Promise<CloudEventParseResult>;

package/dist/src/adapters/cloudevents/parsers/binary-mode.js

@@ -0,0 +1,32 @@
+import { HTTP } from 'cloudevents';
+import { createCloudEventParseError, logger } from '../../../infrastructure';
+/**
+ * Parse binary mode CloudEvent using CloudEvents SDK
+ */
+export const parseBinaryMode = async (headers, rawBody) => {
+    const normalizedHeaders = {};
+    Object.entries(headers).forEach(([key, value]) => {
+        if (typeof value === 'string') {
+            normalizedHeaders[key] = value;
+        }
+    });
+    const body = rawBody ?? '';
+    try {
+        const event = HTTP.toEvent({ headers: normalizedHeaders, body });
+        const finalEvent = Array.isArray(event) ? event[0] : event;
+        const cloudEventData = {
+            id: finalEvent.id,
+            type: finalEvent.type,
+            specversion: finalEvent.specversion,
+            source: finalEvent.source,
+            subject: finalEvent.subject,
+            time: finalEvent.time || new Date().toISOString(),
+            data: finalEvent.data,
+        };
+        return { event: finalEvent, cloudEventData };
+    }
+    catch (error) {
+        logger.error('Binary mode parsing failed:', error);
+        throw createCloudEventParseError(`Binary mode parsing failed: ${error}`);
+    }
+};

package/dist/src/adapters/cloudevents/parsers/pubsub.d.ts

@@ -0,0 +1,5 @@
+import type { CloudEventParseResult } from '../types';
+/**
+ * Parses raw PubSub message into CloudEvent wrapper format
+ */
+export declare const parsePubSubMessage: (rawBody: Record<string, unknown>, headers: Record<string, string | undefined>) => Promise<CloudEventParseResult>;

package/dist/src/adapters/cloudevents/parsers/pubsub.js

@@ -0,0 +1,54 @@
+import { logger } from '../../../infrastructure';
+/**
+ * Parses raw PubSub message into CloudEvent wrapper format
+ */
+export const parsePubSubMessage = async (rawBody, headers) => {
+    const body = rawBody;
+    if (!body.message?.data) {
+        throw new Error('Invalid PubSub message: missing message.data');
+    }
+    // Try to extract real event type from message attributes or decoded data
+    let eventType = 'google.cloud.pubsub.topic.v1.messagePublished';
+    let decodedData = body;
+    try {
+        // Always try to decode the base64 data first
+        const base64Data = body.message.data;
+        const decodedString = Buffer.from(base64Data, 'base64').toString('utf8');
+        const parsedData = JSON.parse(decodedString);
+        // Check for event type in attributes first, then in parsed data
+        if (body.message.attributes?.eventType) {
+            eventType = body.message.attributes.eventType;
+            decodedData = parsedData;
+        }
+        else if (body.message.attributes?.type) {
+            eventType = body.message.attributes.type;
+            decodedData = parsedData;
+        }
+        else if (parsedData.type) {
+            eventType = parsedData.type;
+            decodedData = parsedData;
+        }
+        else {
+            // If no type found, use decoded data but keep default type
+            decodedData = parsedData;
+        }
+    }
+    catch (error) {
+        // If decoding fails, keep original type and data
+        logger.warn('Failed to extract event type from PubSub message:', error);
+    }
+    const messageId = body.message.messageId || 'unknown';
+    const eventSource = headers['ce-source'] || '//pubsub.googleapis.com';
+    const subject = headers['ce-subject'];
+    const publishTime = headers['ce-time'];
+    const cloudEventData = {
+        id: messageId,
+        type: eventType,
+        specversion: '1.0',
+        source: eventSource,
+        subject: subject,
+        time: publishTime || new Date().toISOString(),
+        data: decodedData,
+    };
+    return { event: null, cloudEventData };
+};

package/dist/src/adapters/cloudevents/parsers/raw-event.d.ts

@@ -0,0 +1,5 @@
+import type { CloudEventParseResult } from '../types';
+/**
+ * Parse raw event data and wrap it in CloudEvent structure
+ */
+export declare const parseRawEvent: (body: Record<string, unknown>) => CloudEventParseResult;

package/dist/src/adapters/cloudevents/parsers/raw-event.js

@@ -0,0 +1,17 @@
+import { logger } from '../../../infrastructure';
+/**
+ * Parse raw event data and wrap it in CloudEvent structure
+ */
+export const parseRawEvent = (body) => {
+    logger.info('Creating CloudEvent wrapper for raw data');
+    const cloudEventData = {
+        id: `raw-${Date.now()}`,
+        type: body.type || 'unknown.event',
+        specversion: '1.0',
+        source: '//direct.post',
+        subject: undefined,
+        time: new Date().toISOString(),
+        data: body,
+    };
+    return { event: null, cloudEventData };
+};

package/dist/src/adapters/cloudevents/parsers/structured-mode.d.ts

@@ -0,0 +1,5 @@
+import type { CloudEventParseResult } from '../types';
+/**
+ * Parse structured mode CloudEvent (CloudEvents JSON in body)
+ */
+export declare const parseStructuredMode: (body: Record<string, unknown>) => CloudEventParseResult;

package/dist/src/adapters/cloudevents/parsers/structured-mode.js

@@ -0,0 +1,18 @@
+import { logger } from '../../../infrastructure';
+/**
+ * Parse structured mode CloudEvent (CloudEvents JSON in body)
+ */
+export const parseStructuredMode = (body) => {
+    logger.info('Structured mode CloudEvent detected');
+    // For structured CloudEvents, use data directly since it's already in CloudEvent format
+    const cloudEventData = {
+        id: String(body.id || 'unknown'),
+        type: String(body.type || 'unknown.event'),
+        specversion: String(body.specversion || '1.0'),
+        source: String(body.source || '//unknown'),
+        subject: body.subject ? String(body.subject) : undefined,
+        time: String(body.time) || new Date().toISOString(),
+        data: body.data,
+    };
+    return { event: null, cloudEventData };
+};

package/dist/src/adapters/cloudevents/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Adapter types for external protocols
+ */
+import type { CloudEventV1 } from 'cloudevents';
+/**
+ * Simplified event context for handler consumption
+ *
+ * Provides essential CloudEvent metadata without the complexity of the full CloudEventV1 interface.
+ * This is what handler functions receive as context parameter.
+ */
+export interface EventContext {
+    /** Event type identifier (from CloudEvent.type) */
+    eventType: string;
+    /** Event source (from CloudEvent.source) */
+    source: string;
+    /** Optional subject (from CloudEvent.subject) */
+    subject?: string;
+    /** Event timestamp (from CloudEvent.time) */
+    time: string;
+    /** Message ID for deduplication (from CloudEvent.id) */
+    messageId?: string;
+}
+/**
+ * Result of CloudEvent parsing - either CloudEvents SDK object or normalized data
+ */
+export interface CloudEventParseResult {
+    event: CloudEventV1<unknown> | null;
+    cloudEventData: CloudEventV1<unknown> | null;
+}

package/dist/src/adapters/cloudevents/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import type { HandlerConstructor } from './types';
+/**
+ * Discovers event handlers from files matching the given glob pattern.
+ *
+ * @param pattern - Glob pattern to match handler files (e.g., 'events/*.event.ts')
+ * @param options - Configuration options
+ * @returns Promise resolving to array of discovered handler constructors
+ *
+ * @example
+ * ```typescript
+ * // Discover all handlers in events directory
+ * const handlers = await discoverHandlers('events/*.event.ts')
+ *
+ * // With filtering and logging
+ * const handlers = await discoverHandlers('events/*.event.ts', {
+ *   filter: (name, handler) => name.includes('Customer'),
+ *   log: true
+ * })
+ * ```
+ */
+export declare const discoverHandlers: (pattern: string, options?: {
+    filter?: (name: string, handler: unknown) => boolean;
+    log?: boolean;
+}) => Promise<HandlerConstructor[]>;

package/dist/src/domain/discovery.js

@@ -0,0 +1,137 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { glob } from 'glob';
+import { logger } from '../infrastructure';
+import { isValidHandler } from './validation';
+/**
+ * Gets the search directories for event handler discovery.
+ * @returns Array of search directory paths.
+ */
+const getSearchDirectories = () => {
+    const directories = new Set();
+    directories.add(process.cwd());
+    try {
+        const currentDir = dirname(fileURLToPath(import.meta.url));
+        directories.add(currentDir);
+    }
+    catch {
+        // Ignore resolution errors; fallback to process.cwd()
+    }
+    return [...directories];
+};
+/**
+ * Loads and validates handlers from a TypeScript/JavaScript file.
+ */
+const loadHandlers = async (filePath, filter) => {
+    try {
+        const module = await import(filePath);
+        return Object.entries(module)
+            .filter(([name, handler]) => isValidHandler(handler) && (!filter || filter(name, handler)))
+            .map(([name, handler]) => {
+            const HandlerClass = handler;
+            return HandlerClass.name !== name
+                ? Object.defineProperty(HandlerClass, 'name', { value: name, configurable: true })
+                : HandlerClass;
+        });
+    }
+    catch (error) {
+        logger?.warn(`Failed to load ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return [];
+    }
+};
+/**
+ * Deduplicates handlers by class name to avoid loading the same handler from .ts and .js
+ * @param handlers - Array of handler constructors
+ * @returns Array of unique handlers
+ */
+const deduplicateHandlers = (handlers) => handlers.reduce((acc, handler) => {
+    const existing = acc.find((h) => h.name === handler.name);
+    if (!existing) {
+        acc.push(handler);
+    }
+    return acc;
+}, []);
+/**
+ * Discovers files matching the pattern across multiple search paths
+ * @param pattern - Glob pattern to match
+ * @param searchPaths - Array of directories to search in
+ * @param logger - Logger instance for debug output
+ * @param log - Whether logging is enabled
+ * @returns Promise resolving to array of unique file paths
+ */
+/**
+ * Simple, elegant file discovery using glob patterns
+ */
+const EXTENSION_FALLBACKS = ['js', 'mjs', 'cjs'];
+const expandPatternVariants = (pattern, preferCompiled) => {
+    if (!/\.tsx?\b/.test(pattern)) {
+        return [pattern];
+    }
+    const basePattern = pattern;
+    const compiledVariants = EXTENSION_FALLBACKS.map((ext) => basePattern.replace(/\.tsx?\b/g, `.${ext}`));
+    const ordered = preferCompiled ? [...compiledVariants, basePattern] : [basePattern, ...compiledVariants];
+    return [...new Set(ordered)];
+};
+const discoverFiles = async (pattern, basePath, preferCompiled) => {
+    const prefixedPattern = `{src,dist,build,lib,out}/${pattern}`;
+    const patterns = preferCompiled ? [prefixedPattern, pattern] : [pattern, prefixedPattern];
+    const allFiles = [];
+    for (const globPattern of patterns) {
+        const variants = expandPatternVariants(globPattern, preferCompiled);
+        for (const variant of variants) {
+            try {
+                const files = await glob(variant, { cwd: basePath, absolute: true });
+                allFiles.push(...files);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    return [...new Set(allFiles)]; // Remove duplicates
+};
+/**
+ * Discovers event handlers from files matching the given glob pattern.
+ *
+ * @param pattern - Glob pattern to match handler files (e.g., 'events/*.event.ts')
+ * @param options - Configuration options
+ * @returns Promise resolving to array of discovered handler constructors
+ *
+ * @example
+ * ```typescript
+ * // Discover all handlers in events directory
+ * const handlers = await discoverHandlers('events/*.event.ts')
+ *
+ * // With filtering and logging
+ * const handlers = await discoverHandlers('events/*.event.ts', {
+ *   filter: (name, handler) => name.includes('Customer'),
+ *   log: true
+ * })
+ * ```
+ */
+export const discoverHandlers = async (pattern, options = {}) => {
+    const { filter } = options;
+    const searchDirectories = getSearchDirectories();
+    const preferCompiled = searchDirectories.some((dir) => dir.includes('/dist/') || dir.includes('\\dist\\'));
+    try {
+        const uniqueFiles = new Set();
+        for (const basePath of searchDirectories) {
+            const discoveredFiles = await discoverFiles(pattern, basePath, preferCompiled);
+            for (const file of discoveredFiles) {
+                uniqueFiles.add(file);
+            }
+        }
+        if (uniqueFiles.size === 0) {
+            logger.warn(`No files found matching pattern: ${pattern}`);
+            return [];
+        }
+        const handlers = await Promise.all([...uniqueFiles].map((file) => loadHandlers(file, filter)));
+        const flatHandlers = handlers.flat();
+        const uniqueHandlers = deduplicateHandlers(flatHandlers);
+        return uniqueHandlers;
+    }
+    catch (error) {
+        logger.error('Discovery failed:', error);
+        return [];
+    }
+};

package/dist/src/domain/handler-factory.d.ts

@@ -0,0 +1,24 @@
+import { type ZodTypeAny, z } from 'zod';
+import type { EventContext } from '../adapters/cloudevents';
+import type { HandlerConstructor } from './types';
+/**
+ * Creates an event handler using the handleEvent pattern
+ * Compatible with the new middleware system
+ */
+export declare function handleEvent<TSchema extends ZodTypeAny>(schemaOrOptions: TSchema | {
+    schema: TSchema;
+    type?: string;
+}, handler: (payload: TSchema['_output'], context?: EventContext) => Promise<void> | void, eventType?: string): HandlerConstructor;
+/**
+ * Creates an event schema with type inference
+ * Automatically enforces the presence of a 'type' field
+ */
+export declare function eventSchema<T extends Record<string, ZodTypeAny>>(schema: T & {
+    type: ZodTypeAny;
+}): z.ZodObject<T & {
+    type: ZodTypeAny;
+}, "strip", ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T & {
+    type: ZodTypeAny;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<T & {
+    type: ZodTypeAny;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;

package/dist/src/domain/handler-factory.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/**
+ * Extracts event type from schema
+ */
+function extractEventTypeFromSchema(schema) {
+    if ('shape' in schema && schema.shape && typeof schema.shape === 'object') {
+        const shape = schema.shape;
+        if (shape.type && typeof shape.type === 'object' && shape.type !== null && '_def' in shape.type) {
+            const typeDef = shape.type._def;
+            return typeDef?.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Creates an event handler using the handleEvent pattern
+ * Compatible with the new middleware system
+ */
+export function handleEvent(schemaOrOptions, handler, eventType) {
+    // Handle both API formats
+    let schema;
+    let finalEventType = eventType;
+    if (schemaOrOptions && typeof schemaOrOptions === 'object' && 'schema' in schemaOrOptions) {
+        schema = schemaOrOptions.schema;
+        finalEventType = schemaOrOptions.type || eventType;
+    }
+    else {
+        schema = schemaOrOptions;
+    }
+    // Try to extract event type from schema if not provided
+    if (!finalEventType) {
+        finalEventType = extractEventTypeFromSchema(schema);
+    }
+    // Fallback to unknown event
+    if (!finalEventType) {
+        finalEventType = 'unknown.event';
+    }
+    // Create handler class with proper naming
+    const handlerName = `${finalEventType.replace(/[^a-zA-Z0-9]/g, '')}Handler`;
+    const HandlerClass = class extends Object {
+        static __eventarcMetadata = {
+            schema,
+            declaredType: finalEventType,
+        };
+        async handle(payload, context) {
+            await Promise.resolve(handler(payload, context));
+        }
+    };
+    // Set the class name properly
+    Object.defineProperty(HandlerClass, 'name', {
+        value: handlerName,
+        configurable: true,
+    });
+    return HandlerClass;
+}
+/**
+ * Creates an event schema with type inference
+ * Automatically enforces the presence of a 'type' field
+ */
+export function eventSchema(schema) {
+    return z.object(schema);
+}

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

@@ -0,0 +1,5 @@
+export { discoverHandlers } from './discovery';
+export { eventSchema, handleEvent } from './handler-factory';
+export type { EnrichedEvent, EventHandler, HandleEventOptions, HandlerConstructor, HandlerMetadata, MatchFn, } from './types';
+export type { HandlerValidationError, ValidationErrorDetail } from './validation';
+export { extractTypeFromSchema, isValidHandler } from './validation';

package/dist/src/domain/index.js

@@ -0,0 +1,3 @@
+export { discoverHandlers } from './discovery';
+export { eventSchema, handleEvent } from './handler-factory';
+export { extractTypeFromSchema, isValidHandler } from './validation';