@haskou/ddd-kernel 0.1.0 → 1.0.0

package/dist/{Kernel-CUaqHa1s.d.ts → ShutdownHook-CMWLsfu-.d.ts}

@@ -1,10 +1,30 @@
-import { C as Consumer } from './Consumer-CeT0Wbxb.js';
-import { C as ConsumerMiddleware, S as ShutdownHook } from './ShutdownHook-BGskq2-q.js';
-import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+import { D as DomainEventConsumer } from './DomainEventConsumer-BroJmVty.js';
 import { Route } from './adapters/ui/routes/index.js';
-import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-C7NCKdSS.js';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-Bq_fBC5R.js';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.js';
-import { S as Scheduler } from './Scheduler-oigqNOUJ.js';
+import { a as Scheduler } from './Scheduler-BW-U5Ccg.js';
+import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
+
+declare abstract class Consumer {
+    private readonly consumer;
+    constructor(consumer: DomainEventConsumer);
+    private runMiddleware;
+    abstract get domainEvent(): typeof DomainEvent;
+    abstract get eventName(): string;
+    abstract get exchange(): string;
+    abstract get queueName(): string;
+    abstract handler(event: DomainEvent): Promise<void>;
+    init(): Promise<void>;
+    get<T>(service: unknown): T;
+}
+
+interface KernelDependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
 
 interface KernelOptions {
     readonly di?: DependencyInjection;
@@ -29,6 +49,7 @@ declare class Kernel {
     static get consumerMiddleware(): ConsumerMiddleware[];
     static get di(): DependencyInjection;
     static get logger(): KernelLogger;
+    static get active(): Kernel;
     static get rootDirectory(): string;
     static get routes(): ServiceClass<Route>[];
     static get schedulers(): Scheduler[];
@@ -46,7 +67,8 @@ declare class Kernel {
     get logger(): KernelLogger;
     get routes(): ServiceClass<Route>[];
     get schedulers(): Scheduler[];
-    dependencyInjection(): Promise<void>;
+    private getDependencyInjectionOptions;
+    dependencyInjection(options?: KernelDependencyInjectionOptions): Promise<void>;
     getRoutes(): ServiceClass<Route>[];
     registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
     registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
@@ -67,4 +89,24 @@ declare class Kernel {
 }
 declare function createKernel(options?: KernelOptions): Kernel;
 
-export { Kernel as K, type KernelOptions as a, createKernel as c };
+interface ConsumerExecutionContext {
+    readonly causationId?: string;
+    readonly correlationId?: string;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly exchange: string;
+    readonly kernel: Kernel;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly rawMessage?: unknown;
+    readonly queueName: string;
+}
+
+type ConsumerNext = () => Promise<void>;
+
+interface ConsumerMiddleware {
+    handle(event: DomainEvent, next: ConsumerNext, context: ConsumerExecutionContext): Promise<void>;
+}
+
+type ShutdownHook = () => Promise<void> | void;
+
+export { Consumer as C, Kernel as K, type ShutdownHook as S, type ConsumerExecutionContext as a, type ConsumerMiddleware as b, type ConsumerNext as c, type KernelDependencyInjectionOptions as d, type KernelOptions as e, createKernel as f };

package/dist/Subscription-4vuAAxax.d.cts

@@ -0,0 +1,23 @@
+import { M as Message, H as HandlerContext, D as DomainEvent } from './HandlerContext-Lm89pSeG.cjs';
+import { D as DomainEvent$1 } from './DomainEvent-mXWEtr_J.cjs';
+
+type MessageHandler<TMessage extends Message = Message, TResult = unknown> = (message: TMessage, context: HandlerContext) => TResult | Promise<TResult>;
+
+interface PublishContext<TMessage extends Message | DomainEvent = Message> {
+    readonly domainEvent?: DomainEvent$1;
+    readonly message: TMessage;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly topic: string;
+}
+
+interface PublisherHook {
+    afterPublish?(context: PublishContext): Promise<void> | void;
+    beforePublish?(context: PublishContext): Promise<void> | void;
+    onPublishError?(error: unknown, context: PublishContext): Promise<void> | void;
+}
+
+interface Subscription {
+    close(): Promise<void>;
+}
+
+export type { MessageHandler as M, PublishContext as P, Subscription as S, PublisherHook as a };

package/dist/Subscription-vtF0lEHP.d.ts

@@ -0,0 +1,23 @@
+import { M as Message, H as HandlerContext, D as DomainEvent } from './HandlerContext-DUUExVo3.js';
+import { D as DomainEvent$1 } from './DomainEvent-mXWEtr_J.js';
+
+type MessageHandler<TMessage extends Message = Message, TResult = unknown> = (message: TMessage, context: HandlerContext) => TResult | Promise<TResult>;
+
+interface PublishContext<TMessage extends Message | DomainEvent = Message> {
+    readonly domainEvent?: DomainEvent$1;
+    readonly message: TMessage;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly topic: string;
+}
+
+interface PublisherHook {
+    afterPublish?(context: PublishContext): Promise<void> | void;
+    beforePublish?(context: PublishContext): Promise<void> | void;
+    onPublishError?(error: unknown, context: PublishContext): Promise<void> | void;
+}
+
+interface Subscription {
+    close(): Promise<void>;
+}
+
+export type { MessageHandler as M, PublishContext as P, Subscription as S, PublisherHook as a };