@hexaijs/application 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sangwoo Hyun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,331 @@
+# @hexaijs/application
+
+> Application layer infrastructure for building CQRS applications with hexagonal architecture
+
+## Overview
+
+`@hexaijs/application` provides the application layer components for building CQRS (Command Query Responsibility Segregation) applications. It bridges the gap between your domain model and external interfaces (HTTP, CLI, message queues) by providing a structured way to handle commands, queries, and events.
+
+The package centers around three key patterns:
+
+1. **Application** - A facade that routes messages to their handlers and manages execution context
+2. **ApplicationContext** - Scopes handler execution with transactional boundaries and event publishing
+3. **Interceptors** - Cross-cutting concerns that wrap message handling (logging, tracing, authorization)
+
+These components work together to ensure each command/query executes in isolation with proper transaction management, while events flow through the system with causation and correlation tracking.
+
+## Installation
+
+```bash
+npm install @hexaijs/application
+```
+
+## Core Concepts
+
+### Command and Query
+
+`Command` and `Query` extend the core `Message` class to represent different intents. Commands change state; queries read state.
+
+```typescript
+import { Command, Query } from "@hexaijs/application";
+
+// Command - changes state
+export class CreateOrderCommand extends Command<{
+    customerId: string;
+    items: { productId: string; quantity: number }[];
+}> {
+    static readonly type = "order.create-order";
+}
+
+// Query - reads state
+export class GetOrderQuery extends Query<{
+    orderId: string;
+}> {
+    static readonly type = "order.get-order";
+}
+```
+
+Both support security contexts for authorization:
+
+```typescript
+// Attach security context
+const command = new CreateOrderCommand({
+    customerId: "customer-123",
+    items: []
+}).withSecurityContext({ userId: "user-456", roles: ["admin"] });
+
+// Access in handler
+const user = command.getSecurityContext();
+```
+
+### CommandHandler and QueryHandler
+
+Handlers implement the `execute` method to process messages:
+
+```typescript
+import { CommandHandler, QueryHandler } from "@hexaijs/application";
+
+interface OrderContext {
+    getOrderRepository(): OrderRepository;
+}
+
+class CreateOrderHandler implements CommandHandler<
+    CreateOrderCommand,
+    { orderId: string },
+    OrderContext
+> {
+    async execute(
+        command: CreateOrderCommand,
+        ctx: OrderContext
+    ): Promise<{ orderId: string }> {
+        const repository = ctx.getOrderRepository();
+        const order = Order.create(command.getPayload());
+        await repository.add(order);
+        return { orderId: order.getId().getValue() };
+    }
+}
+
+class GetOrderHandler implements QueryHandler<
+    GetOrderQuery,
+    OrderDto,
+    OrderContext
+> {
+    async execute(
+        query: GetOrderQuery,
+        ctx: OrderContext
+    ): Promise<OrderDto> {
+        const repository = ctx.getOrderRepository();
+        const order = await repository.get(query.getPayload().orderId);
+        return toDto(order);
+    }
+}
+```
+
+### EventHandler
+
+Event handlers react to domain events. The `canHandle` method filters which events the handler processes:
+
+```typescript
+import { Message } from "@hexaijs/core";
+import { EventHandler } from "@hexaijs/application";
+
+class SendOrderConfirmationEmail implements EventHandler<OrderPlaced, OrderContext> {
+    canHandle(message: Message): boolean {
+        return message.getMessageType() === OrderPlaced.getType();
+    }
+
+    async handle(event: OrderPlaced, ctx: OrderContext): Promise<void> {
+        const payload = event.getPayload();
+        await ctx.getEmailService().send({
+            to: payload.customerEmail,
+            template: "order-confirmation",
+            data: { orderId: payload.orderId }
+        });
+    }
+}
+```
+
+### ApplicationBuilder
+
+`ApplicationBuilder` assembles handlers and context into an `Application` using a fluent API:
+
+```typescript
+import { ApplicationBuilder } from "@hexaijs/application";
+
+const application = new ApplicationBuilder()
+    .withApplicationContext(new OrderApplicationContext())
+    .withCommandHandler(CreateOrderCommand, () => new CreateOrderHandler())
+    .withCommandHandler(CancelOrderCommand, () => new CancelOrderHandler())
+    .withQueryHandler(GetOrderQuery, () => new GetOrderHandler())
+    .withEventHandler(() => new SendOrderConfirmationEmail())
+    .build();
+```
+
+Each handler is registered with a factory function. This allows fresh handler instances per request, preventing state leakage between requests.
+
+### Application
+
+The `Application` interface provides three methods for dispatching messages:
+
+```typescript
+import { Application, Result } from "@hexaijs/application";
+
+// Execute commands
+const result: Result<{ orderId: string }> = await application.executeCommand(
+    new CreateOrderCommand({ customerId: "c-123", items: [] })
+);
+
+// Execute queries
+const orderResult: Result<OrderDto> = await application.executeQuery(
+    new GetOrderQuery({ orderId: "order-456" })
+);
+
+// Handle events (typically called by infrastructure)
+await application.handleEvent(orderPlacedEvent);
+```
+
+### Result
+
+All operations return a `Result` type that is either `SuccessResult` or `ErrorResult`:
+
+```typescript
+const result = await application.executeCommand(command);
+
+if (result.isSuccess) {
+    console.log("Order created:", result.data.orderId);
+}
+
+if (result.isError) {
+    console.error("Failed:", result.error.message);
+}
+
+// Or throw on error
+const data = result.getOrThrow();
+```
+
+### AbstractApplicationContext
+
+Extend `AbstractApplicationContext` to define your application's dependencies. The context provides event publishing and hooks for transaction management:
+
+```typescript
+import { AbstractApplicationContext } from "@hexaijs/application";
+import { UnitOfWork } from "@hexaijs/core";
+
+export abstract class OrderApplicationContext extends AbstractApplicationContext {
+    abstract getUnitOfWork(): UnitOfWork;
+    abstract getOrderRepository(): OrderRepository;
+    abstract getEmailService(): EmailService;
+}
+```
+
+The context provides `publish()` for emitting domain events:
+
+```typescript
+// Inside a handler
+await ctx.publish(
+    new OrderPlaced({
+        orderId: order.getId().getValue(),
+        customerId: command.getPayload().customerId
+    })
+);
+```
+
+Events published through the context automatically receive causation and correlation headers, enabling distributed tracing.
+
+## Interceptors
+
+Interceptors wrap message handling for cross-cutting concerns. They follow a middleware pattern:
+
+```typescript
+import { CommandInterceptor, CommandInterceptionContext, Result } from "@hexaijs/application";
+
+const loggingInterceptor: CommandInterceptor = async (
+    ctx: CommandInterceptionContext,
+    next: () => Promise<Result<unknown>>
+): Promise<Result<unknown>> => {
+    console.log("Executing:", ctx.message.getMessageType());
+    const start = Date.now();
+
+    const result = await next();
+
+    console.log(`Completed in ${Date.now() - start}ms`);
+    return result;
+};
+
+// Register with builder
+const app = new ApplicationBuilder()
+    .withApplicationContext(context)
+    .withCommandHandler(CreateOrderCommand, () => new CreateOrderHandler())
+    .withCommandInterceptor(loggingInterceptor)
+    .build();
+```
+
+Four interceptor types are available:
+
+| Type | Applies To |
+|------|------------|
+| `CommandInterceptor` | Command execution only |
+| `QueryInterceptor` | Query execution only |
+| `EventInterceptor` | Event handling only |
+| `Interceptor` | All message types |
+
+## Advanced Patterns
+
+### SelectorBasedEventHandler
+
+For handlers that respond to multiple event types, use `SelectorBasedEventHandler` with the `@When` decorator:
+
+```typescript
+import { Message } from "@hexaijs/core";
+import { SelectorBasedEventHandler, When, eventTypeMatches } from "@hexaijs/application";
+
+class OrderEventHandler extends SelectorBasedEventHandler<Message, OrderContext> {
+    @When(eventTypeMatches(OrderPlaced.getType()))
+    async onOrderPlaced(event: OrderPlaced, ctx: OrderContext): Promise<void> {
+        // Handle order placed
+    }
+
+    @When(eventTypeMatches(OrderCancelled.getType()))
+    async onOrderCancelled(event: OrderCancelled, ctx: OrderContext): Promise<void> {
+        // Handle order cancelled
+    }
+}
+```
+
+The `eventTypeMatches` helper supports strings, arrays, and regex patterns:
+
+```typescript
+@When(eventTypeMatches("order.order-placed"))
+@When(eventTypeMatches(["order.order-placed", "order.order-updated"]))
+@When(eventTypeMatches(/^order\./))
+```
+
+### SimpleCompositeApplication
+
+Compose multiple bounded context applications into one:
+
+```typescript
+import { SimpleCompositeApplication } from "@hexaijs/application";
+
+const compositeApp = new SimpleCompositeApplication({
+    "order.": orderApplication,      // handles order.* messages
+    "inventory.": inventoryApplication,
+    "shipping.": shippingApplication,
+});
+
+// Routes to appropriate application based on message type prefix
+await compositeApp.executeCommand(new CreateOrderCommand(...));
+```
+
+For event handling across bounded contexts, provide a `UnitOfWork` to ensure all handlers execute in the same transaction:
+
+```typescript
+compositeApp.setUnitOfWork(unitOfWork);
+await compositeApp.handleEvent(event);
+```
+
+## API Highlights
+
+| Export | Description |
+|--------|-------------|
+| `Application` | Interface for command/query execution and event handling |
+| `ApplicationBuilder` | Fluent builder for assembling applications |
+| `Command<P, SC>` | Base class for commands with payload and security context |
+| `Query<P, SC>` | Base class for queries with payload and security context |
+| `CommandHandler<I, O, Ctx>` | Interface for command handlers |
+| `QueryHandler<I, O, Ctx>` | Interface for query handlers |
+| `EventHandler<E, Ctx>` | Interface for event handlers |
+| `AbstractApplicationContext` | Base class for application contexts |
+| `Result<R, E>` | Union type of `SuccessResult` or `ErrorResult` |
+| `SelectorBasedEventHandler` | Base class for decorator-based event routing |
+| `SimpleCompositeApplication` | Composes multiple applications by message prefix |
+| `CommandInterceptor` | Interceptor type for commands |
+| `QueryInterceptor` | Interceptor type for queries |
+| `EventInterceptor` | Interceptor type for events |
+| `Interceptor` | Interceptor type for all messages |
+
+## See Also
+
+- [@hexaijs/core](../core/README.md) - Core domain primitives this package builds upon
+- [@hexaijs/postgres](../postgres/README.md) - PostgreSQL implementation for ApplicationContext
+- [@hexaijs/plugin-application-builder](../plugin-application-builder/README.md) - Decorators for automatic handler registration

