FactuGES_ERP/modules/companies/src/api/infrastructure/di/companies.di.ts

import { buildTransactionManager, type ModuleParams, type SetupParams } from "@erp/core/api";
import type { IIdentityPublicServices } from "@erp/identity/api";
import type { Sequelize } from "sequelize";

import {
  CompanyPaymentTermResolver,
  CompanyCreator,
  CompanyFinder,
  CompanyPublicFinder,
  CompanyPublicModelMapper,
  CompanyStatusChanger,
  CompanyUpdater,
  CreateCompanyUseCase,
  DisableCompanyUseCase,
  EnableCompanyUseCase,
  FindAvailableCompaniesForAccountUseCase,
  GetCompanyByIdUseCase,
  GetCurrentCompanyUseCase,
  type ICompanyPublicServices,
  UpdateCompanyUseCase,
  UpdateCurrentCompanyUseCase,
  buildCompanyPublicServices,
} from "../../application";
import { SequelizeCompanyDomainMapper, SequelizeCompanyRepository } from "../persistence";
import { resolveCompanyCatalogsDeps } from "./company-catalog-deps.di";

export type CompaniesInternalDeps = {
  repository: SequelizeCompanyRepository;
  publicFinder: CompanyPublicFinder;
  useCases: {
    createCompany: () => CreateCompanyUseCase;
    getCompanyById: () => GetCompanyByIdUseCase;
    getCurrentCompany: () => GetCurrentCompanyUseCase;
    findAvailableCompaniesForAccount: () => FindAvailableCompaniesForAccountUseCase;
    updateCompany: () => UpdateCompanyUseCase;
    updateCurrentCompany: () => UpdateCurrentCompanyUseCase;
    enableCompany: () => EnableCompanyUseCase;
    disableCompany: () => DisableCompanyUseCase;
  };
};

export const buildCompaniesDependencies = (params: ModuleParams): CompaniesInternalDeps => {
  const { database, getService, transactionContext } = params;
  const transactionManager = buildTransactionManager(database as Sequelize, transactionContext);
  const responseMapper = new CompanyPublicModelMapper();
  const identityServices = getService<IIdentityPublicServices>("identity:general");
  const catalogsDeps = resolveCompanyCatalogsDeps(params);

  const repository = new SequelizeCompanyRepository(new SequelizeCompanyDomainMapper(), database);
  const finder = new CompanyFinder(repository);
  const creator = new CompanyCreator(repository);
  const paymentTermResolver = new CompanyPaymentTermResolver({
    paymentTermFinder: catalogsDeps.paymentTerm.finder,
  });
  const updater = new CompanyUpdater({ finder, repository });
  const statusChanger = new CompanyStatusChanger(repository);
  const publicFinder = new CompanyPublicFinder({
    repository,
    mapper: responseMapper,
  });

  return {
    repository,
    publicFinder,
    useCases: {
      createCompany: () =>
        new CreateCompanyUseCase({
          creator,
          responseMapper,
          transactionManager,
        }),
      getCompanyById: () =>
        new GetCompanyByIdUseCase({
          finder,
          responseMapper,
          transactionManager,
        }),
      getCurrentCompany: () =>
        new GetCurrentCompanyUseCase({
          finder,
          responseMapper,
          transactionManager,
        }),
      findAvailableCompaniesForAccount: () =>
        new FindAvailableCompaniesForAccountUseCase({
          identityServices,
          repository,
          responseMapper,
          transactionManager,
        }),
      updateCompany: () =>
        new UpdateCompanyUseCase({
          updater,
          paymentTermResolver,
          responseMapper,
          transactionManager,
        }),
      updateCurrentCompany: () =>
        new UpdateCurrentCompanyUseCase({
          updater,
          paymentTermResolver,
          responseMapper,
          transactionManager,
        }),
      enableCompany: () =>
        new EnableCompanyUseCase({
          finder,
          changer: statusChanger,
          responseMapper,
          transactionManager,
        }),
      disableCompany: () =>
        new DisableCompanyUseCase({
          finder,
          changer: statusChanger,
          responseMapper,
          transactionManager,
        }),
    },
  };
};

export const buildCompaniesPublicServices = (
  _params: SetupParams,
  deps: CompaniesInternalDeps
): ICompanyPublicServices => {
  return buildCompanyPublicServices(deps.publicFinder);
};