Проєктування системи класів

pending → paid

PaymentError є Error
ValidationError є Error

class PaymentError extends Error {
  constructor(message) {
    super(message);
    this.name = "PaymentError";
  }
}

const checkout = new CheckoutService({
  paymentGateway,
  notifier,
  discountPolicy,
});

Cart
├── CartWithPercentageDiscount
├── CartWithFixedDiscount
└── CartWithVipDiscount

Cart + DiscountPolicy

node checkout.js

"use strict";

const assert = require("node:assert/strict");

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValidationError";
  }
}

class PaymentError extends Error {
  constructor(message) {
    super(message);
    this.name = "PaymentError";
  }
}

class Product {
  constructor({ id, name, priceCents }) {
    if (!id || typeof id !== "string") {
      throw new ValidationError("Товар повинен мати ідентифікатор");
    }

    if (!name || typeof name !== "string") {
      throw new ValidationError("Товар повинен мати назву");
    }

    if (!Number.isInteger(priceCents) || priceCents < 0) {
      throw new ValidationError(
        "Ціна повинна бути невід'ємним цілим числом у копійках",
      );
    }

    this.id = id;
    this.name = name;
    this.priceCents = priceCents;
  }
}

class Cart {
  #items = new Map();

  add(product, quantity = 1) {
    if (!(product instanceof Product)) {
      throw new ValidationError("До кошика можна додавати лише товари");
    }

    if (!Number.isInteger(quantity) || quantity <= 0) {
      throw new ValidationError("Кількість повинна бути додатним цілим числом");
    }

    const currentQuantity = this.#items.get(product.id)?.quantity ?? 0;

    this.#items.set(product.id, {
      product,
      quantity: currentQuantity + quantity,
    });

    return this;
  }

  remove(productId) {
    this.#items.delete(productId);
    return this;
  }

  get isEmpty() {
    return this.#items.size === 0;
  }

  get items() {
    return [...this.#items.values()].map(({ product, quantity }) => ({
      product,
      quantity,
    }));
  }

  get totalCents() {
    return this.items.reduce(
      (total, item) => total + item.product.priceCents * item.quantity,
      0,
    );
  }
}

class NoDiscount {
  discountCents() {
    return 0;
  }
}

class PercentageDiscount {
  constructor(rate) {
    if (typeof rate !== "number" || rate < 0 || rate > 1) {
      throw new ValidationError(
        "Розмір відсоткової знижки повинен бути між 0 і 1",
      );
    }

    this.rate = rate;
  }

  discountCents(subtotalCents) {
    return Math.floor(subtotalCents * this.rate);
  }
}

class FixedDiscount {
  constructor(amountCents) {
    if (!Number.isInteger(amountCents) || amountCents < 0) {
      throw new ValidationError(
        "Фіксована знижка повинна бути невід'ємним цілим числом",
      );
    }

    this.amountCents = amountCents;
  }

  discountCents(subtotalCents) {
    return Math.min(this.amountCents, subtotalCents);
  }
}

class SequentialDiscount {
  constructor(discounts) {
    if (!Array.isArray(discounts)) {
      throw new ValidationError("Знижки повинні бути масивом");
    }

    for (const discount of discounts) {
      if (
        !discount ||
        typeof discount.discountCents !== "function"
      ) {
        throw new ValidationError(
          "Кожна знижка повинна мати метод discountCents",
        );
      }
    }

    this.discounts = discounts;
  }

  discountCents(subtotalCents) {
    let currentTotal = subtotalCents;

    for (const discount of this.discounts) {
      const discountAmount = discount.discountCents(currentTotal);

      if (
        !Number.isInteger(discountAmount) ||
        discountAmount < 0 ||
        discountAmount > currentTotal
      ) {
        throw new ValidationError("Некоректна сума знижки");
      }

      currentTotal -= discountAmount;
    }

    return subtotalCents - currentTotal;
  }
}

class Order {
  constructor({ id, items, totalCents }) {
    this.id = id;
    this.items = items.map(({ product, quantity }) => ({
      product,
      quantity,
    }));
    this.totalCents = totalCents;
    this.status = "pending";
    this.transactionId = null;
  }

  markPaid(transactionId) {
    if (this.status !== "pending") {
      throw new ValidationError(
        "Оплатити замовлення можна лише зі статусом pending",
      );
    }

    if (!transactionId) {
      throw new ValidationError("Потрібен ідентифікатор транзакції");
    }

    this.status = "paid";
    this.transactionId = transactionId;
  }
}

