Uecko_ERP/modules/customer-invoices/src/api/infrastructure/dependencies.ts

import { JsonTaxCatalogProvider, spainTaxCatalogProvider } from "@erp/core";
import type { IMapperRegistry, IPresenterRegistry, ModuleParams } from "@erp/core/api";
import {
  InMemoryMapperRegistry,
  InMemoryPresenterRegistry,
  SequelizeTransactionManager,
} from "@erp/core/api";
import {
  CreateCustomerInvoiceUseCase,
  CustomerInvoiceFullPresenter,
  CustomerInvoiceItemsFullPresenter,
  CustomerInvoiceReportHTMLPresenter,
  CustomerInvoiceReportPDFPresenter,
  DeleteCustomerInvoiceUseCase,
  GetCustomerInvoiceUseCase,
  ListCustomerInvoicesPresenter,
  ListCustomerInvoicesUseCase,
  ReportCustomerInvoiceUseCase,
} from "../application";

import { CustomerInvoiceService } from "../domain";
import { CustomerInvoiceFullMapper, CustomerInvoiceListMapper } from "./mappers";
import { CustomerInvoiceRepository } from "./sequelize";

type InvoiceDeps = {
  transactionManager: SequelizeTransactionManager;
  mapperRegistry: IMapperRegistry;
  presenterRegistry: IPresenterRegistry;
  repo: CustomerInvoiceRepository;
  service: CustomerInvoiceService;
  catalogs: {
    taxes: JsonTaxCatalogProvider;
  };
  build: {
    list: () => ListCustomerInvoicesUseCase;
    get: () => GetCustomerInvoiceUseCase;
    create: () => CreateCustomerInvoiceUseCase;
    //update: () => UpdateCustomerInvoiceUseCase;
    delete: () => DeleteCustomerInvoiceUseCase;
    report: () => ReportCustomerInvoiceUseCase;
  };
};

let _presenterRegistry: IPresenterRegistry | null = null;
let _mapperRegistry: IMapperRegistry | null = null;

let _repo: CustomerInvoiceRepository | null = null;
let _service: CustomerInvoiceService | null = null;
let _catalogs: InvoiceDeps["catalogs"] | null = null;

export function getInvoiceDependencies(params: ModuleParams): InvoiceDeps {
  const { database } = params;
  const transactionManager = new SequelizeTransactionManager(database);
  if (!_catalogs) _catalogs = { taxes: spainTaxCatalogProvider };

  if (!_mapperRegistry) {
    _mapperRegistry = new InMemoryMapperRegistry();
    _mapperRegistry.registerDomainMapper(
      "FULL",
      new CustomerInvoiceFullMapper({
        taxCatalog: _catalogs!.taxes,
      })
    );
    _mapperRegistry.registerReadModelMapper("LIST", new CustomerInvoiceListMapper());
  }
  if (!_repo) _repo = new CustomerInvoiceRepository({ mapperRegistry: _mapperRegistry, database });
  if (!_service) _service = new CustomerInvoiceService(_repo);

  if (!_presenterRegistry) {
    _presenterRegistry = new InMemoryPresenterRegistry();
    _presenterRegistry.registerPresenters([
      {
        key: {
          resource: "customer-invoice-items",
          projection: "FULL",
        },
        presenter: new CustomerInvoiceItemsFullPresenter(_presenterRegistry),
      },
      {
        key: {
          resource: "customer-invoice",
          projection: "FULL",
        },
        presenter: new CustomerInvoiceFullPresenter(_presenterRegistry),
      },

      {
        key: {
          resource: "customer-invoice",
          projection: "LIST",
        },
        presenter: new ListCustomerInvoicesPresenter(_presenterRegistry),
      },

      {
        key: {
          resource: "customer-invoice",
          projection: "REPORT",
          format: "HTML",
        },
        presenter: new CustomerInvoiceReportHTMLPresenter(_presenterRegistry),
      },

      {
        key: {
          resource: "customer-invoice",
          projection: "REPORT",
          format: "PDF",
        },
        presenter: new CustomerInvoiceReportPDFPresenter(_presenterRegistry),
      },
    ]);
  }

  return {
    transactionManager,
    repo: _repo,
    mapperRegistry: _mapperRegistry,
    presenterRegistry: _presenterRegistry,
    service: _service,
    catalogs: _catalogs,

    build: {
      list: () =>
        new ListCustomerInvoicesUseCase(_service!, transactionManager!, _presenterRegistry!),
      get: () => new GetCustomerInvoiceUseCase(_service!, transactionManager!, _presenterRegistry!),
      create: () =>
        new CreateCustomerInvoiceUseCase(
          _service!,
          transactionManager!,
          _presenterRegistry!,
          _catalogs!.taxes
        ),
      /*update: () =>
        new UpdateCustomerInvoiceUseCase(
          _service!,
          transactionManager!,
          _presenterRegistry!,
          _catalogs!.taxes
        ),*/
      delete: () => new DeleteCustomerInvoiceUseCase(_service!, transactionManager!),
      report: () =>
        new ReportCustomerInvoiceUseCase(_service!, transactionManager!, _presenterRegistry!),
    },
  };
}