package/dist/abstract-application-context.d.ts

@@ -0,0 +1,13 @@
+import { Message } from "@hexaijs/core";
+import { ApplicationEventPublisher } from "./application-event-publisher";
+export declare abstract class AbstractApplicationContext {
+    protected eventPublisher: ApplicationEventPublisher;
+    constructor(eventPublisher?: ApplicationEventPublisher);
+    setEventPublisher(eventPublisher: ApplicationEventPublisher): void;
+    protected clone(): this;
+    enterCommandExecutionScope<C extends Message>(command: C, fn: (ctx: this) => Promise<void>): Promise<void>;
+    publish(...events: Message[]): Promise<void>;
+    protected onEnter(message: Message): Promise<void>;
+    protected onExit(message: Message): Promise<void>;
+}
+//# sourceMappingURL=abstract-application-context.d.ts.map

package/dist/abstract-application-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-application-context.d.ts","sourceRoot":"","sources":["../src/abstract-application-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,8BAAsB,0BAA0B;IAC5C,SAAS,CAAC,cAAc,EAAE,yBAAyB,CAAC;gBAExC,cAAc,CAAC,EAAE,yBAAyB;IAI/C,iBAAiB,CAAC,cAAc,EAAE,yBAAyB,GAAG,IAAI;IAIzE,SAAS,CAAC,KAAK,IAAI,IAAI;IAIV,0BAA0B,CAAC,CAAC,SAAS,OAAO,EACrD,OAAO,EAAE,CAAC,EACV,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAUH,OAAO,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;cAIzC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;cAKxC,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAG1D"}