class CheckoutService {
  constructor({ paymentGateway, notifier, discountPolicy, idGenerator }) {
    if (
      !paymentGateway ||
      typeof paymentGateway.charge !== "function"
    ) {
      throw new ValidationError(
        "Платіжний шлюз повинен мати метод charge",
      );
    }

    if (!notifier || typeof notifier.send !== "function") {
      throw new ValidationError(
        "Сервіс сповіщень повинен мати метод send",
      );
    }

    if (
      !discountPolicy ||
      typeof discountPolicy.discountCents !== "function"
    ) {
      throw new ValidationError(
        "Політика знижок повинна мати метод discountCents",
      );
    }

    if (typeof idGenerator !== "function") {
      throw new ValidationError("Потрібен генератор ідентифікаторів");
    }

    this.paymentGateway = paymentGateway;
    this.notifier = notifier;
    this.discountPolicy = discountPolicy;
    this.idGenerator = idGenerator;
  }

  checkout(cart, customerId) {
    if (!(cart instanceof Cart) || cart.isEmpty) {
      throw new ValidationError("Неможливо оформити порожній кошик");
    }

    if (!customerId || typeof customerId !== "string") {
      throw new ValidationError("Потрібен ідентифікатор клієнта");
    }

    const subtotalCents = cart.totalCents;
    const discountCents =
      this.discountPolicy.discountCents(subtotalCents);
    const totalCents = subtotalCents - discountCents;

    if (totalCents <= 0) {
      throw new ValidationError(
        "Сума замовлення повинна бути більшою за нуль",
      );
    }

    const order = new Order({
      id: this.idGenerator(),
      items: cart.items,
      totalCents,
    });

    const transaction = this.paymentGateway.charge({
      orderId: order.id,
      customerId,
      amountCents: order.totalCents,
    });

    order.markPaid(transaction.id);

    this.notifier.send({
      type: "order.paid",
      orderId: order.id,
      customerId,
      amountCents: order.totalCents,
    });

    return order;
  }
}

class FakePaymentGateway {
  constructor({ shouldFail = false } = {}) {
    this.shouldFail = shouldFail;
    this.charges = [];
  }

  charge({ orderId, customerId, amountCents }) {
    if (this.shouldFail) {
      throw new PaymentError("Платіж відхилено");
    }

    const transaction = {
      id: `transaction-${this.charges.length + 1}`,
      orderId,
      customerId,
      amountCents,
    };

    this.charges.push(transaction);

    return transaction;
  }
}

class MemoryNotifier {
  constructor() {
    this.messages = [];
  }

  send(message) {
    this.messages.push(message);
  }
}

function createIdGenerator() {
  let counter = 0;

  return () => {
    counter += 1;
    return `order-${counter}`;
  };
}

function testSuccessfulCheckout() {
  const coffee = new Product({
    id: "coffee",
    name: "Кава",
    priceCents: 1200,
  });

  const cake = new Product({
    id: "cake",
    name: "Чізкейк",
    priceCents: 1800,
  });

  const cart = new Cart()
    .add(coffee, 2)
    .add(cake);

  assert.equal(cart.totalCents, 4200);

  const discountPolicy = new SequentialDiscount([
    new PercentageDiscount(0.1),
    new FixedDiscount(200),
  ]);

  const paymentGateway = new FakePaymentGateway();
  const notifier = new MemoryNotifier();

  const checkout = new CheckoutService({
    paymentGateway,
    notifier,
    discountPolicy,
    idGenerator: createIdGenerator(),
  });

  const order = checkout.checkout(cart, "customer-1");

  // Після знижки 10% залишається 3780 копійок,
  // після фіксованої знижки — 3580 копійок.
  assert.equal(order.id, "order-1");
  assert.equal(order.totalCents, 3580);
  assert.equal(order.status, "paid");
  assert.equal(order.transactionId, "transaction-1");

  assert.deepEqual(paymentGateway.charges, [
    {
      id: "transaction-1",
      orderId: "order-1",
      customerId: "customer-1",
      amountCents: 3580,
    },
  ]);

  assert.deepEqual(notifier.messages, [
    {
      type: "order.paid",
      orderId: "order-1",
      customerId: "customer-1",
      amountCents: 3580,
    },
  ]);
}

