@hg-ts/cqrs 0.1.23

package/src/cqrs.module.ts

@@ -0,0 +1,120 @@
+import { WillNeverHappenedException } from '@hg-ts/exception';
+import {
+	Dependency,
+	DiscoveryService,
+	INIT_HOOK,
+	Module,
+} from '@hg-ts/ioc';
+import assert from 'node:assert/strict';
+import {
+	BaseCommand,
+	BaseCommandHandler,
+	BaseQuery,
+	BaseQueryHandler,
+} from './abstracts';
+
+import {
+	COMMAND_HANDLER_METADATA,
+	QUERY_HANDLER_METADATA,
+} from './decorators';
+import {
+	CommandExecutor,
+	QueryExecutor,
+} from './executors';
+
+@Module({
+	providers: [
+		CommandExecutor,
+		QueryExecutor,
+	],
+	exports: [
+		CommandExecutor,
+		QueryExecutor,
+	],
+	discovery: true,
+
+})
+export class CqrsModule {
+	@Dependency()
+	private readonly discoveryService: DiscoveryService;
+
+	@Dependency()
+	private readonly commandExecutor: CommandExecutor;
+
+	@Dependency()
+	private readonly queryExecutor: QueryExecutor;
+
+	public async [INIT_HOOK](): Promise<void> {
+		const providers = this.discoveryService.getProviders()
+			.filter(wrapper => wrapper.instance)
+			.map(wrapper => wrapper.instance);
+
+		providers.forEach(provider => {
+			const handlerCtor = Object.getPrototypeOf(provider)!.constructor;
+
+			const isCommandHandler = this.isCommandHandler(provider);
+			const isQueryHandler = this.isQueryHandler(provider);
+
+			const commandMetadata = this.getCommandMetadata(handlerCtor);
+			const queryMetadata = this.getQueryMetadata(handlerCtor);
+
+			if (isCommandHandler && commandMetadata) {
+				this.commandExecutor['addHandler'](commandMetadata, provider);
+				return;
+			}
+
+			if (isCommandHandler) {
+				throw new WillNeverHappenedException('Command handler instance provided without CommandHandler decorator');
+			}
+
+			if (commandMetadata) {
+				throw new WillNeverHappenedException('CommandHandler decorate class that does not extended BaseCommandHandler');
+			}
+
+			if (isQueryHandler && queryMetadata) {
+				this.queryExecutor['addHandler'](queryMetadata, provider);
+				return;
+			}
+
+			if (isQueryHandler) {
+				throw new WillNeverHappenedException('Query handler instance provided without QueryHandler decorator');
+			}
+
+			if (queryMetadata) {
+				throw new WillNeverHappenedException('QueryHandler decorate class that does not extended BaseQueryHandler');
+			}
+		});
+	}
+
+	private getCommandMetadata(handlerCtor: Class<any, any[]>): Nullable<Class<BaseCommand, any[]>> {
+		const metadata = Reflect.getMetadata(COMMAND_HANDLER_METADATA, handlerCtor);
+
+		if (!metadata) {
+			return null;
+		}
+
+		assert.ok(metadata.prototype instanceof BaseCommand);
+
+		return metadata;
+	}
+
+	private getQueryMetadata(handlerCtor: Class<any, any[]>): Nullable<Class<BaseQuery<any>, any[]>> {
+		const metadata = Reflect.getMetadata(QUERY_HANDLER_METADATA, handlerCtor);
+
+		if (!metadata) {
+			return null;
+		}
+
+		assert.ok(metadata.prototype instanceof BaseQuery);
+
+		return metadata;
+	}
+
+	private isCommandHandler(provider: any): provider is BaseCommandHandler<BaseCommand<any>> {
+		return provider instanceof BaseCommandHandler;
+	}
+
+	private isQueryHandler(provider: any): provider is BaseQueryHandler<BaseQuery<any>> {
+		return provider instanceof BaseQueryHandler;
+	}
+}

package/src/decorators/command-handler.decorator.ts

