fullstack.org.ua

Патерн Repository · fullstack.org.ua

Середній14 хв· Fullstack Team

Патерн Repository

Винесете доступ до даних у репозиторії та відокремите бізнес-логіку від конкретної технології зберігання.

Що таке Repository

Repository — це об’єкт, який приховує доступ до сховища даних і надає застосунку зрозумілий набір операцій:

знайти сутність;
зберегти її;
оновити або видалити;
отримати список сутностей.

Repository відокремлює бізнес-логіку від конкретної технології зберігання. Бізнес-логіка не повинна знати:

чи використовуємо ми PostgreSQL, MongoDB або файлову систему;
як виглядає SQL-запит;
як формується шлях до файлу;
як перетворити результат драйвера бази даних на об’єкт застосунку.

Замість цього сервіс працює з абстракцією репозиторію:

javascript

const order = await orderRepository.findById(orderId);
await orderRepository.save(order);

javascript

async function payOrder(orderId, database) {
  const result = await database.query(
    'SELECT * FROM orders WHERE id = $1',
    [orderId]
  );

  if (result.rows.length === 0) {
    throw new Error('Замовлення не знайдено');
  }

  const order = result.rows[0];

  if (order.status === 'paid') {
    throw new Error('Замовлення вже оплачене');
  }

  await database.query(
    'UPDATE orders SET status = $1 WHERE id = $2',
    ['paid', orderId]
  );
}

javascript

const fs = require('node:fs/promises');
const crypto = require('node:crypto');

class InMemoryOrderRepository {
  constructor() {
    this.orders = new Map();
  }

  async findById(id) {
    return this.orders.get(id) ?? null;
  }

  async save(order) {
    this.orders.set(order.id, { ...order });
    return { ...order };
  }
}

class JsonFileOrderRepository {
  constructor(filePath) {
    this.filePath = filePath;
  }

  async findById(id) {
    const orders = await this.readOrders();
    return orders.find((order) => order.id === id) ?? null;
  }

  async save(order) {
    const orders = await this.readOrders();
    const index = orders.findIndex((item) => item.id === order.id);

    if (index === -1) {
      orders.push({ ...order });
    } else {
      orders[index] = { ...order };
    }

    await fs.writeFile(
      this.filePath,
      JSON.stringify(orders, null, 2),
      'utf8'
    );

    return { ...order };
  }

  async readOrders() {
    try {
      const content = await fs.readFile(this.filePath, 'utf8');
      return JSON.parse(content);
    } catch (error) {
      if (error.code === 'ENOENT') {
        return [];
      }

      throw error;
    }
  }
}

class OrderService {
  constructor(orderRepository) {
    this.orderRepository = orderRepository;
  }

  async createOrder(customer, total) {
    if (!customer || total <= 0) {
      throw new Error('Некоректні дані замовлення');
    }

    const order = {
      id: crypto.randomUUID(),
      customer,
      total,
      status: 'pending'
    };

    return this.orderRepository.save(order);
  }

  async payOrder(orderId) {
    const order = await this.orderRepository.findById(orderId);

    if (!order) {
      throw new Error('Замовлення не знайдено');
    }

    if (order.status === 'paid') {
      throw new Error('Замовлення вже оплачене');
    }

    const paidOrder = {
      ...order,
      status: 'paid'
    };

    return this.orderRepository.save(paidOrder);
  }
}

async function run() {
  const memoryRepository = new InMemoryOrderRepository();
  const memoryService = new OrderService(memoryRepository);

  const memoryOrder = await memoryService.createOrder('Олена', 1500);
  console.log('Створено в памʼяті:', memoryOrder);

  const paidMemoryOrder = await memoryService.payOrder(memoryOrder.id);
  console.log('Оплачено в памʼяті:', paidMemoryOrder);

  const fileRepository = new JsonFileOrderRepository('./orders.json');
  const fileService = new OrderService(fileRepository);

  const fileOrder = await fileService.createOrder('Андрій', 2300);
  console.log('Створено у файлі:', fileOrder);

  const paidFileOrder = await fileService.payOrder(fileOrder.id);
  console.log('Оплачено у файлі:', paidFileOrder);
}

run().catch((error) => {
  console.error(error.message);
  process.exitCode = 1;
});

javascript

class InMemoryOrderRepository {
  constructor() {
    this.orders = new Map();
  }

  async findById(id) {
    return this.orders.get(id) ?? null;
  }

  async save(order) {
    this.orders.set(order.id, { ...order });
    return { ...order };
  }
}

javascript

const repository = new InMemoryOrderRepository();
const service = new OrderService(repository);

const order = await service.createOrder('Олена', 1000);
const paidOrder = await service.payOrder(order.id);

console.log(paidOrder.status); // paid