Caballerog

import { Middleware } from "./middleware";
import { Server } from "../server";
import { User } from "../interfaces";

export class UserExistsMiddleware extends Middleware {
  public constructor(private server: Server) {
    super();
  }

  public execute({ email, password }: User): boolean {

Caballerog

import { Handler, User } from "../interfaces";

export abstract class Middleware implements Handler {
  private next: Handler;

  public setNextMiddleware(next: Handler): Handler {
    this.next = next;
    return next;
  }
  public abstract execute(user: User): boolean;

Caballerog

export interface User {
  email: string;
  password: string;
}

Caballerog

import { User } from "./user.interface";

export interface Handler {
  setNextMiddleware(handler: Handler): void;

  execute(user: User): boolean;
}

Caballerog

import { Handler } from "./handler";
import { HandlerA } from "./handlerA";
import { HandlerB } from "./handlerB";
import { HandlerC } from "./handlerC";

function clientCode(handler: Handler) {
  const options = ["optionA", "optionB", "optionC"];

  for (const option of options) {
    console.log(`Client: Who does ${option}?`);

Caballerog

import { AbstractHandler } from "./abstract-handler";

export class HandlerA extends AbstractHandler {
  public handle(request: string): string {
    if (request === "optionA") {
      return `A: I'll do the operation -> ${request}.`;
    }
    return super.handle(request);
  }
}

Caballerog

import { Handler } from "./handler";

export abstract class AbstractHandler implements Handler {
  private nextHandler: Handler;

  public setNext(handler: Handler): Handler {
    this.nextHandler = handler;
    return handler;
  }

Caballerog

export interface Handler {
  setNext(handler: Handler): Handler;

  handle(request: string): string;
}

Caballerog

import { ConcreteAgent } from "./concrete-agent";
import { ConcreteAuctioneerA } from "./concrete-auctioneerA";
import { ConcreteAuctioneerB } from "./concrete-auctioneerB";
import { ConcreteAuctioneerC } from "./concrete-auctioneerC";
import { ConcreteAuctioneerD } from "./concrete-auctioneerD";
import { Product } from "./product.model";

const concreteAgent = new ConcreteAgent();

const auctioneerA = new ConcreteAuctioneerA();

Caballerog

import { Agent } from "./agent.interface";
import { Auctioneer } from "./auctioneer.interface";
import { ConcreteAgent } from "./concrete-agent";

export class ConcreteAuctioneerD implements Auctioneer {
  name = "ConcreteAuctioneerD";
  MAX_LIMIT = 1000;

  public update(agent: Agent): void {
    if (!(agent instanceof ConcreteAgent)) {