feat: typed results

src/command-bus.ts

@@ -8,6 +8,7 @@ import {
 import { CommandHandlerNotFoundException } from './exceptions/command-not-found.exception';
 import { DefaultCommandPubSub } from './helpers/default-command-pubsub';
 import { InvalidCommandHandlerException } from './index';
+import { Command } from './interfaces/commands/command';
 import { CommandMetadata } from './interfaces/commands/command-metadata.interface';
 import {
   ICommand,
@@ -54,6 +55,8 @@ export class CommandBus<CommandBase extends ICommand = ICommand>
    * @param command The command to execute.
    * @returns A promise that, when resolved, will contain the result returned by the command's handler.
    */
+  execute<R = void>(query: Command<R>): Promise<R>;
+  execute<T extends CommandBase, R = any>(command: T): Promise<R>;
   execute<T extends CommandBase, R = any>(command: T): Promise<R> {
     const commandId = this.getCommandId(command);
     const handler = this.handlers.get(commandId);

src/interfaces/commands/command-bus.interface.ts

@@ -1,3 +1,4 @@
+import { Command } from './command';
 import { ICommand } from './command.interface';
 
 /**
@@ -8,5 +9,6 @@ export interface ICommandBus<CommandBase extends ICommand = ICommand> {
    * Executes a command.
    * @param command The command to execute.
    */
+  execute<R = void>(query: Command<R>): Promise<R>;
   execute<T extends CommandBase, R = any>(command: T): Promise<R>;
 }

src/interfaces/commands/command-handler.interface.ts

@@ -1,13 +1,22 @@
+import { Command } from './command';
 import { ICommand } from './command.interface';
 
 /**
  * Represents a command handler.
  * Command handlers are used to execute commands.
  */
-export interface ICommandHandler<
-  TCommand extends ICommand = any,
-  TResult = any,
-> {
+export type ICommandHandler<
+  CommandType extends ICommand = any,
+  TRes = any,
+> = CommandType extends Command<infer ResultType>
+  ? BaseICommandHandler<CommandType, ResultType>
+  : BaseICommandHandler<CommandType, TRes>;
+
+/**
+ * Basic interface for CommandHandlers
+ * Can be used for both: inferred and declared return types
+ */
+interface BaseICommandHandler<TCommand extends ICommand = any, TResult = any> {
   /**
    * Executes a command.
    * @param command The command to execute.

src/interfaces/commands/command-result.type.ts

@@ -0,0 +1,4 @@
+import { Command } from './command';
+
+export type CommandResult<CommandT extends Command<unknown>> =
+  CommandT extends Command<infer ResultT> ? ResultT : never;

src/interfaces/commands/command.ts

@@ -0,0 +1,5 @@
+import { ICommand } from './command.interface';
+
+export class Command<T> implements ICommand {
+  resultType$e1ca39fa!: T;
+}

src/interfaces/index.ts

@@ -1,6 +1,8 @@
+export * from './commands/command';
 export * from './commands/command-bus.interface';
 export * from './commands/command-handler.interface';
 export * from './commands/command-publisher.interface';
+export * from './commands/command-result.type';
 export * from './commands/command.interface';
 export * from './events/event-bus.interface';
 export * from './events/event-handler.interface';
@@ -9,9 +11,11 @@ export * from './events/event.interface';
 export * from './events/message-source.interface';
 export * from './exceptions/unhandled-exception-info.interface';
 export * from './exceptions/unhandled-exception-publisher.interface';
+export * from './queries/query';
 export * from './queries/query-bus.interface';
 export * from './queries/query-handler.interface';
 export * from './queries/query-publisher.interface';
 export * from './queries/query-result.interface';
+export * from './queries/query-result.type';
 export * from './queries/query.interface';
 export * from './saga.type';

src/interfaces/queries/query-handler.interface.ts

@@ -1,9 +1,21 @@
+import { Query } from './query';
 import { IQuery } from './query.interface';
 
 /**
  * Represents a query handler.
  */
-export interface IQueryHandler<T extends IQuery = any, TRes = any> {
+export type IQueryHandler<
+  QueryType extends IQuery = any,
+  TRes = any,
+> = QueryType extends Query<infer ResultType>
+  ? BaseIQueryHandler<QueryType, ResultType>
+  : BaseIQueryHandler<QueryType, TRes>;
+
+/**
+ * Basic interface for QueryHandlers
+ * Can be used for both: inferred and declared return types
+ */
+interface BaseIQueryHandler<T extends IQuery = any, TRes = any> {
   /**
    * Executes a query.
    * @param query The query to execute.

src/interfaces/queries/query-result.type.ts

@@ -0,0 +1,7 @@
+import { Query } from './query';
+
+export type QueryResult<QueryT extends Query<unknown>> = QueryT extends Query<
+  infer ResultT
+>
+  ? ResultT
+  : never;

src/interfaces/queries/query.ts

@@ -0,0 +1,5 @@
+import { IQuery } from './query.interface';
+
+export class Query<T> implements IQuery {
+  resultType$f9fbca36!: T;
+}

src/query-bus.ts

@@ -12,6 +12,7 @@ import {
   IQueryPublisher,
   IQueryResult,
 } from './interfaces';
+import { Query } from './interfaces/queries/query';
 import { QueryMetadata } from './interfaces/queries/query-metadata.interface';
 import { ObservableBus } from './utils/observable-bus';
 
@@ -53,6 +54,8 @@ export class QueryBus<QueryBase extends IQuery = IQuery>
    * Executes a query.
    * @param query The query to execute.
    */
+  execute<TResult>(query: Query<TResult>): Promise<TResult>;
+  execute<T extends QueryBase, TResult = any>(query: T): Promise<TResult>;
   async execute<T extends QueryBase, TResult = any>(
     query: T,
   ): Promise<TResult> {