Miczeq22

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

Miczeq22

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

Miczeq22

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.`);

Miczeq22

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

export class GetUserEnrolledDecksQueryHandler extends QueryHandler<
  GetUserEnrolledDecks,
  GetUserEnrolledDecksQueryResult
> {

Miczeq22

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

  public abstract async execute(command: T);
}

Miczeq22

interface Dependencies {
  customerRepository: CustomerRepository;
}

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

Miczeq22

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

export const REGISTER_CUSTOMER_COMMAND_TYPE = "customer/register";

class RegisterCustomerCommand extends Command<
  RegisterCustomerPayload

Miczeq22

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

Miczeq22

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

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

  return existingProduct;
}

Miczeq22

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

  public abstract async execute(command: T);
}