@@ -0,0 +1,14 @@
+import {
+	BaseCommand,
+	BaseCommandHandler,
+} from '../abstracts';
+
+export const COMMAND_HANDLER_METADATA = Symbol('COMMAND_HANDLER_METADATA');
+
+export function CommandHandler<Command extends BaseCommand<any>>(
+	commandCtor: Class<Command, any[]>,
+): TypedClassDecorator<Class<BaseCommandHandler<Command>>> {
+	return (ctor: Class<BaseCommandHandler<Command>>) => {
+		Reflect.defineMetadata(COMMAND_HANDLER_METADATA, commandCtor, ctor);
+	};
+}

package/src/decorators/index.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+
+export * from './query-handler.decorator';
+export * from './command-handler.decorator';

package/src/decorators/query-handler.decorator.ts

@@ -0,0 +1,14 @@
+import {
+	BaseQuery,
+	BaseQueryHandler,
+} from '../abstracts';
+
+export const QUERY_HANDLER_METADATA = Symbol('QUERY_HANDLER_METADATA');
+
+export function QueryHandler<Query extends BaseQuery<any>>(
+	queryCtor: Class<Query, any[]>,
+): TypedClassDecorator<Class<BaseQueryHandler<Query>>> {
+	return (ctor: Class<BaseQueryHandler<Query>>) => {
+		Reflect.defineMetadata(QUERY_HANDLER_METADATA, queryCtor, ctor);
+	};
+}

package/src/exceptions/handler-already-added.exception.ts

@@ -0,0 +1,8 @@
+import { BaseException } from '@hg-ts/exception';
+import { BaseCommandOrQuery } from '../types';
+
+export class HandlerAlreadyAddedException extends BaseException {
+	public constructor(command: Class<BaseCommandOrQuery>) {
+		super(`Handler for command "${command.name}" already added`);
+	}
+}

package/src/exceptions/handler-not-found.exception.ts

@@ -0,0 +1,8 @@
+import { BaseException } from '@hg-ts/exception';
+import { BaseCommandOrQuery } from '../types';
+
+export class HandlerNotFoundException extends BaseException {
+	public constructor(command: Class<BaseCommandOrQuery>) {
+		super(`Handler for command "${command.name}" not found`);
+	}
+}

package/src/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from './handler-already-added.exception';
+export * from './handler-not-found.exception';

package/src/executors/command.executor.ts

@@ -0,0 +1,18 @@
+import {
+	BaseCommand,
+	BaseExecutor,
+} from '../abstracts';
+import { CommonResult } from '../types';
+
+export class CommandExecutor extends BaseExecutor<BaseCommand<any>> {
+	protected override async executeHandler<Command extends BaseCommand<any>>(
+		command: Command,
+	): Promise<CommonResult<Command>> {
+		const commandCtor = Object.getPrototypeOf(command)!.constructor as Class<Command>;
+		const handler = this.handlers.get(commandCtor) ?? null;
+
+		this.assertHandler(handler, commandCtor);
+
+		return handler.execute(command);
+	}
+}

package/src/executors/index.ts

@@ -0,0 +1,2 @@
+export * from './command.executor';
+export * from './query.executor';

package/src/executors/query.executor.ts

