node-cqrs 1.0.0-rc.9 → 1.0.0

package/src/interfaces/IObserver.ts

@@ -1,5 +0,0 @@
-import { IObservable } from './IObservable';
-
-export interface IObserver {
-	subscribe(observable: IObservable): void;
-}

package/src/interfaces/IProjection.ts

@@ -1,20 +0,0 @@
-import { IEvent } from './IEvent';
-import { IEventStore } from './IEventStore';
-import { IObserver } from './IObserver';
-
-export interface IProjection<TView> extends IObserver {
-	readonly view: TView;
-
-	subscribe(eventStore: IEventStore): Promise<void>;
-
-	project(event: IEvent): Promise<void>;
-}
-
-export interface IProjectionConstructor {
-	new(c?: any): IProjection<any>;
-	readonly handles?: string[];
-}
-
-export interface IViewFactory<TView> {
-	(options: { schemaVersion: string }): TView;
-}

package/src/interfaces/ISaga.ts

@@ -1,38 +0,0 @@
-import { ICommand } from './ICommand';
-import { Identifier } from './Identifier';
-import { IEvent } from './IEvent';
-import { IEventSet } from './IEventSet';
-
-export interface ISaga {
-
-	/** Unique Saga ID */
-	readonly id: Identifier;
-
-	/** List of commands emitted by Saga */
-	readonly uncommittedMessages: ICommand[];
-
-	/** Main entry point for Saga events */
-	apply(event: IEvent): void | Promise<void>;
-
-	/** Reset emitted commands when they are not longer needed */
-	resetUncommittedMessages(): void;
-
-	onError?(error: Error, options: { event: IEvent, command: ICommand }): void;
-}
-
-export type ISagaConstructorParams = {
-	id: Identifier,
-	events?: IEventSet
-};
-
-export type ISagaFactory = (options: ISagaConstructorParams) => ISaga;
-
-export interface ISagaConstructor {
-	new(options: ISagaConstructorParams): ISaga;
-
-	/** List of event types that trigger new saga start */
-	readonly startsWith: string[];
-
-	/** List of events being handled by Saga */
-	readonly handles: string[];
-}

package/src/interfaces/IViewLocker.ts

@@ -1,46 +0,0 @@
-import { isObject } from './isObject';
-
-/**
- * Interface for managing view restoration state to prevent early access to an inconsistent view
- * or concurrent restoration by another process.
- */
-export interface IViewLocker {
-
-	/**
-	 * Indicates whether the view is fully restored and ready to accept new event projections.
-	 */
-	ready: boolean;
-
-	/**
-	 * Locks the view to prevent external read/write operations.
-	 *
-	 * @returns `true` if the lock is successfully acquired, `false` otherwise.
-	 */
-	lock(): Promise<boolean> | boolean;
-
-	/**
-	 * Unlocks the view, allowing external read/write operations to resume.
-	 */
-	unlock(): Promise<void> | void;
-
-	/**
-	 * Waits until the view is fully restored and ready to accept new events.
-	 *
-	 * @param eventType The event type to listen for (`"ready"`).
-	 * @returns A promise that resolves when the view is ready.
-	 */
-	once(eventType: 'ready'): Promise<void>;
-}
-
-/**
- * Checks if a given object conforms to the `IViewLocker` interface.
- *
- * @param view The object to check.
- * @returns `true` if the object implements `IViewLocker`, `false` otherwise.
- */
-export const isViewLocker = (view: unknown): view is IViewLocker =>
-	isObject(view)
-	&& 'ready' in view
-	&& 'lock' in view
-	&& 'unlock' in view
-	&& 'once' in view;

package/src/interfaces/Identifier.ts

@@ -1 +0,0 @@
-export type Identifier = string | number;

package/src/interfaces/index.ts