package/dist/abstract-application-context.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractApplicationContext = void 0;
+const lodash_1 = require("lodash");
+const application_event_publisher_1 = require("./application-event-publisher");
+class AbstractApplicationContext {
+    eventPublisher;
+    constructor(eventPublisher) {
+        this.eventPublisher = eventPublisher ?? new application_event_publisher_1.ApplicationEventPublisher();
+    }
+    setEventPublisher(eventPublisher) {
+        this.eventPublisher = eventPublisher;
+    }
+    clone() {
+        return (0, lodash_1.clone)(this);
+    }
+    async enterCommandExecutionScope(command, fn) {
+        const newContext = this.clone();
+        await newContext.onEnter(command);
+        await fn(newContext);
+        await newContext.onExit(command);
+    }
+    async publish(...events) {
+        await this.eventPublisher.publish(...events);
+    }
+    async onEnter(message) {
+        this.eventPublisher = this.eventPublisher.deriveFrom(message);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async onExit(message) {
+        return;
+    }
+}
+exports.AbstractApplicationContext = AbstractApplicationContext;
+//# sourceMappingURL=abstract-application-context.js.map

package/dist/abstract-application-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-application-context.js","sourceRoot":"","sources":["../src/abstract-application-context.ts"],"names":[],"mappings":";;;AAAA,mCAA+B;AAG/B,+EAA0E;AAE1E,MAAsB,0BAA0B;IAClC,cAAc,CAA4B;IAEpD,YAAY,cAA0C;QAClD,IAAI,CAAC,cAAc,GAAG,cAAc,IAAI,IAAI,uDAAyB,EAAE,CAAC;IAC5E,CAAC;IAEM,iBAAiB,CAAC,cAAyC;QAC9D,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACzC,CAAC;IAES,KAAK;QACX,OAAO,IAAA,cAAK,EAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,0BAA0B,CACnC,OAAU,EACV,EAAgC;QAEhC,MAAM,UAAU,GAAS,IAAI,CAAC,KAAK,EAAE,CAAC;QAEtC,MAAM,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAElC,MAAM,EAAE,CAAC,UAAU,CAAC,CAAC;QAErB,MAAM,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,GAAG,MAAiB;QACrC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;IACjD,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,OAAgB;QACpC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAClE,CAAC;IAED,6DAA6D;IACnD,KAAK,CAAC,MAAM,CAAC,OAAgB;QACnC,OAAO;IACX,CAAC;CACJ;AAxCD,gEAwCC"}

package/dist/application-context.d.ts

@@ -0,0 +1,2 @@
+export { AbstractApplicationContext } from "./abstract-application-context";
+//# sourceMappingURL=application-context.d.ts.map

package/dist/application-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-context.d.ts","sourceRoot":"","sources":["../src/application-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/application-context.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractApplicationContext = void 0;
+var abstract_application_context_1 = require("./abstract-application-context");
+Object.defineProperty(exports, "AbstractApplicationContext", { enumerable: true, get: function () { return abstract_application_context_1.AbstractApplicationContext; } });
+//# sourceMappingURL=application-context.js.map

package/dist/application-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-context.js","sourceRoot":"","sources":["../src/application-context.ts"],"names":[],"mappings":";;;AAAA,+EAA4E;AAAnE,0IAAA,0BAA0B,OAAA"}

package/dist/application-event-publisher.d.ts

@@ -0,0 +1,16 @@
+import { AnyMessage, Message } from "@hexaijs/core";
+import { EventPublisher } from "./event-publisher";
+interface PublishCallback {
+    (event: AnyMessage): void | Promise<void>;
+}
+export declare class ApplicationEventPublisher implements EventPublisher<Message> {
+    private callbacks;
+    private context?;
+    deriveFrom(message: Message): ApplicationEventPublisher;
+    subscribe(callback: PublishCallback): () => void;
+    private unsubscribe;
+    publish(...events: Message[]): Promise<void>;
+    private runCallbacks;
+}
+export {};
+//# sourceMappingURL=application-event-publisher.d.ts.map

package/dist/application-event-publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-event-publisher.d.ts","sourceRoot":"","sources":["../src/application-event-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,UAAU,eAAe;IACrB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C;AAED,qBAAa,yBAA0B,YAAW,cAAc,CAAC,OAAO,CAAC;IACrE,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,OAAO,CAAC,CAAU;IAEnB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,yBAAyB;IAQvD,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAKvD,OAAO,CAAC,WAAW;IAIN,OAAO,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YAgB3C,YAAY;CAG7B"}

package/dist/application-event-publisher.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationEventPublisher = void 0;
+const messaging_support_1 = require("./messaging-support");
+class ApplicationEventPublisher {
+    callbacks = new Set();
+    context;
+    deriveFrom(message) {
+        const derived = new ApplicationEventPublisher();
+        derived.context = message;
+        derived.callbacks = new Set(this.callbacks);
+        return derived;
+    }
+    subscribe(callback) {
+        this.callbacks.add(callback);
+        return () => this.unsubscribe(callback);
+    }
+    unsubscribe(callback) {
+        this.callbacks.delete(callback);
+    }
+    async publish(...events) {
+        for (let event of events) {
+            if (this.context) {
+                const trace = (0, messaging_support_1.asTrace)(this.context);
+                event = event
+                    .withHeader("causation", trace)
+                    .withHeader("correlation", this.context.getHeader("correlation") || trace);
+            }
+            await this.runCallbacks(event);
+        }
+    }
+    async runCallbacks(event) {
+        await Promise.all([...this.callbacks].map((cb) => cb(event)));
+    }
+}
+exports.ApplicationEventPublisher = ApplicationEventPublisher;
+//# sourceMappingURL=application-event-publisher.js.map

package/dist/application-event-publisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-event-publisher.js","sourceRoot":"","sources":["../src/application-event-publisher.ts"],"names":[],"mappings":";;;AACA,2DAA8C;AAO9C,MAAa,yBAAyB;IAC1B,SAAS,GAAyB,IAAI,GAAG,EAAE,CAAC;IAC5C,OAAO,CAAW;IAEnB,UAAU,CAAC,OAAgB;QAC9B,MAAM,OAAO,GAAG,IAAI,yBAAyB,EAAE,CAAC;QAChD,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;QAC1B,OAAO,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE5C,OAAO,OAAO,CAAC;IACnB,CAAC;IAEM,SAAS,CAAC,QAAyB;QACtC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAEO,WAAW,CAAC,QAAyB;QACzC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,GAAG,MAAiB;QACrC,KAAK,IAAI,KAAK,IAAI,MAAM,EAAE,CAAC;YACvB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,MAAM,KAAK,GAAG,IAAA,2BAAO,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAEpC,KAAK,GAAG,KAAK;qBACR,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC;qBAC9B,UAAU,CACP,aAAa,EACb,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,KAAK,CACjD,CAAC;YACV,CAAC;YACD,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,YAAY,CAAC,KAAc;QACrC,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;CACJ;AAxCD,8DAwCC"}

package/dist/application.d.ts

@@ -0,0 +1,59 @@
+import { Message, MessageClass } from "@hexaijs/core";
+import { AbstractApplicationContext } from "./abstract-application-context";
+import { CommandHandler } from "./command-handler";
+import { Command } from "./command";
+import { QueryHandler } from "./query-handler";
+import { Query } from "./query";
+import { ApplicationErrorTransformer } from "./error";
+import { EventHandler } from "./event-handler";
+import { CommandInterceptor, QueryInterceptor, EventInterceptor, Interceptor } from "./interceptor";
+import { SuccessResult, ErrorResult, Result } from "./result";
+export { SuccessResult, ErrorResult, Result };
+type Factory<T> = () => T;
+type CommandHandlerFactory = Factory<CommandHandler>;
+type QueryHandlerFactory = Factory<QueryHandler>;
+interface CommandClass extends MessageClass {
+    new (...args: any[]): Command;
+}
+interface QueryClass extends MessageClass {
+    new (...args: any[]): Query;
+}
+export type EventHandlingResult = unknown;
+export interface CommandDispatcher {
+    executeCommand<T = unknown>(command: Command): Promise<Result<T>>;
+}
+export interface QueryDispatcher {
+    executeQuery<T = unknown>(query: Query): Promise<Result<T>>;
+}
+export interface EventDispatcher {
+    handleEvent(event: Message): Promise<Result<EventHandlingResult>>;
+}
+export interface Application extends CommandDispatcher, QueryDispatcher, EventDispatcher {
+}
+export declare class ApplicationBuilder {
+    private commandHandlers;
+    private queryHandlers;
+    private eventHandlers;
+    private eventHandlerNames;
+    private applicationContext;
+    private errorTransformer;
+    private commandInterceptors;
+    private queryInterceptors;
+    private eventInterceptors;
+    private commonInterceptors;
+    static readonly defaultErrorTransformer: ApplicationErrorTransformer;
+    withCommandHandler(commandClass: CommandClass, commandHandlerFactory: CommandHandlerFactory): this;
+    private assertNoHandlerRegisteredFor;
+    withQueryHandler(queryClass: QueryClass, queryHandlerFactory: QueryHandlerFactory): this;
+    private assertNoQueryHandlerRegisteredFor;
+    withApplicationContext(applicationContext: AbstractApplicationContext): this;
+    withErrorTransformer(errorTransformer: ApplicationErrorTransformer): this;
+    withEventHandler(eventHandlerFactory: () => EventHandler, eventHandlerName?: string): this;
+    private assertNoEventHandlerWithSameNameRegistered;
+    withCommandInterceptor(interceptor: CommandInterceptor): this;
+    withQueryInterceptor(interceptor: QueryInterceptor): this;
+    withEventInterceptor(interceptor: EventInterceptor): this;
+    withInterceptor(interceptor: Interceptor): this;
+    build(): Application;
+}
+//# sourceMappingURL=application.d.ts.map

package/dist/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../src/application.ts"],"names":[],"mappings":"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"}