@oldzy/conduit 1.0.2 → 1.0.4

package/README.md

@@ -4,12 +4,13 @@ Transport-agnostic request/response pipeline framework with mediator pattern, de
 
 ## Features
 
-- 🎯 Mediator pattern for clean request/response handling
-- 💉 Built-in dependency injection
-- 🔧 Flexible middleware pipeline
-- 🚀 Transport-agnostic architecture
-- 📦 TypeScript support with full type safety
-- ⚡ Lightweight and performant
+- 🎯 **Mediator Pattern** - Clean request/response handling with type-safe handlers
+- 💉 **Dependency Injection** - Built-in DI container with three lifetime scopes (Singleton, Scoped, Transient)
+- 🔧 **Pipeline Behaviors** - Middleware support for cross-cutting concerns (logging, validation, error handling)
+- 🚀 **Transport-Agnostic** - Adapter pattern for any transport (HTTP, IPC, WebSocket, etc.)
+- 📡 **Streaming Support** - Built-in support for both simple and streaming responses
+- 📦 **TypeScript First** - Full type safety with generics
+- ⚡ **Lightweight** - Zero dependencies (except uuid and reflect-metadata)
 
 ## Installation
 
@@ -17,6 +18,708 @@ Transport-agnostic request/response pipeline framework with mediator pattern, de
 npm install @oldzy/conduit
 ```
 
+## Quick Start
+
+```typescript
+import { ApplicationBuilder, BaseRequest, BaseResponse, SimpleHandler } from '@oldzy/conduit';
+
+// 1. Define your request
+class GetUserRequest extends BaseRequest {
+    constructor(public userId: string) {
+        super('GET_USER');
+    }
+}
+
+// 2. Define your response
+class GetUserResponse extends BaseResponse {
+    constructor(public userName: string, public email: string) {
+        super('GET_USER_RESPONSE');
+    }
+}
+
+// 3. Create a handler
+class GetUserHandler extends SimpleHandler<GetUserRequest, GetUserResponse> {
+    protected async handleSimple(request: GetUserRequest): Promise<GetUserResponse> {
+        // Your business logic here
+        return new GetUserResponse(`User ${request.userId}`, 'user@example.com');
+    }
+}
+
+// 4. Build and run the application
+const app = await new ApplicationBuilder()
+    .registerHandler('GET_USER', GetUserHandler)
+    .build();
+
+await app.run();
+
+// 5. Send requests
+const request = new GetUserRequest('123');
+const response = await app.send<GetUserResponse>(request);
+
+console.log(response.userName); // "User 123"
+```
+
+## Core Concepts
+
+### Requests and Responses
+
+All requests must extend `BaseRequest` and all responses must extend `BaseResponse`.
+
+```typescript
+// Request with auto-generated UUID and timestamp
+class CreateOrderRequest extends BaseRequest {
+    constructor(
+        public productId: string,
+        public quantity: number
+    ) {
+        super('CREATE_ORDER'); // Request type identifier
+    }
+}
+
+// Response with success/error handling
+class CreateOrderResponse extends BaseResponse {
+    constructor(public orderId: string, public total: number) {
+        super('CREATE_ORDER_RESPONSE');
+    }
+}
+```
+
+**BaseRequest** includes:
+- `uuid`: Auto-generated unique identifier
+- `timestamp`: Request creation time
+- `type`: Request type identifier
+
+**BaseResponse** includes:
+- `success`: Boolean indicating success/failure
+- `errors`: Optional array of error messages
+- `timestamp`: Response creation time
+- `addError(error)`: Helper to add errors
+- `setErrors(errors)`: Helper to set multiple errors
+
+### Handlers
+
+Conduit provides two types of handlers:
+
+#### Simple Handlers
+
+For single-response requests:
+
+```typescript
+class GetUserHandler extends SimpleHandler<GetUserRequest, GetUserResponse> {
+    protected async handleSimple(request: GetUserRequest): Promise<GetUserResponse> {
+        const user = await database.getUser(request.userId);
+        return new GetUserResponse(user.name, user.email);
+    }
+}
+```
+
+#### Streaming Handlers
+
+For streaming/chunked responses:
+
+```typescript
+class StreamLogsRequest extends BaseRequest {
+    constructor(public filename: string) {
+        super('STREAM_LOGS');
+    }
+}
+
+class LogChunkResponse extends BaseResponse {
+    constructor(public line: string) {
+        super('LOG_CHUNK');
+    }
+}
+
+class StreamLogsHandler extends StreamingHandler<StreamLogsRequest, LogChunkResponse> {
+    protected async handleStream(request: StreamLogsRequest): Promise<AsyncIterable<LogChunkResponse>> {
+        return {
+            async *[Symbol.asyncIterator]() {
+                const lines = await readFileLines(request.filename);
+                for (const line of lines) {
+                    yield new LogChunkResponse(line);
+                }
+            }
+        };
+    }
+}
+```
+
+### Sending Requests
+
+Use the appropriate method based on your handler type:
+
+```typescript
+// For simple handlers - returns a single response
+const response = await app.send<GetUserResponse>(request);
+
+// For streaming handlers - returns an async iterable
+const stream = await app.stream<LogChunkResponse>(request);
+for await (const chunk of stream) {
+    console.log(chunk.line);
+}
+```
+
+**Important**: Using `send()` with a streaming handler or `stream()` with a simple handler will throw an error.
+
+### Dependency Injection
+
+Conduit includes a full-featured DI container with three lifetime scopes:
+
+#### Service Lifetimes
+
+- **Singleton**: Created once and shared across the entire application lifetime
+- **Scoped**: Created once per request (each `send()` or `stream()` call gets a new instance)
+- **Transient**: Created every time the service is requested
+
+**Important**: Conduit automatically creates a new scope for each request, making Scoped services perfect for:
+- Database transactions (commit/rollback per request)
+- Request-specific caching
+- Request context and metadata
+- Per-request logging with correlation IDs
+
+```typescript
+class UserRepository {
+    async getUser(id: string) {
+        return { id, name: 'John Doe' };
+    }
+}
+
+class Logger {
+    log(message: string) {
+        console.log(`[${new Date().toISOString()}] ${message}`);
+    }
+}
+
+const app = await new ApplicationBuilder()
+    // Register services
+    .registerSingleton('UserRepository', UserRepository)
+    .registerTransient('Logger', Logger)
+    
+    // Register handler with dependency injection
+    .registerFactory('GET_USER', (provider) => {
+        const repo = provider.getRequiredService<UserRepository>('UserRepository');
+        const logger = provider.getRequiredService<Logger>('Logger');
+        return new GetUserHandler(repo, logger);
+    })
+    .build();
+```
+
+#### Scoped Services Example
+
+Scoped services are perfect for per-request state. Each `send()` or `stream()` call creates a new scope:
+
+```typescript
+// Database transaction that lives for the duration of a request
+class DatabaseTransaction {
+    private isCommitted = false;
+    private isRolledBack = false;
+
+    async execute(query: string) {
+        if (this.isCommitted || this.isRolledBack) {
+            throw new Error('Transaction already completed');
+        }
+        // Execute query within transaction
+    }
+
+    async commit() {
+        this.isCommitted = true;
+        // Commit transaction
+    }
+
+    async rollback() {
+        this.isRolledBack = true;
+        // Rollback transaction
+    }
+}
+
+// Request cache that's cleared after each request
+class RequestCache {
+    private cache = new Map<string, any>();
+
+    get<T>(key: string): T | undefined {
+        return this.cache.get(key);
+    }
+
+    set<T>(key: string, value: T): void {
+        this.cache.set(key, value);
+    }
+}
+
+// Handler using scoped services
+class CreateOrderHandler extends SimpleHandler<CreateOrderRequest, CreateOrderResponse> {
+    constructor(
+        private transaction: DatabaseTransaction,
+        private cache: RequestCache
+    ) {
+        super();
+    }
+
+    protected async handleSimple(request: CreateOrderRequest): Promise<CreateOrderResponse> {
+        try {
+            // Check cache first
+            const cached = this.cache.get('product:' + request.productId);
+            
+            // Use transaction
+            await this.transaction.execute('INSERT INTO orders...');
+            await this.transaction.execute('UPDATE inventory...');
+            
+            // Commit transaction
+            await this.transaction.commit();
+            
+            return new CreateOrderResponse('order-123');
+        } catch (error) {
+            // Rollback on error
+            await this.transaction.rollback();
+            throw error;
+        }
+    }
+}
+
+const app = await new ApplicationBuilder()
+    // Scoped services - new instance per request
+    .registerScoped('DatabaseTransaction', DatabaseTransaction)
+    .registerScoped('RequestCache', RequestCache)
+    
+    // Handler factory
+    .registerFactory('CREATE_ORDER', (provider) => {
+        const transaction = provider.getRequiredService<DatabaseTransaction>('DatabaseTransaction');
+        const cache = provider.getRequiredService<RequestCache>('RequestCache');
+        return new CreateOrderHandler(transaction, cache);
+    })
+    .build();
+
+await app.run();
+
+// Each request gets its own transaction and cache
+const order1 = await app.send(new CreateOrderRequest('product-1'));
+const order2 = await app.send(new CreateOrderRequest('product-2'));
+// order1 and order2 had separate DatabaseTransaction instances
+```
+
+#### Using @Inject Decorator
+
+```typescript
+import { Inject } from '@oldzy/conduit/di';
+
+class GetUserHandler extends SimpleHandler<GetUserRequest, GetUserResponse> {
+    constructor(
+        @Inject('UserRepository') private repository: UserRepository,
+        @Inject('Logger') private logger: Logger
+    ) {
+        super();
+    }
+    
+    protected async handleSimple(request: GetUserRequest): Promise<GetUserResponse> {
+        this.logger.log(`Fetching user ${request.userId}`);
+        const user = await this.repository.getUser(request.userId);
+        return new GetUserResponse(user.name, user.email);
+    }
+}
+```
+
+### Pipeline Behaviors (Middleware)
+
+Behaviors allow you to add cross-cutting concerns like logging, validation, and error handling:
+
+```typescript
+class LoggingBehavior implements IPipelineBehavior {
+    async handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse> {
+        console.log(`Handling: ${context.request.type}`);
+        const startTime = Date.now();
+        
+        const response = await next();
+        
+        const duration = Date.now() - startTime;
+        console.log(`Completed in ${duration}ms`);
+        
+        return response;
+    }
+}
+
+class ErrorHandlingBehavior implements IPipelineBehavior {
+    async handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse> {
+        try {
+            return await next();
+        } catch (error) {
+            const response = new BaseResponse('ERROR_RESPONSE');
+            response.addError(error instanceof Error ? error.message : 'Unknown error');
+            return response;
+        }
+    }
+}
+
+const app = await new ApplicationBuilder()
+    .registerHandler('GET_USER', GetUserHandler)
+    .registerBehavior(new LoggingBehavior())
+    .registerBehavior(new ErrorHandlingBehavior())
+    .build();
+```
+
+**Execution Order**: Behaviors are executed in the order they are registered:
+```
+LoggingBehavior (before) → ErrorHandlingBehavior (before) → Handler → ErrorHandlingBehavior (after) → LoggingBehavior (after)
+```
+
+### Transport Adapters
+
+Adapters connect your application to specific transports (HTTP, IPC, WebSocket, etc.):
+
+```typescript
+interface IApplicationAdapter {
+    readonly name: string;
+    configure(services: ServiceCollection): void | Promise<void>;
+    initialize?(app: Application): void | Promise<void>;
+    dispose?(): void | Promise<void>;
+}
+```
+
+#### Example: HTTP Adapter with Express
+
+```typescript
+import express from 'express';
+
+class ExpressAdapter implements IApplicationAdapter {
+    readonly name = 'express-adapter';
+    private server?: Server;
+    
+    configure(services: ServiceCollection): void {
+        // Register transport-specific services
+    }
+    
+    async initialize(app: Application): Promise<void> {
+        const expressApp = express();
+        
+        expressApp.post('/api/:requestType', async (req, res) => {
+            const { requestType } = req.params;
+            
+            // Create request from HTTP body
+            const request = this.createRequest(requestType, req.body);
+            
+            try {
+                const response = await app.send(request);
+                res.json(response);
+            } catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+        
+        this.server = expressApp.listen(3000);
+    }
+    
+    async dispose(): Promise<void> {
+        if (this.server) {
+            this.server.close();
+        }
+    }
+}
+
+const app = await new ApplicationBuilder()
+    .registerHandler('GET_USER', GetUserHandler)
+    .use(new ExpressAdapter())
+    .build();
+
+await app.run();
+```
+
+#### Example: Electron IPC Adapter with Streaming
+
+```typescript
+import { ipcMain } from 'electron';
+
+class ElectronAdapter implements IApplicationAdapter {
+    readonly name = 'electron-adapter';
+    private requestControllers = new Map<string, AbortController>();
+    
+    configure(services: ServiceCollection): void {}
+    
+    async initialize(app: Application): Promise<void> {
+        // Handle simple requests
+        ipcMain.handle('conduit:send', async (event, requestData) => {
+            const request = this.createRequest(requestData);
+            return await app.send(request);
+        });
+        
+        // Handle streaming requests
+        ipcMain.handle('conduit:stream', async (event, requestData) => {
+            const request = this.createRequest(requestData);
+            const requestId = request.uuid;
+            
+            const abortController = new AbortController();
+            this.requestControllers.set(requestId, abortController);
+            
+            try {
+                const stream = await app.stream(request);
+                
+                for await (const response of stream) {
+                    if (abortController.signal.aborted) break;
+                    event.sender.send(`conduit:stream:${requestId}`, response);
+                }
+                
+                event.sender.send(`conduit:stream:${requestId}:complete`);
+            } catch (error) {
+                event.sender.send(`conduit:stream:${requestId}:error`, error.message);
+            } finally {
+                this.requestControllers.delete(requestId);
+            }
+        });
+        
+        // Handle cancellation
+        ipcMain.on('conduit:cancel', (event, requestId) => {
+            const controller = this.requestControllers.get(requestId);
+            if (controller) {
+                controller.abort();
+                this.requestControllers.delete(requestId);
+            }
+        });
+    }
+    
+    dispose(): void {
+        ipcMain.removeHandler('conduit:send');
+        ipcMain.removeHandler('conduit:stream');
+        ipcMain.removeAllListeners('conduit:cancel');
+    }
+}
+```
+
+## Application Builder API
+
+The `ApplicationBuilder` provides a fluent API for configuring your application:
+
+```typescript
+const app = await new ApplicationBuilder()
+    // Register handlers
+    .registerHandler('REQUEST_TYPE', HandlerClass, ServiceLifetime.Transient)
+    .registerHandlers(handlersMap)
+    
+    // Register services
+    .registerSingleton('ServiceName', ServiceClass)
+    .registerScoped('ServiceName', ServiceClass)
+    .registerTransient('ServiceName', ServiceClass)
+    .registerFactory('ServiceName', (provider) => new Service(...), ServiceLifetime.Singleton)
+    
+    // Register behaviors (middleware)
+    .registerBehavior(new BehaviorInstance())
+    .registerBehavior(BehaviorClass) // Will be instantiated by DI
+    
+    // Register adapters
+    .use(new HttpAdapter())
+    .use(new WebSocketAdapter())
+    
+    .build();
+```
+
+## Application Lifecycle
+
+```typescript
+const app = await builder.build();
+
+// Start the application (calls adapter.initialize())
+await app.run();
+
+// Application is now ready to handle requests
+const response = await app.send(request);
+
+// Stop the application (calls adapter.dispose())
+await app.stop();
+```
+
+## Advanced Examples
+
+### Complete Application with All Features
+
+```typescript
+import { 
+    ApplicationBuilder, 
+    BaseRequest, 
+    BaseResponse, 
+    SimpleHandler,
+    StreamingHandler,
+    IPipelineBehavior,
+    PipelineContext,
+    PipelineDelegate,
+    HandlerResult
+} from '@oldzy/conduit';
+
+// Services
+class DatabaseService {
+    async query(sql: string) { /* ... */ }
+}
+
+class CacheService {
+    async get(key: string) { /* ... */ }
+    async set(key: string, value: any) { /* ... */ }
+}
+
+// Request/Response
+class GetProductRequest extends BaseRequest {
+    constructor(public productId: string) {
+        super('GET_PRODUCT');
+    }
+}
+
+class ProductResponse extends BaseResponse {
+    constructor(public id: string, public name: string, public price: number) {
+        super('PRODUCT_RESPONSE');
+    }
+}
+
+// Handler with dependencies
+class GetProductHandler extends SimpleHandler<GetProductRequest, ProductResponse> {
+    constructor(
+        private db: DatabaseService,
+        private cache: CacheService
+    ) {
+        super();
+    }
+    
+    protected async handleSimple(request: GetProductRequest): Promise<ProductResponse> {
+        // Check cache first
+        const cached = await this.cache.get(`product:${request.productId}`);
+        if (cached) return cached;
+        
+        // Query database
+        const product = await this.db.query(`SELECT * FROM products WHERE id = ?`, [request.productId]);
+        const response = new ProductResponse(product.id, product.name, product.price);
+        
+        // Cache result
+        await this.cache.set(`product:${request.productId}`, response);
+        
+        return response;
+    }
+}
+
+// Caching behavior
+class CachingBehavior implements IPipelineBehavior {
+    constructor(private cache: CacheService) {}
+    
+    async handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse> {
+        const cacheKey = `${context.request.type}:${JSON.stringify(context.request)}`;
+        
+        const cached = await this.cache.get(cacheKey);
+        if (cached) return cached;
+        
+        const response = await next();
+        
+        if (response instanceof BaseResponse && response.success) {
+            await this.cache.set(cacheKey, response);
+        }
+        
+        return response;
+    }
+}
+
+// Validation behavior
+class ValidationBehavior implements IPipelineBehavior {
+    async handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse> {
+        // Add your validation logic
+        if (!context.request.type) {
+            const response = new BaseResponse('VALIDATION_ERROR');
+            response.addError('Request type is required');
+            return response;
+        }
+        
+        return await next();
+    }
+}
+
+// Build the application
+const app = await new ApplicationBuilder()
+    // Register services
+    .registerSingleton('DatabaseService', DatabaseService)
+    .registerSingleton('CacheService', CacheService)
+    
+    // Register handler with factory
+    .registerFactory('GET_PRODUCT', (provider) => {
+        const db = provider.getRequiredService<DatabaseService>('DatabaseService');
+        const cache = provider.getRequiredService<CacheService>('CacheService');
+        return new GetProductHandler(db, cache);
+    })
+    
+    // Register behaviors (order matters!)
+    .registerFactory('ValidationBehavior', (provider) => new ValidationBehavior())
+    .registerFactory('CachingBehavior', (provider) => {
+        const cache = provider.getRequiredService<CacheService>('CacheService');
+        return new CachingBehavior(cache);
+    })
+    
+    .build();
+
+await app.run();
+
+// Use the application
+const request = new GetProductRequest('123');
+const response = await app.send<ProductResponse>(request);
+
+console.log(response.name, response.price);
+```
+
+## Testing
+
+Conduit is designed to be testable. You can easily mock services and test handlers in isolation:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+
+describe('GetUserHandler', () => {
+    it('should return user data', async () => {
+        const mockRepo = {
+            getUser: async (id: string) => ({ id, name: 'Test User' })
+        };
+        
+        const handler = new GetUserHandler(mockRepo as any);
+        const request = new GetUserRequest('123');
+        
+        const response = await handler.handle(request);
+        
+        expect(response.userName).toBe('Test User');
+        expect(response.success).toBe(true);
+    });
+});
+```
+
+## API Reference
+
+### Core Classes
+
+- **ApplicationBuilder** - Fluent API for building applications
+- **Application** - Main application class
+- **Mediator** - Core mediator implementation
+- **ServiceProvider** - DI container
+- **ServiceCollection** - Service registration
+
+### Base Classes
+
+- **BaseRequest** - Base class for all requests
+- **BaseResponse** - Base class for all responses
+- **SimpleHandler** - Base class for simple handlers
+- **StreamingHandler** - Base class for streaming handlers
+
+### Interfaces
+
+- **IRequestHandler** - Handler interface
+- **IPipelineBehavior** - Behavior/middleware interface
+- **IApplicationAdapter** - Transport adapter interface
+
+### Types
+
+- **ServiceLifetime** - Enum: Singleton, Scoped, Transient
+- **HandlerResult** - Union: `Promise<TResponse> | Promise<AsyncIterable<TResponse>>`
+
+## Best Practices
+
+1. **Use specific request/response types** - Don't use generic types, create specific classes for each use case
+2. **Keep handlers focused** - Each handler should do one thing well
+3. **Use behaviors for cross-cutting concerns** - Don't repeat logging, validation, etc. in every handler
+4. **Register services by interface** - Use string/symbol identifiers for better testability
+5. **Handle errors in behaviors** - Use an error handling behavior instead of try-catch in every handler
+6. **Use dependency injection** - Don't create dependencies inside handlers, inject them
+7. **Separate transport concerns** - Keep business logic in handlers, transport logic in adapters
+8. **Choose the right service lifetime**:
+   - **Singleton** for stateless services, repositories, configuration
+   - **Scoped** for database transactions, request caching, request context
+   - **Transient** for lightweight, stateful operations
+9. **Leverage scoped services** - Use them for per-request resources that need cleanup (transactions, connections, caches)
+
 ## License
 
 MIT

package/dist/{IRequestHandler-CjLrozYA.d.mts → IRequestHandler-x0c3xSqH.d.mts}

@@ -6,15 +6,14 @@ declare abstract class BaseCommunicationObject {
 declare abstract class BaseRequest extends BaseCommunicationObject {
     readonly uuid: string;
     readonly timestamp: Date;
-    constructor(type: string);
+    constructor(type: string | symbol);
 }
 
 declare abstract class BaseResponse extends BaseCommunicationObject {
     success: boolean;
     errors?: string[];
     readonly timestamp: Date;
-    readonly requestUuid: string;
-    constructor(type: string, requestUuid: string);
+    constructor(type: string | symbol);
     setErrors(errors: string[]): this;
     addError(error: string): this;
 }

package/dist/{IRequestHandler-CjLrozYA.d.ts → IRequestHandler-x0c3xSqH.d.ts}

@@ -6,15 +6,14 @@ declare abstract class BaseCommunicationObject {
 declare abstract class BaseRequest extends BaseCommunicationObject {
     readonly uuid: string;
     readonly timestamp: Date;
-    constructor(type: string);
+    constructor(type: string | symbol);
 }
 
 declare abstract class BaseResponse extends BaseCommunicationObject {
     success: boolean;
     errors?: string[];
     readonly timestamp: Date;
-    readonly requestUuid: string;
-    constructor(type: string, requestUuid: string);
+    constructor(type: string | symbol);
     setErrors(errors: string[]): this;
     addError(error: string): this;
 }

package/dist/Mediator-CBq5EqK5.d.mts

@@ -0,0 +1,15 @@
+import { S as ServiceProvider } from './ServiceProvider-BcW9XXlN.mjs';
+import { b as BaseResponse, a as BaseRequest } from './IRequestHandler-x0c3xSqH.mjs';
+
+declare class Mediator {
+    private serviceProvider;
+    private behaviors;
+    constructor(serviceProvider: ServiceProvider);
+    send<TResponse extends BaseResponse>(request: BaseRequest): Promise<TResponse>;
+    stream<TResponse extends BaseResponse>(request: BaseRequest): Promise<AsyncIterable<TResponse>>;
+    private executeHandler;
+    private executePipeline;
+    private isAsyncIterable;
+}
+
+export { Mediator as M };

package/dist/Mediator-CnBmWM_n.d.ts

@@ -0,0 +1,15 @@
+import { S as ServiceProvider } from './ServiceProvider-BcW9XXlN.js';
+import { b as BaseResponse, a as BaseRequest } from './IRequestHandler-x0c3xSqH.js';
+
+declare class Mediator {
+    private serviceProvider;
+    private behaviors;
+    constructor(serviceProvider: ServiceProvider);
+    send<TResponse extends BaseResponse>(request: BaseRequest): Promise<TResponse>;
+    stream<TResponse extends BaseResponse>(request: BaseRequest): Promise<AsyncIterable<TResponse>>;
+    private executeHandler;
+    private executePipeline;
+    private isAsyncIterable;
+}
+
+export { Mediator as M };

package/dist/application/index.d.mts

@@ -1,8 +1,8 @@
 import { S as ServiceCollection } from '../ServiceCollection-3wUO7p8g.mjs';
 import { S as ServiceProvider, b as ServiceLifetime } from '../ServiceProvider-BcW9XXlN.mjs';
-import { b as BaseResponse, a as BaseRequest, H as HandlerResult, I as IRequestHandler } from '../IRequestHandler-CjLrozYA.mjs';
+import { b as BaseResponse, a as BaseRequest, I as IRequestHandler } from '../IRequestHandler-x0c3xSqH.mjs';
 import { IPipelineBehavior } from '../pipeline/index.mjs';
-import { M as Mediator } from '../Mediator-CF-4m1QF.mjs';
+import { M as Mediator } from '../Mediator-CBq5EqK5.mjs';
 
 interface IApplicationAdapter {
     readonly name: string;
@@ -19,7 +19,8 @@ declare class Application {
     constructor(serviceProvider: ServiceProvider, mediator: Mediator, adapters: IApplicationAdapter[]);
     run(): Promise<void>;
     stop(): Promise<void>;
-    send<TResponse extends BaseResponse>(request: BaseRequest): HandlerResult<TResponse>;
+    send<TResponse extends BaseResponse>(request: BaseRequest): Promise<TResponse>;
+    stream<TResponse extends BaseResponse>(request: BaseRequest): Promise<AsyncIterable<TResponse>>;
     getServiceProvider(): ServiceProvider;
     getMediator(): Mediator;
     get running(): boolean;
@@ -32,7 +33,7 @@ declare class ApplicationBuilder {
     constructor();
     registerHandler<TRequest extends BaseRequest, TResponse extends BaseResponse>(requestType: string | symbol, handler: (new (...args: any[]) => IRequestHandler<TRequest, TResponse>) | IRequestHandler<TRequest, TResponse>, lifetime?: ServiceLifetime): this;
     registerHandlers(handlers: Map<string | symbol, new (...args: any[]) => IRequestHandler<any, any>>): this;
-    registerBehavior<TRequest extends BaseRequest, TResponse extends BaseResponse>(behavior: (new (...args: any[]) => IPipelineBehavior<TRequest, TResponse>) | IPipelineBehavior<TRequest, TResponse>): this;
+    registerBehavior(behavior: (new (...args: any[]) => IPipelineBehavior) | IPipelineBehavior): this;
     registerSingleton<T>(serviceIdentifier: string | symbol, implementation: (new (...args: any[]) => T) | T): this;
     registerScoped<T>(serviceIdentifier: string | symbol, implementation: new (...args: any[]) => T): this;
     registerTransient<T>(serviceIdentifier: string | symbol, implementation: new (...args: any[]) => T): this;

package/dist/application/index.d.ts

@@ -1,8 +1,8 @@
 import { S as ServiceCollection } from '../ServiceCollection-B8PXr0Uo.js';
 import { S as ServiceProvider, b as ServiceLifetime } from '../ServiceProvider-BcW9XXlN.js';
-import { b as BaseResponse, a as BaseRequest, H as HandlerResult, I as IRequestHandler } from '../IRequestHandler-CjLrozYA.js';
+import { b as BaseResponse, a as BaseRequest, I as IRequestHandler } from '../IRequestHandler-x0c3xSqH.js';
 import { IPipelineBehavior } from '../pipeline/index.js';
-import { M as Mediator } from '../Mediator-DkYg4E8y.js';
+import { M as Mediator } from '../Mediator-CnBmWM_n.js';
 
 interface IApplicationAdapter {
     readonly name: string;
@@ -19,7 +19,8 @@ declare class Application {
     constructor(serviceProvider: ServiceProvider, mediator: Mediator, adapters: IApplicationAdapter[]);
     run(): Promise<void>;
     stop(): Promise<void>;
-    send<TResponse extends BaseResponse>(request: BaseRequest): HandlerResult<TResponse>;
+    send<TResponse extends BaseResponse>(request: BaseRequest): Promise<TResponse>;
+    stream<TResponse extends BaseResponse>(request: BaseRequest): Promise<AsyncIterable<TResponse>>;
     getServiceProvider(): ServiceProvider;
     getMediator(): Mediator;
     get running(): boolean;
@@ -32,7 +33,7 @@ declare class ApplicationBuilder {
     constructor();
     registerHandler<TRequest extends BaseRequest, TResponse extends BaseResponse>(requestType: string | symbol, handler: (new (...args: any[]) => IRequestHandler<TRequest, TResponse>) | IRequestHandler<TRequest, TResponse>, lifetime?: ServiceLifetime): this;
     registerHandlers(handlers: Map<string | symbol, new (...args: any[]) => IRequestHandler<any, any>>): this;
-    registerBehavior<TRequest extends BaseRequest, TResponse extends BaseResponse>(behavior: (new (...args: any[]) => IPipelineBehavior<TRequest, TResponse>) | IPipelineBehavior<TRequest, TResponse>): this;
+    registerBehavior(behavior: (new (...args: any[]) => IPipelineBehavior) | IPipelineBehavior): this;
     registerSingleton<T>(serviceIdentifier: string | symbol, implementation: (new (...args: any[]) => T) | T): this;
     registerScoped<T>(serviceIdentifier: string | symbol, implementation: new (...args: any[]) => T): this;
     registerTransient<T>(serviceIdentifier: string | symbol, implementation: new (...args: any[]) => T): this;

package/dist/application/index.js

@@ -1,2 +1,2 @@
 'use strict';require('reflect-metadata');/* conduit - MIT License */
-var P=Object.defineProperty;var E=(o,e,t)=>e in o?P(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var n=(o,e)=>P(o,"name",{value:e,configurable:true});var i=(o,e,t)=>E(o,typeof e!="symbol"?e+"":e,t);var s=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var l=class l{constructor(e,t){i(this,"serviceDescriptors");i(this,"singletons",new Map);i(this,"scopedInstances",new Map);i(this,"parent");i(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case s.Singleton:return this.resolveSingleton(e);case s.Scoped:return this.resolveScoped(e);case s.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let c=r.map(d=>this.getRequiredService(d));return new t(...c)}let p=(Reflect.getMetadata("design:paramtypes",t)||[]).map((c,d)=>{let T=Reflect.getMetadata("inject:params",t)?.[d];if(T)return this.getRequiredService(T);let R=c.name||c;return this.getRequiredService(R)});return new t(...p)}createScope(){let e=new l(this.serviceDescriptors,this);return {serviceProvider:e,dispose:n(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};n(l,"ServiceProvider");var u=l;var m=class m{constructor(){i(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:s.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Transient}),this}addFactory(e,t,r=s.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};n(m,"ServiceCollection");var v=m;var S=class S{constructor(e){i(this,"request");i(this,"response");i(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};n(S,"PipelineContext");var f=S;var w=class w{constructor(e){i(this,"serviceProvider");i(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let r=new f(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(r,t,this.behaviors)}async executePipeline(e,t,r){let a=0,p=n(async()=>{if(a<r.length)return await r[a++].handle(e,p);let c=await t.handle(e.request);return e.response=c,c},"next");return await p()}};n(w,"Mediator");var g=w;var y=class y{constructor(e,t,r){i(this,"serviceProvider");i(this,"mediator");i(this,"isRunning",false);i(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};n(y,"Application");var h=y;var k="PipelineBehaviors",I=class I{constructor(){i(this,"services");i(this,"adapters",[]);i(this,"pipelineBehaviors",[]);this.services=new v;}registerHandler(e,t,r=s.Transient){if(typeof t=="function")switch(r){case s.Singleton:this.services.addSingleton(e,t);break;case s.Scoped:this.services.addScoped(e,t);break;case s.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=s.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(k,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new g(e);return new h(e,t,this.adapters)}};n(I,"ApplicationBuilder");var D=I;exports.Application=h;exports.ApplicationBuilder=D;
+var E=Object.defineProperty;var T=(o,e,t)=>e in o?E(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var n=(o,e)=>E(o,"name",{value:e,configurable:true});var s=(o,e,t)=>T(o,typeof e!="symbol"?e+"":e,t);var i=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var l=class l{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case i.Singleton:return this.resolveSingleton(e);case i.Scoped:return this.resolveScoped(e);case i.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let c=r.map(d=>this.getRequiredService(d));return new t(...c)}let p=(Reflect.getMetadata("design:paramtypes",t)||[]).map((c,d)=>{let P=Reflect.getMetadata("inject:params",t)?.[d];if(P)return this.getRequiredService(P);let R=c.name||c;return this.getRequiredService(R)});return new t(...p)}createScope(){let e=new l(this.serviceDescriptors,this);return {serviceProvider:e,dispose:n(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};n(l,"ServiceProvider");var u=l;var g=class g{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:i.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Transient}),this}addFactory(e,t,r=i.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};n(g,"ServiceCollection");var v=g;var S=class S{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};n(S,"PipelineContext");var f=S;var w=class w{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(this.isAsyncIterable(r))throw new Error("Handler returned a stream. Use stream() method instead of send().");return r}finally{t.dispose();}}async stream(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(!this.isAsyncIterable(r))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return r}finally{t.dispose();}}async executeHandler(e,t){let r=t.getService(e.type);if(!r)throw new Error(`No handler registered for request type: ${String(e.type)}`);let a=new f(e);return this.behaviors.length===0?await r.handle(e):await this.executePipeline(a,r,this.behaviors)}async executePipeline(e,t,r){let a=0,p=n(async()=>{if(a<r.length)return await r[a++].handle(e,p);let c=await t.handle(e.request);return e.response=c,c},"next");return await p()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};n(w,"Mediator");var m=w;var y=class y{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}async stream(e){if(!this.isRunning)throw new Error("Application must be running before streaming requests. Call app.run() first.");return this.mediator.stream(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};n(y,"Application");var h=y;var b="PipelineBehaviors",D=class D{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new v;}registerHandler(e,t,r=i.Transient){if(typeof t=="function")switch(r){case i.Singleton:this.services.addSingleton(e,t);break;case i.Scoped:this.services.addScoped(e,t);break;case i.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=i.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(b,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new h(e,t,this.adapters)}};n(D,"ApplicationBuilder");var I=D;exports.Application=h;exports.ApplicationBuilder=I;

package/dist/application/index.mjs

@@ -1,2 +1,2 @@
 import'reflect-metadata';/* conduit - MIT License */
-var P=Object.defineProperty;var E=(o,e,t)=>e in o?P(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var n=(o,e)=>P(o,"name",{value:e,configurable:true});var i=(o,e,t)=>E(o,typeof e!="symbol"?e+"":e,t);var s=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var l=class l{constructor(e,t){i(this,"serviceDescriptors");i(this,"singletons",new Map);i(this,"scopedInstances",new Map);i(this,"parent");i(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case s.Singleton:return this.resolveSingleton(e);case s.Scoped:return this.resolveScoped(e);case s.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let c=r.map(d=>this.getRequiredService(d));return new t(...c)}let p=(Reflect.getMetadata("design:paramtypes",t)||[]).map((c,d)=>{let T=Reflect.getMetadata("inject:params",t)?.[d];if(T)return this.getRequiredService(T);let R=c.name||c;return this.getRequiredService(R)});return new t(...p)}createScope(){let e=new l(this.serviceDescriptors,this);return {serviceProvider:e,dispose:n(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};n(l,"ServiceProvider");var u=l;var m=class m{constructor(){i(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:s.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Transient}),this}addFactory(e,t,r=s.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:s.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};n(m,"ServiceCollection");var v=m;var S=class S{constructor(e){i(this,"request");i(this,"response");i(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};n(S,"PipelineContext");var f=S;var w=class w{constructor(e){i(this,"serviceProvider");i(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let r=new f(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(r,t,this.behaviors)}async executePipeline(e,t,r){let a=0,p=n(async()=>{if(a<r.length)return await r[a++].handle(e,p);let c=await t.handle(e.request);return e.response=c,c},"next");return await p()}};n(w,"Mediator");var g=w;var y=class y{constructor(e,t,r){i(this,"serviceProvider");i(this,"mediator");i(this,"isRunning",false);i(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};n(y,"Application");var h=y;var k="PipelineBehaviors",I=class I{constructor(){i(this,"services");i(this,"adapters",[]);i(this,"pipelineBehaviors",[]);this.services=new v;}registerHandler(e,t,r=s.Transient){if(typeof t=="function")switch(r){case s.Singleton:this.services.addSingleton(e,t);break;case s.Scoped:this.services.addScoped(e,t);break;case s.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=s.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(k,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new g(e);return new h(e,t,this.adapters)}};n(I,"ApplicationBuilder");var D=I;export{h as Application,D as ApplicationBuilder};
+var E=Object.defineProperty;var T=(o,e,t)=>e in o?E(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var n=(o,e)=>E(o,"name",{value:e,configurable:true});var s=(o,e,t)=>T(o,typeof e!="symbol"?e+"":e,t);var i=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var l=class l{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case i.Singleton:return this.resolveSingleton(e);case i.Scoped:return this.resolveScoped(e);case i.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let c=r.map(d=>this.getRequiredService(d));return new t(...c)}let p=(Reflect.getMetadata("design:paramtypes",t)||[]).map((c,d)=>{let P=Reflect.getMetadata("inject:params",t)?.[d];if(P)return this.getRequiredService(P);let R=c.name||c;return this.getRequiredService(R)});return new t(...p)}createScope(){let e=new l(this.serviceDescriptors,this);return {serviceProvider:e,dispose:n(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};n(l,"ServiceProvider");var u=l;var g=class g{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:i.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Transient}),this}addFactory(e,t,r=i.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:i.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};n(g,"ServiceCollection");var v=g;var S=class S{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};n(S,"PipelineContext");var f=S;var w=class w{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(this.isAsyncIterable(r))throw new Error("Handler returned a stream. Use stream() method instead of send().");return r}finally{t.dispose();}}async stream(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(!this.isAsyncIterable(r))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return r}finally{t.dispose();}}async executeHandler(e,t){let r=t.getService(e.type);if(!r)throw new Error(`No handler registered for request type: ${String(e.type)}`);let a=new f(e);return this.behaviors.length===0?await r.handle(e):await this.executePipeline(a,r,this.behaviors)}async executePipeline(e,t,r){let a=0,p=n(async()=>{if(a<r.length)return await r[a++].handle(e,p);let c=await t.handle(e.request);return e.response=c,c},"next");return await p()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};n(w,"Mediator");var m=w;var y=class y{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}async stream(e){if(!this.isRunning)throw new Error("Application must be running before streaming requests. Call app.run() first.");return this.mediator.stream(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};n(y,"Application");var h=y;var b="PipelineBehaviors",D=class D{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new v;}registerHandler(e,t,r=i.Transient){if(typeof t=="function")switch(r){case i.Singleton:this.services.addSingleton(e,t);break;case i.Scoped:this.services.addScoped(e,t);break;case i.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=i.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(b,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new h(e,t,this.adapters)}};n(D,"ApplicationBuilder");var I=D;export{h as Application,I as ApplicationBuilder};

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 export { S as ServiceCollection } from './ServiceCollection-3wUO7p8g.mjs';
 export { I as IServiceScope, a as ServiceDescriptor, b as ServiceLifetime, S as ServiceProvider } from './ServiceProvider-BcW9XXlN.mjs';
 export { Inject } from './di/index.mjs';
-export { B as BaseCommunicationObject, a as BaseRequest, b as BaseResponse, H as HandlerResult, I as IRequestHandler } from './IRequestHandler-CjLrozYA.mjs';
-export { M as Mediator } from './Mediator-CF-4m1QF.mjs';
+export { B as BaseCommunicationObject, a as BaseRequest, b as BaseResponse, H as HandlerResult, I as IRequestHandler } from './IRequestHandler-x0c3xSqH.mjs';
+export { M as Mediator } from './Mediator-CBq5EqK5.mjs';
 export { SimpleHandler, StreamingHandler } from './mediator/index.mjs';
 export { IPipelineBehavior, PipelineContext, PipelineDelegate } from './pipeline/index.mjs';
 export { Application, ApplicationBuilder, IApplicationAdapter } from './application/index.mjs';

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { S as ServiceCollection } from './ServiceCollection-B8PXr0Uo.js';
 export { I as IServiceScope, a as ServiceDescriptor, b as ServiceLifetime, S as ServiceProvider } from './ServiceProvider-BcW9XXlN.js';
 export { Inject } from './di/index.js';
-export { B as BaseCommunicationObject, a as BaseRequest, b as BaseResponse, H as HandlerResult, I as IRequestHandler } from './IRequestHandler-CjLrozYA.js';
-export { M as Mediator } from './Mediator-DkYg4E8y.js';
+export { B as BaseCommunicationObject, a as BaseRequest, b as BaseResponse, H as HandlerResult, I as IRequestHandler } from './IRequestHandler-x0c3xSqH.js';
+export { M as Mediator } from './Mediator-CnBmWM_n.js';
 export { SimpleHandler, StreamingHandler } from './mediator/index.js';
 export { IPipelineBehavior, PipelineContext, PipelineDelegate } from './pipeline/index.js';
 export { Application, ApplicationBuilder, IApplicationAdapter } from './application/index.js';

package/dist/index.js

@@ -1,2 +1,2 @@
 'use strict';require('reflect-metadata');var uuid=require('uuid');/* conduit - MIT License */
-var F=Object.defineProperty;var $=(o,e,t)=>e in o?F(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var i=(o,e)=>F(o,"name",{value:e,configurable:true});var s=(o,e,t)=>$(o,typeof e!="symbol"?e+"":e,t);var n=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var g=class g{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case n.Singleton:return this.resolveSingleton(e);case n.Scoped:return this.resolveScoped(e);case n.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let h=r.map(v=>this.getRequiredService(v));return new t(...h)}let c=(Reflect.getMetadata("design:paramtypes",t)||[]).map((h,v)=>{let q=Reflect.getMetadata("inject:params",t)?.[v];if(q)return this.getRequiredService(q);let N=h.name||h;return this.getRequiredService(N)});return new t(...c)}createScope(){let e=new g(this.serviceDescriptors,this);return {serviceProvider:e,dispose:i(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};i(g,"ServiceProvider");var u=g;var S=class S{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:n.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Transient}),this}addFactory(e,t,r=n.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};i(S,"ServiceCollection");var d=S;function B(o){return (e,t,r)=>{let c={...Reflect.getOwnMetadata("inject:params",e)||{}};c[r]=o,Reflect.defineMetadata("inject:params",c,e);}}i(B,"Inject");var w=class w{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};i(w,"PipelineContext");var l=w;var x=class x{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let r=new l(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(r,t,this.behaviors)}async executePipeline(e,t,r){let a=0,c=i(async()=>{if(a<r.length)return await r[a++].handle(e,c);let h=await t.handle(e.request);return e.response=h,h},"next");return await c()}};i(x,"Mediator");var m=x;var D=class D{handle(e){return this.handleSimple(e)}};i(D,"SimpleHandler");var y=D,P=class P{handle(e){return this.handleStream(e)}};i(P,"StreamingHandler");var I=P;var E=class E{constructor(e){s(this,"type");this.type=e;}};i(E,"BaseCommunicationObject");var p=E;var R=class R extends p{constructor(t){super(t);s(this,"uuid");s(this,"timestamp");this.uuid=uuid.v4(),this.timestamp=new Date;}};i(R,"BaseRequest");var T=R;var k=class k extends p{constructor(t,r){super(t);s(this,"success");s(this,"errors");s(this,"timestamp");s(this,"requestUuid");this.timestamp=new Date,this.success=true,this.requestUuid=r;}setErrors(t){return this.success=false,this.errors=t,this}addError(t){return this.errors||(this.errors=[]),this.errors.push(t),this.success=false,this}};i(k,"BaseResponse");var b=k;var j=class j{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};i(j,"Application");var f=j;var L="PipelineBehaviors",C=class C{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new d;}registerHandler(e,t,r=n.Transient){if(typeof t=="function")switch(r){case n.Singleton:this.services.addSingleton(e,t);break;case n.Scoped:this.services.addScoped(e,t);break;case n.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=n.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(L,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new f(e,t,this.adapters)}};i(C,"ApplicationBuilder");var M=C;exports.Application=f;exports.ApplicationBuilder=M;exports.BaseCommunicationObject=p;exports.BaseRequest=T;exports.BaseResponse=b;exports.Inject=B;exports.Mediator=m;exports.PipelineContext=l;exports.ServiceCollection=d;exports.ServiceLifetime=n;exports.ServiceProvider=u;exports.SimpleHandler=y;exports.StreamingHandler=I;
+var H=Object.defineProperty;var F=(o,e,t)=>e in o?H(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var i=(o,e)=>H(o,"name",{value:e,configurable:true});var s=(o,e,t)=>F(o,typeof e!="symbol"?e+"":e,t);var n=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var g=class g{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case n.Singleton:return this.resolveSingleton(e);case n.Scoped:return this.resolveScoped(e);case n.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let h=r.map(v=>this.getRequiredService(v));return new t(...h)}let c=(Reflect.getMetadata("design:paramtypes",t)||[]).map((h,v)=>{let A=Reflect.getMetadata("inject:params",t)?.[v];if(A)return this.getRequiredService(A);let q=h.name||h;return this.getRequiredService(q)});return new t(...c)}createScope(){let e=new g(this.serviceDescriptors,this);return {serviceProvider:e,dispose:i(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};i(g,"ServiceProvider");var u=g;var S=class S{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:n.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Transient}),this}addFactory(e,t,r=n.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};i(S,"ServiceCollection");var d=S;function N(o){return (e,t,r)=>{let c={...Reflect.getOwnMetadata("inject:params",e)||{}};c[r]=o,Reflect.defineMetadata("inject:params",c,e);}}i(N,"Inject");var w=class w{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};i(w,"PipelineContext");var l=w;var y=class y{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(this.isAsyncIterable(r))throw new Error("Handler returned a stream. Use stream() method instead of send().");return r}finally{t.dispose();}}async stream(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(!this.isAsyncIterable(r))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return r}finally{t.dispose();}}async executeHandler(e,t){let r=t.getService(e.type);if(!r)throw new Error(`No handler registered for request type: ${String(e.type)}`);let a=new l(e);return this.behaviors.length===0?await r.handle(e):await this.executePipeline(a,r,this.behaviors)}async executePipeline(e,t,r){let a=0,c=i(async()=>{if(a<r.length)return await r[a++].handle(e,c);let h=await t.handle(e.request);return e.response=h,h},"next");return await c()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};i(y,"Mediator");var m=y;var D=class D{handle(e){return this.handleSimple(e)}};i(D,"SimpleHandler");var x=D,P=class P{handle(e){return this.handleStream(e)}};i(P,"StreamingHandler");var I=P;var E=class E{constructor(e){s(this,"type");this.type=e;}};i(E,"BaseCommunicationObject");var p=E;var R=class R extends p{constructor(t){super(t);s(this,"uuid");s(this,"timestamp");this.uuid=uuid.v4(),this.timestamp=new Date;}};i(R,"BaseRequest");var b=R;var k=class k extends p{constructor(t){super(t);s(this,"success");s(this,"errors");s(this,"timestamp");this.timestamp=new Date,this.success=true;}setErrors(t){return this.success=false,this.errors=t,this}addError(t){return this.errors||(this.errors=[]),this.errors.push(t),this.success=false,this}};i(k,"BaseResponse");var T=k;var M=class M{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}async stream(e){if(!this.isRunning)throw new Error("Application must be running before streaming requests. Call app.run() first.");return this.mediator.stream(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};i(M,"Application");var f=M;var B="PipelineBehaviors",C=class C{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new d;}registerHandler(e,t,r=n.Transient){if(typeof t=="function")switch(r){case n.Singleton:this.services.addSingleton(e,t);break;case n.Scoped:this.services.addScoped(e,t);break;case n.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=n.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(B,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new f(e,t,this.adapters)}};i(C,"ApplicationBuilder");var j=C;exports.Application=f;exports.ApplicationBuilder=j;exports.BaseCommunicationObject=p;exports.BaseRequest=b;exports.BaseResponse=T;exports.Inject=N;exports.Mediator=m;exports.PipelineContext=l;exports.ServiceCollection=d;exports.ServiceLifetime=n;exports.ServiceProvider=u;exports.SimpleHandler=x;exports.StreamingHandler=I;

package/dist/index.mjs

@@ -1,2 +1,2 @@
 import'reflect-metadata';import {v4}from'uuid';/* conduit - MIT License */
-var F=Object.defineProperty;var $=(o,e,t)=>e in o?F(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var i=(o,e)=>F(o,"name",{value:e,configurable:true});var s=(o,e,t)=>$(o,typeof e!="symbol"?e+"":e,t);var n=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var g=class g{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case n.Singleton:return this.resolveSingleton(e);case n.Scoped:return this.resolveScoped(e);case n.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let h=r.map(v=>this.getRequiredService(v));return new t(...h)}let c=(Reflect.getMetadata("design:paramtypes",t)||[]).map((h,v)=>{let q=Reflect.getMetadata("inject:params",t)?.[v];if(q)return this.getRequiredService(q);let N=h.name||h;return this.getRequiredService(N)});return new t(...c)}createScope(){let e=new g(this.serviceDescriptors,this);return {serviceProvider:e,dispose:i(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};i(g,"ServiceProvider");var u=g;var S=class S{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:n.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Transient}),this}addFactory(e,t,r=n.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};i(S,"ServiceCollection");var d=S;function B(o){return (e,t,r)=>{let c={...Reflect.getOwnMetadata("inject:params",e)||{}};c[r]=o,Reflect.defineMetadata("inject:params",c,e);}}i(B,"Inject");var w=class w{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};i(w,"PipelineContext");var l=w;var x=class x{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let r=new l(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(r,t,this.behaviors)}async executePipeline(e,t,r){let a=0,c=i(async()=>{if(a<r.length)return await r[a++].handle(e,c);let h=await t.handle(e.request);return e.response=h,h},"next");return await c()}};i(x,"Mediator");var m=x;var D=class D{handle(e){return this.handleSimple(e)}};i(D,"SimpleHandler");var y=D,P=class P{handle(e){return this.handleStream(e)}};i(P,"StreamingHandler");var I=P;var E=class E{constructor(e){s(this,"type");this.type=e;}};i(E,"BaseCommunicationObject");var p=E;var R=class R extends p{constructor(t){super(t);s(this,"uuid");s(this,"timestamp");this.uuid=v4(),this.timestamp=new Date;}};i(R,"BaseRequest");var T=R;var k=class k extends p{constructor(t,r){super(t);s(this,"success");s(this,"errors");s(this,"timestamp");s(this,"requestUuid");this.timestamp=new Date,this.success=true,this.requestUuid=r;}setErrors(t){return this.success=false,this.errors=t,this}addError(t){return this.errors||(this.errors=[]),this.errors.push(t),this.success=false,this}};i(k,"BaseResponse");var b=k;var j=class j{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};i(j,"Application");var f=j;var L="PipelineBehaviors",C=class C{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new d;}registerHandler(e,t,r=n.Transient){if(typeof t=="function")switch(r){case n.Singleton:this.services.addSingleton(e,t);break;case n.Scoped:this.services.addScoped(e,t);break;case n.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=n.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(L,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new f(e,t,this.adapters)}};i(C,"ApplicationBuilder");var M=C;export{f as Application,M as ApplicationBuilder,p as BaseCommunicationObject,T as BaseRequest,b as BaseResponse,B as Inject,m as Mediator,l as PipelineContext,d as ServiceCollection,n as ServiceLifetime,u as ServiceProvider,y as SimpleHandler,I as StreamingHandler};
+var H=Object.defineProperty;var F=(o,e,t)=>e in o?H(o,e,{enumerable:true,configurable:true,writable:true,value:t}):o[e]=t;var i=(o,e)=>H(o,"name",{value:e,configurable:true});var s=(o,e,t)=>F(o,typeof e!="symbol"?e+"":e,t);var n=(function(o){return o.Singleton="SINGLETON",o.Scoped="SCOPED",o.Transient="TRANSIENT",o})({});var g=class g{constructor(e,t){s(this,"serviceDescriptors");s(this,"singletons",new Map);s(this,"scopedInstances",new Map);s(this,"parent");s(this,"resolutionStack",[]);this.serviceDescriptors=e,this.parent=t;}getService(e){try{return this.getRequiredService(e)}catch{return}}getRequiredService(e){let t=this.resolutionStack.length===0;if(this.resolutionStack.includes(e)){let r=[...this.resolutionStack,e].map(a=>String(a)).join(" \u2192 ");throw new Error(`Circular dependency detected: ${r}`)}this.resolutionStack.push(e);try{let r=this.serviceDescriptors.find(a=>a.serviceIdentifier===e);if(!r){if(this.parent)return this.parent.getRequiredService(e);throw new Error(`Service '${String(e)}' not registered`)}return this.resolveService(r)}catch(r){throw this.resolutionStack.pop(),r}finally{this.resolutionStack[this.resolutionStack.length-1]===e&&this.resolutionStack.pop(),t&&(this.resolutionStack=[]);}}resolveService(e){switch(e.lifetime){case n.Singleton:return this.resolveSingleton(e);case n.Scoped:return this.resolveScoped(e);case n.Transient:return this.resolveTransient(e);default:throw new Error(`Unknown lifetime: ${e.lifetime}`)}}resolveSingleton(e){let{serviceIdentifier:t}=e;if(this.singletons.has(t))return this.singletons.get(t);let r=this.createInstance(e);return this.singletons.set(t,r),r}resolveScoped(e){let{serviceIdentifier:t}=e;if(!this.parent)throw new Error(`Cannot resolve scoped service '${String(t)}' from root provider. Use createScope() first.`);if(this.scopedInstances.has(t))return this.scopedInstances.get(t);let r=this.createInstance(e);return this.scopedInstances.set(t,r),r}resolveTransient(e){return this.createInstance(e)}createInstance(e){if(e.implementationInstance!==void 0)return e.implementationInstance;if(e.implementationFactory)return e.implementationFactory(this);if(e.implementationType)return this.constructInstance(e);throw new Error(`Cannot create instance for service '${String(e.serviceIdentifier)}'`)}constructInstance(e){let{implementationType:t,dependencies:r}=e;if(!t)throw new Error("Implementation type is required");if(r&&r.length>0){let h=r.map(v=>this.getRequiredService(v));return new t(...h)}let c=(Reflect.getMetadata("design:paramtypes",t)||[]).map((h,v)=>{let A=Reflect.getMetadata("inject:params",t)?.[v];if(A)return this.getRequiredService(A);let q=h.name||h;return this.getRequiredService(q)});return new t(...c)}createScope(){let e=new g(this.serviceDescriptors,this);return {serviceProvider:e,dispose:i(()=>{e.scopedInstances.clear();},"dispose")}}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)||(this.parent?.has(e)??false)}};i(g,"ServiceProvider");var u=g;var S=class S{constructor(){s(this,"serviceDescriptors",[]);}addSingleton(e,t){return typeof t=="function"?this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Singleton}):this.serviceDescriptors.push({serviceIdentifier:e,implementationInstance:t,lifetime:n.Singleton}),this}addScoped(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped}),this}addTransient(e,t){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Transient}),this}addFactory(e,t,r=n.Transient){return this.serviceDescriptors.push({serviceIdentifier:e,implementationFactory:t,lifetime:r}),this}addScopedWithDependencies(e,t,r){return this.serviceDescriptors.push({serviceIdentifier:e,implementationType:t,lifetime:n.Scoped,dependencies:r}),this}buildServiceProvider(){return new u([...this.serviceDescriptors])}getDescriptors(){return [...this.serviceDescriptors]}has(e){return this.serviceDescriptors.some(t=>t.serviceIdentifier===e)}get count(){return this.serviceDescriptors.length}};i(S,"ServiceCollection");var d=S;function N(o){return (e,t,r)=>{let c={...Reflect.getOwnMetadata("inject:params",e)||{}};c[r]=o,Reflect.defineMetadata("inject:params",c,e);}}i(N,"Inject");var w=class w{constructor(e){s(this,"request");s(this,"response");s(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};i(w,"PipelineContext");var l=w;var y=class y{constructor(e){s(this,"serviceProvider");s(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(this.isAsyncIterable(r))throw new Error("Handler returned a stream. Use stream() method instead of send().");return r}finally{t.dispose();}}async stream(e){let t=this.serviceProvider.createScope();try{let r=await this.executeHandler(e,t.serviceProvider);if(!this.isAsyncIterable(r))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return r}finally{t.dispose();}}async executeHandler(e,t){let r=t.getService(e.type);if(!r)throw new Error(`No handler registered for request type: ${String(e.type)}`);let a=new l(e);return this.behaviors.length===0?await r.handle(e):await this.executePipeline(a,r,this.behaviors)}async executePipeline(e,t,r){let a=0,c=i(async()=>{if(a<r.length)return await r[a++].handle(e,c);let h=await t.handle(e.request);return e.response=h,h},"next");return await c()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};i(y,"Mediator");var m=y;var D=class D{handle(e){return this.handleSimple(e)}};i(D,"SimpleHandler");var x=D,P=class P{handle(e){return this.handleStream(e)}};i(P,"StreamingHandler");var I=P;var E=class E{constructor(e){s(this,"type");this.type=e;}};i(E,"BaseCommunicationObject");var p=E;var R=class R extends p{constructor(t){super(t);s(this,"uuid");s(this,"timestamp");this.uuid=v4(),this.timestamp=new Date;}};i(R,"BaseRequest");var b=R;var k=class k extends p{constructor(t){super(t);s(this,"success");s(this,"errors");s(this,"timestamp");this.timestamp=new Date,this.success=true;}setErrors(t){return this.success=false,this.errors=t,this}addError(t){return this.errors||(this.errors=[]),this.errors.push(t),this.success=false,this}};i(k,"BaseResponse");var T=k;var M=class M{constructor(e,t,r){s(this,"serviceProvider");s(this,"mediator");s(this,"isRunning",false);s(this,"adapters");this.serviceProvider=e,this.mediator=t,this.adapters=r;}async run(){if(this.isRunning)throw new Error("Application is already running");for(let e of this.adapters)e.initialize&&await e.initialize(this);this.isRunning=true;}async stop(){if(this.isRunning){for(let e of [...this.adapters].reverse())e.dispose&&await e.dispose();this.isRunning=false;}}async send(e){if(!this.isRunning)throw new Error("Application must be running before sending requests. Call app.run() first.");return this.mediator.send(e)}async stream(e){if(!this.isRunning)throw new Error("Application must be running before streaming requests. Call app.run() first.");return this.mediator.stream(e)}getServiceProvider(){return this.serviceProvider}getMediator(){return this.mediator}get running(){return this.isRunning}};i(M,"Application");var f=M;var B="PipelineBehaviors",C=class C{constructor(){s(this,"services");s(this,"adapters",[]);s(this,"pipelineBehaviors",[]);this.services=new d;}registerHandler(e,t,r=n.Transient){if(typeof t=="function")switch(r){case n.Singleton:this.services.addSingleton(e,t);break;case n.Scoped:this.services.addScoped(e,t);break;case n.Transient:default:this.services.addTransient(e,t);break}else this.services.addSingleton(e,t);return this}registerHandlers(e){return e.forEach((t,r)=>{this.registerHandler(r,t);}),this}registerBehavior(e){return this.pipelineBehaviors.push(e),this}registerSingleton(e,t){return this.services.addSingleton(e,t),this}registerScoped(e,t){return this.services.addScoped(e,t),this}registerTransient(e,t){return this.services.addTransient(e,t),this}registerFactory(e,t,r=n.Transient){return this.services.addFactory(e,t,r),this}use(e){return this.adapters.push(e),this}getServiceCollection(){return this.services}async build(){for(let r of this.adapters)await r.configure(this.services);this.pipelineBehaviors.length>0&&this.services.addSingleton(B,this.pipelineBehaviors.map(r=>typeof r=="function"?new r:r));let e=this.services.buildServiceProvider(),t=new m(e);return new f(e,t,this.adapters)}};i(C,"ApplicationBuilder");var j=C;export{f as Application,j as ApplicationBuilder,p as BaseCommunicationObject,b as BaseRequest,T as BaseResponse,N as Inject,m as Mediator,l as PipelineContext,d as ServiceCollection,n as ServiceLifetime,u as ServiceProvider,x as SimpleHandler,I as StreamingHandler};

package/dist/mediator/index.d.mts

@@ -1,6 +1,6 @@
-import { a as BaseRequest, b as BaseResponse, I as IRequestHandler } from '../IRequestHandler-CjLrozYA.mjs';
-export { H as HandlerResult } from '../IRequestHandler-CjLrozYA.mjs';
-export { M as Mediator } from '../Mediator-CF-4m1QF.mjs';
+import { a as BaseRequest, b as BaseResponse, I as IRequestHandler } from '../IRequestHandler-x0c3xSqH.mjs';
+export { H as HandlerResult } from '../IRequestHandler-x0c3xSqH.mjs';
+export { M as Mediator } from '../Mediator-CBq5EqK5.mjs';
 import '../ServiceProvider-BcW9XXlN.mjs';
 
 declare abstract class SimpleHandler<TRequest extends BaseRequest, TResponse extends BaseResponse> implements IRequestHandler<TRequest, TResponse> {

package/dist/mediator/index.d.ts

@@ -1,6 +1,6 @@
-import { a as BaseRequest, b as BaseResponse, I as IRequestHandler } from '../IRequestHandler-CjLrozYA.js';
-export { H as HandlerResult } from '../IRequestHandler-CjLrozYA.js';
-export { M as Mediator } from '../Mediator-DkYg4E8y.js';
+import { a as BaseRequest, b as BaseResponse, I as IRequestHandler } from '../IRequestHandler-x0c3xSqH.js';
+export { H as HandlerResult } from '../IRequestHandler-x0c3xSqH.js';
+export { M as Mediator } from '../Mediator-CnBmWM_n.js';
 import '../ServiceProvider-BcW9XXlN.js';
 
 declare abstract class SimpleHandler<TRequest extends BaseRequest, TResponse extends BaseResponse> implements IRequestHandler<TRequest, TResponse> {

package/dist/mediator/index.js

@@ -1,2 +1,2 @@
 'use strict';/* conduit - MIT License */
-var g=Object.defineProperty;var x=(s,e,t)=>e in s?g(s,e,{enumerable:true,configurable:true,writable:true,value:t}):s[e]=t;var r=(s,e)=>g(s,"name",{value:e,configurable:true});var a=(s,e,t)=>x(s,typeof e!="symbol"?e+"":e,t);var o=class o{constructor(e){a(this,"request");a(this,"response");a(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};r(o,"PipelineContext");var n=o;var c=class c{constructor(e){a(this,"serviceProvider");a(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let i=new n(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(i,t,this.behaviors)}async executePipeline(e,t,i){let u=0,w=r(async()=>{if(u<i.length)return await i[u++].handle(e,w);let f=await t.handle(e.request);return e.response=f,f},"next");return await w()}};r(c,"Mediator");var h=c;var v=class v{handle(e){return this.handleSimple(e)}};r(v,"SimpleHandler");var d=v,p=class p{handle(e){return this.handleStream(e)}};r(p,"StreamingHandler");var l=p;exports.Mediator=h;exports.SimpleHandler=d;exports.StreamingHandler=l;
+var m=Object.defineProperty;var w=(a,e,r)=>e in a?m(a,e,{enumerable:true,configurable:true,writable:true,value:r}):a[e]=r;var s=(a,e)=>m(a,"name",{value:e,configurable:true});var i=(a,e,r)=>w(a,typeof e!="symbol"?e+"":e,r);var c=class c{constructor(e){i(this,"request");i(this,"response");i(this,"metadata",new Map);this.request=e;}setMetadata(e,r){this.metadata.set(e,r);}getMetadata(e){return this.metadata.get(e)}};s(c,"PipelineContext");var o=c;var d=class d{constructor(e){i(this,"serviceProvider");i(this,"behaviors",[]);this.serviceProvider=e;let r=this.serviceProvider.getService("PipelineBehaviors");r&&(this.behaviors=r);}async send(e){let r=this.serviceProvider.createScope();try{let t=await this.executeHandler(e,r.serviceProvider);if(this.isAsyncIterable(t))throw new Error("Handler returned a stream. Use stream() method instead of send().");return t}finally{r.dispose();}}async stream(e){let r=this.serviceProvider.createScope();try{let t=await this.executeHandler(e,r.serviceProvider);if(!this.isAsyncIterable(t))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return t}finally{r.dispose();}}async executeHandler(e,r){let t=r.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let n=new o(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(n,t,this.behaviors)}async executePipeline(e,r,t){let n=0,y=s(async()=>{if(n<t.length)return await t[n++].handle(e,y);let f=await r.handle(e.request);return e.response=f,f},"next");return await y()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};s(d,"Mediator");var h=d;var v=class v{handle(e){return this.handleSimple(e)}};s(v,"SimpleHandler");var l=v,p=class p{handle(e){return this.handleStream(e)}};s(p,"StreamingHandler");var u=p;exports.Mediator=h;exports.SimpleHandler=l;exports.StreamingHandler=u;

package/dist/mediator/index.mjs

@@ -1,2 +1,2 @@
 /* conduit - MIT License */
-var g=Object.defineProperty;var x=(s,e,t)=>e in s?g(s,e,{enumerable:true,configurable:true,writable:true,value:t}):s[e]=t;var r=(s,e)=>g(s,"name",{value:e,configurable:true});var a=(s,e,t)=>x(s,typeof e!="symbol"?e+"":e,t);var o=class o{constructor(e){a(this,"request");a(this,"response");a(this,"metadata",new Map);this.request=e;}setMetadata(e,t){this.metadata.set(e,t);}getMetadata(e){return this.metadata.get(e)}};r(o,"PipelineContext");var n=o;var c=class c{constructor(e){a(this,"serviceProvider");a(this,"behaviors",[]);this.serviceProvider=e;let t=this.serviceProvider.getService("PipelineBehaviors");t&&(this.behaviors=t);}async send(e){let t=this.serviceProvider.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let i=new n(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(i,t,this.behaviors)}async executePipeline(e,t,i){let u=0,w=r(async()=>{if(u<i.length)return await i[u++].handle(e,w);let f=await t.handle(e.request);return e.response=f,f},"next");return await w()}};r(c,"Mediator");var h=c;var v=class v{handle(e){return this.handleSimple(e)}};r(v,"SimpleHandler");var d=v,p=class p{handle(e){return this.handleStream(e)}};r(p,"StreamingHandler");var l=p;export{h as Mediator,d as SimpleHandler,l as StreamingHandler};
+var m=Object.defineProperty;var w=(a,e,r)=>e in a?m(a,e,{enumerable:true,configurable:true,writable:true,value:r}):a[e]=r;var s=(a,e)=>m(a,"name",{value:e,configurable:true});var i=(a,e,r)=>w(a,typeof e!="symbol"?e+"":e,r);var c=class c{constructor(e){i(this,"request");i(this,"response");i(this,"metadata",new Map);this.request=e;}setMetadata(e,r){this.metadata.set(e,r);}getMetadata(e){return this.metadata.get(e)}};s(c,"PipelineContext");var o=c;var d=class d{constructor(e){i(this,"serviceProvider");i(this,"behaviors",[]);this.serviceProvider=e;let r=this.serviceProvider.getService("PipelineBehaviors");r&&(this.behaviors=r);}async send(e){let r=this.serviceProvider.createScope();try{let t=await this.executeHandler(e,r.serviceProvider);if(this.isAsyncIterable(t))throw new Error("Handler returned a stream. Use stream() method instead of send().");return t}finally{r.dispose();}}async stream(e){let r=this.serviceProvider.createScope();try{let t=await this.executeHandler(e,r.serviceProvider);if(!this.isAsyncIterable(t))throw new Error("Handler did not return a stream. Use send() method instead of stream().");return t}finally{r.dispose();}}async executeHandler(e,r){let t=r.getService(e.type);if(!t)throw new Error(`No handler registered for request type: ${String(e.type)}`);let n=new o(e);return this.behaviors.length===0?await t.handle(e):await this.executePipeline(n,t,this.behaviors)}async executePipeline(e,r,t){let n=0,y=s(async()=>{if(n<t.length)return await t[n++].handle(e,y);let f=await r.handle(e.request);return e.response=f,f},"next");return await y()}isAsyncIterable(e){return e!=null&&typeof e[Symbol.asyncIterator]=="function"}};s(d,"Mediator");var h=d;var v=class v{handle(e){return this.handleSimple(e)}};s(v,"SimpleHandler");var l=v,p=class p{handle(e){return this.handleStream(e)}};s(p,"StreamingHandler");var u=p;export{h as Mediator,l as SimpleHandler,u as StreamingHandler};

package/dist/pipeline/index.d.mts

@@ -1,17 +1,17 @@
-import { a as BaseRequest, b as BaseResponse, H as HandlerResult } from '../IRequestHandler-CjLrozYA.mjs';
+import { a as BaseRequest, b as BaseResponse, H as HandlerResult } from '../IRequestHandler-x0c3xSqH.mjs';
 
-declare class PipelineContext<TRequest extends BaseRequest, TResponse extends BaseResponse> {
-    readonly request: TRequest;
-    response?: AsyncIterable<TResponse> | TResponse;
+declare class PipelineContext {
+    readonly request: BaseRequest;
+    response?: AsyncIterable<BaseResponse> | BaseResponse;
     metadata: Map<string, any>;
-    constructor(request: TRequest);
+    constructor(request: BaseRequest);
     setMetadata(key: string, value: any): void;
     getMetadata<T>(key: string): T | undefined;
 }
 
-type PipelineDelegate<TResponse> = () => HandlerResult<TResponse>;
-interface IPipelineBehavior<TRequest extends BaseRequest, TResponse extends BaseResponse> {
-    handle(context: PipelineContext<TRequest, TResponse>, next: PipelineDelegate<TResponse>): HandlerResult<TResponse>;
+type PipelineDelegate = () => HandlerResult<BaseResponse>;
+interface IPipelineBehavior {
+    handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse>;
 }
 
 export { type IPipelineBehavior, PipelineContext, type PipelineDelegate };

package/dist/pipeline/index.d.ts

@@ -1,17 +1,17 @@
-import { a as BaseRequest, b as BaseResponse, H as HandlerResult } from '../IRequestHandler-CjLrozYA.js';
+import { a as BaseRequest, b as BaseResponse, H as HandlerResult } from '../IRequestHandler-x0c3xSqH.js';
 
-declare class PipelineContext<TRequest extends BaseRequest, TResponse extends BaseResponse> {
-    readonly request: TRequest;
-    response?: AsyncIterable<TResponse> | TResponse;
+declare class PipelineContext {
+    readonly request: BaseRequest;
+    response?: AsyncIterable<BaseResponse> | BaseResponse;
     metadata: Map<string, any>;
-    constructor(request: TRequest);
+    constructor(request: BaseRequest);
     setMetadata(key: string, value: any): void;
     getMetadata<T>(key: string): T | undefined;
 }
 
-type PipelineDelegate<TResponse> = () => HandlerResult<TResponse>;
-interface IPipelineBehavior<TRequest extends BaseRequest, TResponse extends BaseResponse> {
-    handle(context: PipelineContext<TRequest, TResponse>, next: PipelineDelegate<TResponse>): HandlerResult<TResponse>;
+type PipelineDelegate = () => HandlerResult<BaseResponse>;
+interface IPipelineBehavior {
+    handle(context: PipelineContext, next: PipelineDelegate): HandlerResult<BaseResponse>;
 }
 
 export { type IPipelineBehavior, PipelineContext, type PipelineDelegate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oldzy/conduit",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Transport-agnostic request/response pipeline framework with mediator pattern, dependency injection, and middleware support",
   "author": "oldzy",
   "license": "MIT",
@@ -51,7 +51,8 @@
     "test:coverage": "vitest --coverage",
     "test:watch": "vitest --watch",
     "lint": "eslint src",
-    "prepublishOnly": "npm run build:prod && npm test"
+    "prepublishOnly": "npm run build:prod && npm test",
+    "publish:npm": "npm run build:prod && npm test && npm publish --access public"
   },
   "keywords": [
     "mediator",

package/dist/Mediator-CF-4m1QF.d.mts

@@ -1,12 +0,0 @@
-import { S as ServiceProvider } from './ServiceProvider-BcW9XXlN.mjs';
-import { a as BaseRequest, H as HandlerResult, b as BaseResponse } from './IRequestHandler-CjLrozYA.mjs';
-
-declare class Mediator {
-    private serviceProvider;
-    private behaviors;
-    constructor(serviceProvider: ServiceProvider);
-    send(request: BaseRequest): HandlerResult<BaseResponse>;
-    private executePipeline;
-}
-
-export { Mediator as M };

package/dist/Mediator-DkYg4E8y.d.ts

@@ -1,12 +0,0 @@
-import { S as ServiceProvider } from './ServiceProvider-BcW9XXlN.js';
-import { a as BaseRequest, H as HandlerResult, b as BaseResponse } from './IRequestHandler-CjLrozYA.js';
-
-declare class Mediator {
-    private serviceProvider;
-    private behaviors;
-    constructor(serviceProvider: ServiceProvider);
-    send(request: BaseRequest): HandlerResult<BaseResponse>;
-    private executePipeline;
-}
-
-export { Mediator as M };