@@ -1,26 +0,0 @@
-export * from './IAggregate';
-export * from './IAggregateSnapshotStorage';
-export * from './ICommand';
-export * from './ICommandBus';
-export * from './IContainer';
-export * from './Identifier';
-export * from './IDispatchPipelineProcessor';
-export * from './IEvent';
-export * from './IEventBus';
-export * from './IEventDispatcher';
-export * from './IEventLocker';
-export * from './IEventReceptor';
-export * from './IEventSet';
-export * from './IEventStorage';
-export * from './IEventStore';
-export * from './IEventStream';
-export * from './IIdentifierProvider';
-export * from './ILogger';
-export * from './IMessage';
-export * from './IMessageBus';
-export * from './IObjectStorage';
-export * from './IObservable';
-export * from './IObserver';
-export * from './IProjection';
-export * from './ISaga';
-export * from './IViewLocker';

package/src/interfaces/isObject.ts

@@ -1,5 +0,0 @@
-export const isObject = (obj: unknown): obj is {} =>
-	typeof obj === 'object'
-	&& obj !== null
-	&& !(obj instanceof Date)
-	&& !Array.isArray(obj);

package/src/rabbitmq/IContainer.ts

@@ -1,16 +0,0 @@
-import { IEventBus } from '../interfaces';
-import { RabbitMqEventInjector } from './RabbitMqEventInjector';
-import { RabbitMqGateway } from './RabbitMqGateway';
-
-declare module '../interfaces/IContainer' {
-	interface IContainer {
-		rabbitMqGateway?: RabbitMqGateway;
-		rabbitMqEventInjector?: RabbitMqEventInjector;
-		rabbitMqEventBus?: RabbitMqEventInjector;
-
-		/**
-		 * Optional external event bus for publishing events to an external system.
-		 */
-		externalEventBus?: IEventBus;
-	}
-}

package/src/rabbitmq/RabbitMqEventBus.ts

@@ -1,104 +0,0 @@
-import { IEvent, IEventBus, IDispatchPipelineProcessor, IMessageHandler, IObservable, DispatchPipelineBatch } from '../interfaces';
-import { DEFAULT_EXCHANGE } from './constants';
-import { RabbitMqGateway } from './RabbitMqGateway';
-
-const ALL_EVENTS_WILDCARD = '*';
-
-export class RabbitMqEventBus implements IEventBus, IDispatchPipelineProcessor {
-
-	static get allEventsWildcard(): '*' {
-		return ALL_EVENTS_WILDCARD;
-	}
-
-	#gateway: RabbitMqGateway;
-	#queues = new Map<string, RabbitMqEventBus>();
-	#exchange: string;
-	#queueName: string | undefined;
-
-	constructor(o: {
-		rabbitMqGateway: RabbitMqGateway,
-		exchange?: string,
-		queueName?: string
-	}) {
-		this.#gateway = o.rabbitMqGateway;
-		this.#exchange = o.exchange ?? DEFAULT_EXCHANGE;
-		this.#queueName = o.queueName;
-	}
-
-
-	/**
-	 * Publishes an event to the fanout exchange.
-	 * The event will be delivered to all subscribers, except this instance's own consumer.
-	 */
-	async publish(event: IEvent): Promise<void> {
-		await this.#gateway.publish(this.#exchange, event);
-	}
-
-	/**
-	 * Registers a message handler for a specific event type.
-	 *
-	 * @param eventType The event type to listen for.
-	 * @param handler The function to handle incoming messages of the specified type.
-	 */
-	async on(eventType: string, handler: IMessageHandler): Promise<void> {
-		await this.#gateway.subscribe({
-			exchange: this.#exchange,
-			queueName: this.#queueName,
-			eventType,
-			handler,
-			ignoreOwn: !this.#queueName
-		});
-	}
-
-	/**
-	 * Removes a previously registered message handler for a specific event type.
-	 */
-	off(eventType: string, handler: IMessageHandler): void {
-		this.#gateway.unsubscribe({
-			exchange: this.#exchange,
-			queueName: this.#queueName,
-			eventType,
-			handler
-		});
-	}
-
-	/**
-	 * Returns a new instance of RabbitMqGateway that uses a durable queue with the given name.
-	 * This ensures that all messages published to the fanout exchange are also delivered to this queue.
-	 *
-	 * @param name The name of the durable queue.
-	 * @returns A new RabbitMqGateway instance configured to use the specified queue.
-	 */
-	queue(name: string): IObservable {
-		let queue = this.#queues.get(name);
-		if (!queue) {
-			queue = new RabbitMqEventBus({
-				rabbitMqGateway: this.#gateway,
-				exchange: this.#exchange,
-				queueName: name
-			});
-			this.#queues.set(name, queue);
-		}
-		return queue;
-	}
-
-	/**
-	 * Processes a batch of events and publishes them to the fanout exchange.
-	 *
-	 * This method is part of the `IDispatchPipelineProcessor` interface.
-	 */
-	async process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch> {
-		for (const { event, origin } of batch) {
-			// Skip publishing if the event was dispatched from external source
-			if (origin === 'external')
-				continue;
-
-			if (!event)
-				throw new Error('Event batch does not contain `event`');
-
-			await this.publish(event);
-		}
-
-		return batch;
-	}
-}