function testEmptyCartIsRejected() {
  const checkout = new CheckoutService({
    paymentGateway: new FakePaymentGateway(),
    notifier: new MemoryNotifier(),
    discountPolicy: new NoDiscount(),
    idGenerator: createIdGenerator(),
  });

  assert.throws(
    () => checkout.checkout(new Cart(), "customer-1"),
    {
      name: "ValidationError",
      message: "Неможливо оформити порожній кошик",
    },
  );
}

function testPaymentFailureDoesNotSendNotification() {
  const product = new Product({
    id: "book",
    name: "Книга",
    priceCents: 2500,
  });

  const cart = new Cart().add(product);

  const paymentGateway = new FakePaymentGateway({
    shouldFail: true,
  });

  const notifier = new MemoryNotifier();

  const checkout = new CheckoutService({
    paymentGateway,
    notifier,
    discountPolicy: new NoDiscount(),
    idGenerator: createIdGenerator(),
  });

  assert.throws(
    () => checkout.checkout(cart, "customer-1"),
    {
      name: "PaymentError",
      message: "Платіж відхилено",
    },
  );

  assert.equal(notifier.messages.length, 0);
  assert.equal(paymentGateway.charges.length, 0);
}

function testOrderCannotBePaidTwice() {
  const order = new Order({
    id: "order-1",
    items: [],
    totalCents: 1000,
  });

  order.markPaid("transaction-1");

  assert.throws(
    () => order.markPaid("transaction-2"),
    {
      name: "ValidationError",
      message: "Оплатити замовлення можна лише зі статусом pending",
    },
  );
}

testSuccessfulCheckout();
testEmptyCartIsRejected();
testPaymentFailureDoesNotSendNotification();
testOrderCannotBePaidTwice();

console.log("Усі тести успішно пройдено");

class Cart {
  #items = new Map();
}

priceCents: 1200

discountCents(subtotalCents)

if (
  !discountPolicy ||
  typeof discountPolicy.discountCents !== "function"
) {
  throw new ValidationError(
    "Політика знижок повинна мати метод discountCents",
  );
}

const weekendDiscount = {
  discountCents(subtotalCents) {
    return Math.floor(subtotalCents * 0.15);
  },
};

const discountPolicy = new SequentialDiscount([
  new PercentageDiscount(0.1),
  new FixedDiscount(200),
]);

const checkout = new CheckoutService({
  paymentGateway,
  notifier,
  discountPolicy,
  idGenerator: createIdGenerator(),
});

class ValidationError extends Error {
  // ...
}

class PaymentError extends Error {
  // ...
}

try {
  checkout.checkout(cart, "customer-1");
} catch (error) {
  if (error instanceof PaymentError) {
    console.log("Потрібно запропонувати інший спосіб оплати");
  } else if (error instanceof ValidationError) {
    console.log("Потрібно виправити дані замовлення");
  } else {
    throw error;
  }
}

pending → paid

markPaid(transactionId) {
  if (this.status !== "pending") {
    throw new ValidationError(
      "Оплатити замовлення можна лише зі статусом pending",
    );
  }

  this.status = "paid";
  this.transactionId = transactionId;
}

pending
payment_failed
paid
processing
shipped
cancelled
refunded

const allowedTransitions = {
  pending: ["paid", "payment_failed", "cancelled"],
  paid: ["processing", "refunded"],
  processing: ["shipped", "cancelled"],
  shipped: [],
  payment_failed: ["pending", "cancelled"],
  cancelled: [],
  refunded: [],
};

const transaction = this.paymentGateway.charge({
  orderId: order.id,
  customerId,
  amountCents: order.totalCents,
});

order.markPaid(transaction.id);

const assert = require("node:assert/strict");

paymentGateway.charges

notifier.messages

class TaxPolicy {
  calculateCents(subtotalCents) {
    return Math.floor(subtotalCents * 0.2);
  }
}

class ShippingPolicy {
  calculateCents({ totalCents }) {
    return totalCents >= 10000 ? 0 : 800;
  }
}

class StripePaymentGateway {
  charge({ orderId, customerId, amountCents }) {
    // Виклик зовнішнього платіжного API
  }
}

class BankPaymentGateway {
  charge({ orderId, customerId, amountCents }) {
    // Виклик банківського API
  }
}

class CheckoutService {
  constructor() {
    this.paymentGateway = new RealPaymentGateway();
    this.notifier = new EmailNotifier();
  }
}

class CheckoutService {
  constructor({ paymentGateway, notifier }) {
    this.paymentGateway = paymentGateway;
    this.notifier = notifier;
  }
}

charge → markPaid → notify

assert.equal(cart.totalCents, 4200);