@@ -0,0 +1,18 @@
+import {
+	BaseQuery,
+	BaseExecutor,
+} from '../abstracts';
+import { CommonResult } from '../types';
+
+export class QueryExecutor extends BaseExecutor<BaseQuery<any>> {
+	protected override async executeHandler<Query extends BaseQuery<any>>(
+		query: Query,
+	): Promise<CommonResult<Query>> {
+		const queryCtor = Object.getPrototypeOf(query)!.constructor as Class<Query>;
+		const handler = this.handlers.get(queryCtor) ?? null;
+
+		this.assertHandler(handler, queryCtor);
+
+		return handler.execute(query);
+	}
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export {
+	BaseQuery,
+	BaseQueryHandler,
+	BaseCommand,
+	BaseCommandHandler,
+} from './abstracts';
+export * from './exceptions';
+export * from './executors';
+export { CommandHandler, QueryHandler } from './decorators';
+export { CqrsModule } from './cqrs.module';

package/src/tests/command-executor.test.ts

@@ -0,0 +1,31 @@
+import { Describe } from '@hg-ts/tests';
+
+import {
+	BaseCommand,
+	BaseCommandHandler,
+	BaseExecutor,
+	BaseExecutorTestSuite,
+} from '../abstracts';
+import { CommandExecutor } from '../executors';
+import { TestCommand } from './commands';
+
+import { TestCommandHandler } from './test-command.handler';
+
+@Describe()
+export class CommandExecutorTest extends BaseExecutorTestSuite<BaseCommand<any>> {
+	protected override getCommandOrQuery(input: string): TestCommand {
+		return new TestCommand(input);
+	}
+
+	protected override getExecutor(): BaseExecutor<BaseCommand<any>> {
+		return new CommandExecutor();
+	}
+
+	protected override getHandler(): BaseCommandHandler<BaseCommand<any>> {
+		return new TestCommandHandler();
+	}
+
+	protected override getCommandOrQueryCtor(): Class<BaseCommand<any>, [string]> {
+		return TestCommand;
+	}
+}

package/src/tests/commands/index.ts

@@ -0,0 +1,2 @@
+export * from './unknown.command';
+export * from './test.command';

package/src/tests/commands/test.command.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../abstracts';
+
+export class TestCommand extends BaseCommand<string> {
+	public readonly expectedResult: string;
+
+	public constructor(expectedResult: string) {
+		super();
+
+		this.expectedResult = expectedResult;
+	}
+}

package/src/tests/commands/unknown.command.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../abstracts';
+
+export class UnknownCommand extends BaseCommand<string> {
+	public readonly expectedResult: string;
+
+	public constructor(expectedResult: string) {
+		super();
+
+		this.expectedResult = expectedResult;
+	}
+}

package/src/tests/cqrs-test.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@hg-ts/ioc';
+import { CqrsModule } from '../cqrs.module';
+import { TestCommandHandler } from './test-command.handler';
+import { TestQueryHandler } from './test-query.handler';
+
+@Module({ imports: [CqrsModule], providers: [TestCommandHandler, TestQueryHandler] })
+export class CqrsTestModule {}

package/src/tests/cqrs.module.test.ts

@@ -0,0 +1,73 @@
+import { TestContainer } from '@hg-ts/ioc';
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+
+import { HandlerNotFoundException } from '../exceptions';
+import {
+	CommandExecutor,
+	QueryExecutor,
+} from '../executors';
+import {
+	TestCommand,
+	UnknownCommand,
+} from './commands';
+import { CqrsTestModule } from './cqrs-test.module';
+import {
+	TestQuery,
+	UnknownQuery,
+} from './queries';
+
+@Describe()
+export class QueryExecutorTest extends Suite {
+	private container: TestContainer;
+	private commandExecutor: CommandExecutor;
+	private queryExecutor: QueryExecutor;
+
+	@Test()
+	public async executorProvides(): Promise<void> {
+		expect(this.commandExecutor).toBeInstanceOf(CommandExecutor);
+		expect(this.queryExecutor).toBeInstanceOf(QueryExecutor);
+	}
+
+	@Test()
+	public async commandSuccess(): Promise<void> {
+		const value = String(Math.random());
+		const result = await this.commandExecutor.execute(new TestCommand(value));
+
+		expect(result).toBe(value);
+	}
+
+	@Test()
+	@ExpectException(HandlerNotFoundException)
+	public async unknownCommand(): Promise<void> {
+		await this.commandExecutor.execute(new UnknownCommand(''));
+	}
+
+	@Test()
+	public async querySuccess(): Promise<void> {
+		const value = String(Math.random());
+		const result = await this.queryExecutor.execute(new TestQuery(value));
+
+		expect(result).toBe(value);
+	}
+
+	@Test()
+	@ExpectException(HandlerNotFoundException)
+	public async unknownQuery(): Promise<void> {
+		await this.queryExecutor.execute(new UnknownQuery(''));
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.container = await TestContainer.create(CqrsTestModule);
+
+		await this.container.init();
+
+		this.queryExecutor = this.container.get(QueryExecutor);
+		this.commandExecutor = this.container.get(CommandExecutor);
+	}
+}

package/src/tests/queries/index.ts

@@ -0,0 +1,2 @@
+export * from './unknown.query';
+export * from './test.query';

package/src/tests/queries/test.query.ts

@@ -0,0 +1,11 @@
+import { BaseQuery } from '../../abstracts';
+
+export class TestQuery extends BaseQuery<string> {
+	public readonly expectedResult: string;
+
+	public constructor(expectedResult: string) {
+		super();
+
+		this.expectedResult = expectedResult;
+	}
+}

package/src/tests/queries/unknown.query.ts

@@ -0,0 +1,11 @@
+import { BaseQuery } from '../../abstracts';
+
+export class UnknownQuery extends BaseQuery<string> {
+	public readonly expectedResult: string;
+
+	public constructor(expectedResult: string) {
+		super();
+
+		this.expectedResult = expectedResult;
+	}
+}

package/src/tests/query-executor.test.ts

@@ -0,0 +1,30 @@
+import { Describe } from '@hg-ts/tests';
+
+import {
+	BaseExecutor,
+	BaseExecutorTestSuite,
+	BaseQuery,
+	BaseQueryHandler,
+} from '../abstracts';
+import { QueryExecutor } from '../executors';
+import { TestQuery } from './queries';
+import { TestQueryHandler } from './test-query.handler';
+
+@Describe()
+export class QueryExecutorTest extends BaseExecutorTestSuite<BaseQuery<any>> {
+	protected override getCommandOrQuery(input: string): TestQuery {
+		return new TestQuery(input);
+	}
+
+	protected override getExecutor(): BaseExecutor<BaseQuery<any>> {
+		return new QueryExecutor();
+	}
+
+	protected override getHandler(): BaseQueryHandler<BaseQuery<any>> {
+		return new TestQueryHandler();
+	}
+
+	protected override getCommandOrQueryCtor(): Class<BaseQuery<any>, [string]> {
+		return TestQuery;
+	}
+}

package/src/tests/test-command.handler.ts

@@ -0,0 +1,17 @@
+import { UnknownException } from '@hg-ts/exception';
+import {
+	BaseCommandHandler,
+	INPUT_FOR_EXCEPTION,
+} from '../abstracts';
+import { CommandHandler } from '../decorators';
+import { TestCommand } from './commands';
+
+@CommandHandler(TestCommand)
+export class TestCommandHandler extends BaseCommandHandler<TestCommand> {
+	public async execute(command: TestCommand): Promise<string> {
+		if (command.expectedResult === INPUT_FOR_EXCEPTION) {
+			throw new UnknownException(command.expectedResult);
+		}
+		return command.expectedResult;
+	}
+}

package/src/tests/test-query.handler.ts

@@ -0,0 +1,18 @@
+import { UnknownException } from '@hg-ts/exception';
+
+import {
+	BaseQueryHandler,
+	INPUT_FOR_EXCEPTION,
+} from '../abstracts';
+import { QueryHandler } from '../decorators';
+import { TestQuery } from './queries';
+
+@QueryHandler(TestQuery)
+export class TestQueryHandler extends BaseQueryHandler<TestQuery> {
+	public async execute(command: TestQuery): Promise<string> {
+		if (command.expectedResult === INPUT_FOR_EXCEPTION) {
+			throw new UnknownException(command.expectedResult);
+		}
+		return command.expectedResult;
+	}
+}

package/src/types.ts

@@ -0,0 +1,29 @@
+import {
+	BaseQuery,
+	BaseCommand,
+	BaseQueryHandler,
+	BaseCommandHandler,
+} from './abstracts';
+
+export type CommandResult<Command extends BaseCommand<any>> = Command extends BaseCommand<infer Result>
+	? Result
+	: never;
+export type QueryResult<Command extends BaseQuery<any>> = Command extends BaseQuery<infer Result>
+	? Result
+	: never;
+
+export type BaseCommandOrQuery = BaseQuery<any> | BaseCommand<any>;
+
+export type CommonHandler<CommandOrQuery extends BaseCommandOrQuery> =
+	CommandOrQuery extends BaseQuery<any>
+		? BaseQueryHandler<CommandOrQuery>
+		: CommandOrQuery extends BaseCommand<any>
+			? BaseCommandHandler<CommandOrQuery>
+			: never;
+
+export type CommonResult<CommandOrQuery extends BaseCommandOrQuery> =
+	CommandOrQuery extends BaseQuery<any>
+		? QueryResult<CommandOrQuery>
+		: CommandOrQuery extends BaseCommand<any>
+			? CommandResult<CommandOrQuery>
+			: never;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "@hg-ts-config/typescript/commonjs",
+	"compilerOptions": {
+		"baseUrl": "src",
+		"rootDir": "src",
+		"outDir": "dist"
+	},
+	"exclude": ["dist"]
+}