package/src/rabbitmq/RabbitMqEventInjector.ts

@@ -1,66 +0,0 @@
-import { IContainer } from '../interfaces/IContainer';
-import { IMessage } from '../interfaces/IMessage';
-import { RabbitMqGateway } from './RabbitMqGateway';
-import { IEventDispatcher } from '../interfaces';
-import * as Event from '../Event';
-import { DEFAULT_EXCHANGE } from './constants';
-
-/**
- * Injects events received from a RabbitMQ exchange into the local event dispatcher.
- *
- * It subscribes to a specified fanout exchange on RabbitMQ and dispatches
- * any received messages as events using the provided event dispatcher.
- */
-export class RabbitMqEventInjector {
-	#rabbitMqGateway: RabbitMqGateway;
-	#messageHandler: (message: IMessage) => Promise<void>;
-	#eventDispatcher: IEventDispatcher;
-	#logger: IContainer['logger'];
-
-	constructor(container: Partial<Pick<IContainer, 'eventDispatcher' | 'rabbitMqGateway' | 'logger'>>) {
-		if (!container.eventDispatcher)
-			throw new Error('eventDispatcher is required in the container.');
-		if (!container.rabbitMqGateway)
-			throw new Error('rabbitMqGateway is required in the container.');
-
-		this.#rabbitMqGateway = container.rabbitMqGateway;
-		this.#messageHandler = (msg: IMessage) => this.#handleMessage(msg);
-		this.#eventDispatcher = container.eventDispatcher;
-		this.#logger = container.logger && 'child' in container.logger ?
-			container.logger.child({ service: new.target.name }) :
-			container.logger;
-	}
-
-	async start(exchange: string = DEFAULT_EXCHANGE): Promise<void> {
-		this.#logger?.debug(`Subscribing to messages from exchange "${exchange}"...`);
-
-		await this.#rabbitMqGateway.subscribeToFanout(exchange, this.#messageHandler);
-
-		this.#logger?.debug(`Listening to messages from exchange "${exchange}"`);
-	}
-
-	async stop(exchange: string = DEFAULT_EXCHANGE): Promise<void> {
-		this.#logger?.debug(`Unsubscribing from messages from exchange "${exchange}"...`);
-
-		await this.#rabbitMqGateway.unsubscribe({
-			exchange,
-			handler: this.#messageHandler
-		});
-
-		this.#logger?.debug(`Stopped listening to messages from exchange "${exchange}"`);
-	}
-
-	async #handleMessage(message: IMessage): Promise<void> {
-		this.#logger?.debug(`"${Event.describe(message)}" received`);
-		try {
-			await this.#eventDispatcher.dispatch([message], { origin: 'external' });
-
-			this.#logger?.debug(`${Event.describe(message)} dispatched successfully`);
-		}
-		catch (error: any) {
-			this.#logger?.error(`Failed to dispatch event ${message.type}: ${error.message}`, { stack: error.stack });
-
-			throw error; // Re-throw to ensure message is nack'd by the gateway
-		}
-	}
-}