@crossdelta/cloudevents 0.5.7 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossdelta/cloudevents",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "description": "CloudEvents toolkit for TypeScript - Zod validation, handler discovery, NATS JetStream",
   "author": "crossdelta",
   "license": "MIT",
@@ -15,9 +15,9 @@
     "nestjs",
     "nest"
   ],
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -25,25 +25,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "default": "./dist/index.js"
-    },
-    "./transports/nats": {
-      "types": "./dist/src/transports/nats/index.d.ts",
-      "import": "./dist/src/transports/nats/index.js",
-      "require": "./dist/src/transports/nats/index.js",
-      "default": "./dist/src/transports/nats/index.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "start:dev": "tsc -p tsconfig.json --watch",
+    "build": "tsup",
+    "start:dev": "tsup --watch",
     "stryker": "bun stryker run",
     "lint": "biome lint --fix",
-    "pretest": "rm -rf dist",
     "test": "bun test",
     "prepublishOnly": "bun run build"
   },
@@ -52,18 +45,27 @@
     "glob": "^11.1.0",
     "nats": "^2.29.3"
   },
-  "optionalDependencies": {
-    "@google-cloud/pubsub": "5.2.0"
-  },
   "peerDependencies": {
+    "@google-cloud/pubsub": ">=4.0.0",
     "hono": "^4.6.0",
     "zod": "^4.0.0"
   },
+  "peerDependenciesMeta": {
+    "@google-cloud/pubsub": {
+      "optional": true
+    },
+    "hono": {
+      "optional": true
+    }
+  },
   "trustedDependencies": [],
   "devDependencies": {
-    "@types/bun": "^1.3.3",
+    "@google-cloud/pubsub": "^4.9.0",
     "@stryker-mutator/core": "^9.1.1",
+    "@types/bun": "^1.3.3",
+    "hono": "^4.6.11",
     "stryker-mutator-bun-runner": "^0.4.0",
+    "tsup": "^8.3.5",
     "typescript": "^5.9.2"
   }
 }

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

@@ -1,14 +0,0 @@
-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/adapters/cloudevents/cloudevents.js

@@ -1,58 +0,0 @@
-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/adapters/cloudevents/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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/adapters/cloudevents/index.js

@@ -1,7 +0,0 @@
-/**
- * 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/adapters/cloudevents/parsers/binary-mode.d.ts

@@ -1,5 +0,0 @@
-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/adapters/cloudevents/parsers/binary-mode.js

@@ -1,32 +0,0 @@
-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/adapters/cloudevents/parsers/pubsub.d.ts

@@ -1,5 +0,0 @@
-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/adapters/cloudevents/parsers/pubsub.js

@@ -1,54 +0,0 @@
-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/adapters/cloudevents/parsers/raw-event.d.ts

@@ -1,5 +0,0 @@
-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/adapters/cloudevents/parsers/raw-event.js

@@ -1,17 +0,0 @@
-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/adapters/cloudevents/parsers/structured-mode.d.ts

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

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

@@ -1,18 +0,0 @@
-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/adapters/cloudevents/types.d.ts

@@ -1,29 +0,0 @@
-/**
- * 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/adapters/cloudevents/types.js

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

package/dist/domain/contract-helper.d.ts

@@ -1,63 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import type { ChannelMetadata, HandleEventOptions } from './types';
-/**
- * Creates a type-safe event contract with optional channel metadata
- *
- * This helper ensures proper type inference when using contracts
- * with handleEvent across package boundaries.
- *
- * @example
- * Basic contract without channel:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   schema: z.object({
- *     orderId: z.string(),
- *     total: z.number(),
- *   }),
- * })
- * ```
- *
- * @example
- * Contract with channel metadata:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   channel: {
- *     stream: 'ORDERS',
- *     // subject defaults to 'orders.created' if omitted
- *   },
- *   schema: z.object({
- *     orderId: z.string(),
- *     total: z.number(),
- *   }),
- * })
- * ```
- *
- * @example
- * Contract with explicit subject:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   channel: {
- *     stream: 'ORDERS',
- *     subject: 'orders.v1.created', // Override default
- *   },
- *   schema: OrderSchema,
- * })
- * ```
- */
-export declare function createContract<TSchema extends ZodTypeAny>(options: {
-    type: string;
-    schema: TSchema;
-    match?: HandleEventOptions['match'];
-    safeParse?: boolean;
-    tenantId?: string | string[];
-    channel?: {
-        stream: string;
-        subject?: string;
-    };
-}): HandleEventOptions<TSchema> & {
-    _schema: TSchema;
-    channel?: ChannelMetadata;
-};

package/dist/domain/contract-helper.js

@@ -1,61 +0,0 @@
-/**
- * Creates a type-safe event contract with optional channel metadata
- *
- * This helper ensures proper type inference when using contracts
- * with handleEvent across package boundaries.
- *
- * @example
- * Basic contract without channel:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   schema: z.object({
- *     orderId: z.string(),
- *     total: z.number(),
- *   }),
- * })
- * ```
- *
- * @example
- * Contract with channel metadata:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   channel: {
- *     stream: 'ORDERS',
- *     // subject defaults to 'orders.created' if omitted
- *   },
- *   schema: z.object({
- *     orderId: z.string(),
- *     total: z.number(),
- *   }),
- * })
- * ```
- *
- * @example
- * Contract with explicit subject:
- * ```typescript
- * export const OrderCreatedContract = createContract({
- *   type: 'orders.created',
- *   channel: {
- *     stream: 'ORDERS',
- *     subject: 'orders.v1.created', // Override default
- *   },
- *   schema: OrderSchema,
- * })
- * ```
- */
-export function createContract(options) {
-    // Resolve channel metadata: default subject to type if not provided
-    const resolvedChannel = options.channel
-        ? {
-            stream: options.channel.stream,
-            subject: options.channel.subject ?? options.type,
-        }
-        : undefined;
-    return {
-        ...options,
-        _schema: options.schema,
-        channel: resolvedChannel,
-    };
-}

package/dist/domain/discovery.d.ts

@@ -1,24 +0,0 @@
-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/*.handler.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/*.handler.ts')
- *
- * // With filtering and logging
- * const handlers = await discoverHandlers('events/*.handler.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[]>;