CQRS Article

abstract-command-handler.ts

abstract class CommandHandler<T extends Command<unknown>> {
  constructor(public readonly type: string) {}

  public abstract async execute(command: T);
}

abstract-command.ts

abstract class Command<T> {
  constructor(public readonly type: string, public readonly payload: T) {}
}

command-bus.ts

class CommandBus {
  constructor(private readonly handlers: CommandHandler<any>[]) {}

  public async execute(command: Command<unknown>) {
    const handler = this.handlers.find(
      (existingHandler) => existingHandler.type === command.type
    );

    if (!handler) {
      throw new Error(`Handler for command: ${command.type} does not exist.`);
    }

    return handler.execute(command);
  }
}

execute-command.ts

const registerCustomerAction = (
  payload: RegisterCustomerPayload,
  context: ApplicationContext
) => context.commandBus.execute(new RegisterCustomerCommand(payload));

get-or-create-product.ts

function getOrCreateProduct(data: ProductData) {
  let existingProduct = productRepository.findByAttributes(data);

  if (!existingProduct) {
    existingProduct = productRepository.save(data);
  }

  return existingProduct;
}

graphql-example.ts

export const resolvers = {
  Mutation: {
    addCardToDeck,
    removeCardFromDeck,
  },
  Query: {
    getCardsForDeck,
  },
};

quey-handler-example.ts

interface GetUserEnrolledDecksQueryHandlerDependencies {
  enrolledDeckRepository: EnrolledDeckRepository;
  deckElasticView: ElasticView<Deck>;
  storageClient: StorageClient;
}

export class GetUserEnrolledDecksQueryHandler extends QueryHandler<
  GetUserEnrolledDecks,
  GetUserEnrolledDecksQueryResult
> {
  constructor(
    private readonly dependencies: GetUserEnrolledDecksQueryHandlerDependencies,
  ) {
    super(GET_USER_ENROLLED_DECKS_QUERY_TYPE);
  }

  public async execute({ payload: { userId } }: GetUserEnrolledDecks) {
    const {
      enrolledDeckRepository,
      deckElasticView,
      storageClient,
    } = this.dependencies;

    const enrolledDecks = await enrolledDeckRepository.getAllByUser(userId);

    const { items } = await deckElasticView.findMany({
      ids: enrolledDecks.map(enrolledDeck => enrolledDeck.getDeckId()),
    });

    return new GetUserEnrolledDecksQueryResult(
      items.map(item => ({
        ...item,
        imgUrl: item.imgUrl
          ? storageClient.getPublicUrlResolver(item.imgUrl)
          : '',
      })),
    );
  }
}

register-customer.command-handler.ts

interface Dependencies {
  customerRepository: CustomerRepository;
}

class RegisterCustomerCommandHandler extends CommandHandler<
  RegisterCustomerCommand
> {
  constructor(private readonly dependencies: Dependencies) {
    super(REGISTER_CUSTOMER_COMMAND_TYPE);
  }

  public async execute({ payload }: RegisterCustomerCommand) {
    const { customerRepository } = this.dependencies;
    const { email } = payload;

    const existingUser = await customerRepository.findByEmail(email);

    if (existingUser) {
      throw new Error(`User with email: "${email}" already exist.`);
    }

    await customerRepository.insert(payload);
  }
}

register-customer.command.ts

interface RegisterCustomerPayload {
  email: string;
  password: string;
  name: string;
}

export const REGISTER_CUSTOMER_COMMAND_TYPE = "customer/register";

class RegisterCustomerCommand extends Command<
  RegisterCustomerPayload
> {
  constructor(payload: RegisterCustomerPayload) {
    super(REGISTER_CUSTOMER_COMMAND_TYPE, payload);
  }
}