Uecko_ERP/modules/customer-invoices/src/api/infrastructure/sequelize/customer-invoice.repository.ts

import { SequelizeRepository, errorMapper } from "@erp/core/api";
import { Criteria, CriteriaToSequelizeConverter } from "@repo/rdx-criteria/server";
import { UniqueID } from "@repo/rdx-ddd";
import { Collection, Result } from "@repo/rdx-utils";
import { Sequelize, Transaction } from "sequelize";
import { CustomerInvoice, ICustomerInvoiceRepository } from "../../domain";
import { ICustomerInvoiceMapper } from "../mappers/customer-invoice.mapper";
import { CustomerInvoiceModel } from "./customer-invoice.model";

export class CustomerInvoiceRepository
  extends SequelizeRepository<CustomerInvoice>
  implements ICustomerInvoiceRepository
{
  //private readonly model: typeof CustomerInvoiceModel;
  private readonly mapper!: ICustomerInvoiceMapper;

  constructor(database: Sequelize, mapper: ICustomerInvoiceMapper) {
    super(database);

    //CustomerInvoice = database.model("CustomerInvoice") as typeof CustomerInvoiceModel;
    this.mapper = mapper;
  }

  async existsById(id: UniqueID, transaction?: Transaction): Promise<Result<boolean, Error>> {
    try {
      const result = await this._exists(CustomerInvoiceModel, "id", id.toString(), transaction);

      return Result.ok(Boolean(result));
    } catch (err: unknown) {
      return Result.fail(errorMapper.toDomainError(err));
    }
  }

  /**
   *
   * Persiste una nueva factura o actualiza una existente.
   *
   * @param invoice - El agregado a guardar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error>
   */
  async save(
    invoice: CustomerInvoice,
    transaction: Transaction
  ): Promise<Result<CustomerInvoice, Error>> {
    try {
      const data = this.mapper.mapToPersistence(invoice);
      await CustomerInvoiceModel.upsert(data, { transaction });
      return Result.ok(invoice);
    } catch (err: unknown) {
      return Result.fail(errorMapper.toDomainError(err));
    }
  }

  /**
   *
   * Busca una factura por su identificador único.
   * @param id - UUID de la factura.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice, Error>
   */
  async findById(id: UniqueID, transaction: Transaction): Promise<Result<CustomerInvoice, Error>> {
    try {
      const rawData = await this._findById(CustomerInvoiceModel, id.toString(), { transaction });

      if (!rawData) {
        return Result.fail(new Error(`Invoice with id ${id} not found.`));
      }

      return this.mapper.mapToDomain(rawData);
    } catch (err: unknown) {
      return Result.fail(errorMapper.toDomainError(err));
    }
  }

  /**
   *
   * Consulta facturas usando un objeto Criteria (filtros, orden, paginación).
   * @param criteria - Criterios de búsqueda.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<CustomerInvoice[], Error>
   *
   * @see Criteria
   */
  public async findByCriteria(
    criteria: Criteria,
    transaction: Transaction
  ): Promise<Result<Collection<CustomerInvoice>, Error>> {
    try {
      const converter = new CriteriaToSequelizeConverter();
      const query = converter.convert(criteria);

      const instances = await CustomerInvoiceModel.findAll({
        ...query,
        transaction,
      });

      return this.mapper.mapArrayToDomain(instances);
    } catch (err: unknown) {
      return Result.fail(errorMapper.toDomainError(err));
    }
  }

  /**
   *
   * Elimina o marca como eliminada una factura.
   * @param id - UUID de la factura a eliminar.
   * @param transaction - Transacción activa para la operación.
   * @returns Result<void, Error>
   */
  async deleteById(id: UniqueID, transaction: any): Promise<Result<void, Error>> {
    try {
      await this._deleteById(CustomerInvoiceModel, id, false, transaction);
      return Result.ok<void>();
    } catch (err: unknown) {
      return Result.fail(errorMapper.toDomainError(err));
    }
  }
}