edr-platform/apps/edr-freight-api/src/modules/companies/companies.repository.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { BaseRepository } from '@edr/api-common';
import { Company } from './entities/company.entity';
import {
  companyDraftSql,
  companyPendingChangeRequestSql,
} from './company-scope.sql';
import { ListCompaniesQueryDto } from './dto/list-companies-query.dto';
import { CompanyStatsResponseDto } from './dto/company-stats-response.dto';

@Injectable()
export class CompaniesRepository extends BaseRepository<Company> {
  /**
   * A company still being filled in by its owner in the portal wizard: it was
   * self-registered (so it has an external profile) and nobody has submitted
   * onboarding yet. The row exists from the wizard's first click, carrying a
   * placeholder name + TIN, so it must not be offered up for review.
   * Staff-created companies have no external profiles and are never drafts.
   */
  private static readonly DRAFT_SQL = companyDraftSql('company');

  private static readonly PENDING_CHANGE_REQUEST_SQL =
    companyPendingChangeRequestSql('company');

  /**
   * The `sortBy = 'review'` queue ordering: whatever marketing must act on
   * floats to the top. Tier 0 — submitted applications awaiting first approval
   * (drafts excluded: nothing to review yet). Tier 1 — approved customers with
   * a pending change request. Tier 2 — everyone else, drafts included.
   */
  private static readonly REVIEW_TIER_SQL = `(CASE
    WHEN company.status = 'pending' AND NOT ${CompaniesRepository.DRAFT_SQL} THEN 0
    WHEN ${CompaniesRepository.PENDING_CHANGE_REQUEST_SQL} THEN 1
    ELSE 2
  END)`;

  constructor(
    @InjectRepository(Company)
    repo: Repository<Company>,
  ) {
    super(repo);
  }

  async findByTin(tin: string): Promise<Company | null> {
    return this.repository.findOne({ where: { tin } as any });
  }

  async findByType(type: string): Promise<Company[]> {
    return this.repository.find({ where: { type } as any, order: { name: 'ASC' } });
  }

  async findByName(name: string): Promise<Company[]> {
    return this.repository
      .createQueryBuilder('company')
      .where('company.name ILIKE :name', { name: `%${name}%` })
      .getMany();
  }

  async existsByTin(tin: string, excludeCompanyId?: string): Promise<boolean> {
    const qb = this.repository
      .createQueryBuilder('company')
      .where('company.tin = :tin', { tin });
    if (excludeCompanyId) {
      qb.andWhere('company.id != :excludeCompanyId', { excludeCompanyId });
    }
    const count = await qb.getCount();
    return count > 0;
  }

  async findPaginated(
    query: ListCompaniesQueryDto,
  ): Promise<{ items: Company[]; total: number }> {
    const {
      page = 1,
      pageSize = 20,
      search,
      type,
      kind,
      status,
      nationality,
      createdFrom,
      createdTo,
      onboardingCompleted,
      hasPendingChangeRequest,
      profileType,
      sortBy = 'review',
      sortOrder = 'DESC',
    } = query;

    const qb = this.repository
      .createQueryBuilder('company')
      .leftJoinAndSelect('company.companyProfiles', 'companyProfiles')
      // External profiles carry onboardingCompleted, which the backoffice list
      // uses to flag customers still mid-onboarding (not yet reviewable).
      .leftJoinAndSelect('company.profiles', 'profiles')
      .where('company.deleted_at IS NULL');

    if (type) {
      qb.andWhere('company.type = :type', { type });
    }

    if (kind) {
      qb.andWhere('company.kind = :kind', { kind });
    }

    if (status) {
      qb.andWhere('company.status = :status', { status });
    }

    if (nationality) {
      qb.andWhere('company.nationality = :nationality', { nationality });
    }

    if (createdFrom) {
      qb.andWhere('company.createdAt >= :createdFrom', { createdFrom });
    }

    if (createdTo) {
      qb.andWhere('company.createdAt <= :createdTo', { createdTo });
    }

    if (onboardingCompleted !== undefined) {
      qb.andWhere(
        onboardingCompleted
          ? `NOT ${CompaniesRepository.DRAFT_SQL}`
          : CompaniesRepository.DRAFT_SQL,
      );
    }

    if (hasPendingChangeRequest !== undefined) {
      qb.andWhere(
        hasPendingChangeRequest
          ? CompaniesRepository.PENDING_CHANGE_REQUEST_SQL
          : `NOT ${CompaniesRepository.PENDING_CHANGE_REQUEST_SQL}`,
      );
    }

    if (search) {
      const term = `%${search.trim()}%`;
      // Staff search by whatever is in front of them: the company name, the
      // TIN/email, a profile reference off a document — and, since a TIN holds
      // many licences, the trade name or licence number of the specific
      // business a role operates as. All the per-profile terms share one EXISTS
      // so a match on any of them qualifies the company once.
      qb.andWhere(
        `(company.name ILIKE :term
          OR company.tin ILIKE :term
          OR company.email ILIKE :term
          OR company.licence_number ILIKE :term
          OR EXISTS (
            SELECT 1 FROM freight.company_profiles cp
            WHERE cp.company_id = company.id
              AND cp.deleted_at IS NULL
              AND (
                cp.reference ILIKE :term
                OR cp.etrade_business->>'tradeName' ILIKE :term
                OR cp.etrade_business->>'licenceNumber' ILIKE :term
              )
          ))`,
        { term },
      );
    }

    // Companies holding a given operational role. EXISTS rather than a filter
    // on the joined `companyProfiles` alias: constraining the join would drop
    // the company's OTHER profiles from the loaded entity, so the list would
    // render an exporter-and-importer as importer-only.
    if (profileType) {
      qb.andWhere(
        `EXISTS (
          SELECT 1 FROM freight.company_profiles cp_type
          WHERE cp_type.company_id = company.id
            AND cp_type.deleted_at IS NULL
            AND cp_type.type = :profileType
        )`,
        { profileType },
      );
    }

    // sortBy is whitelisted by @IsIn on the DTO, so it is safe to interpolate.
    if (sortBy === 'review') {
      // Queue ordering: actionable tiers first, newest first within each. The
      // tier is selected under an alias because skip/take pagination with
      // joins re-derives the ORDER BY in a subquery — a raw expression there
      // breaks, a selected alias survives.
      qb.addSelect(CompaniesRepository.REVIEW_TIER_SQL, 'review_tier')
        .orderBy('review_tier', 'ASC')
        .addOrderBy('company.createdAt', 'DESC');
    } else {
      qb.orderBy(`company.${sortBy}`, sortOrder);
    }
    const [items, total] = await qb
      // Names are not unique and createdAt can tie on bulk imports; the id
      // tiebreaker keeps paging stable instead of dropping/repeating rows.
      .addOrderBy('company.id', 'ASC')
      .skip((page - 1) * pageSize)
      .take(pageSize)
      .getManyAndCount();

    return { items, total };
  }

  async getStats(): Promise<CompanyStatsResponseDto> {
    // Drafts are counted separately rather than under `pending`: they carry
    // status=pending from creation, which would otherwise inflate the review
    // queue's KPI with customers who haven't submitted anything yet.
    const rows: { status: string; is_draft: boolean; count: string }[] =
      await this.repository
        .createQueryBuilder('company')
        .select('company.status', 'status')
        .addSelect(CompaniesRepository.DRAFT_SQL, 'is_draft')
        .addSelect('COUNT(*)', 'count')
        .where('company.deleted_at IS NULL')
        .groupBy('company.status')
        .addGroupBy(CompaniesRepository.DRAFT_SQL)
        .getRawMany();

    const pendingChanges = await this.repository
      .createQueryBuilder('company')
      .where('company.deleted_at IS NULL')
      .andWhere(CompaniesRepository.PENDING_CHANGE_REQUEST_SQL)
      .getCount();

    const map = new Map<string, number>();
    let onboarding = 0;
    let total = 0;
    for (const row of rows) {
      const count = parseInt(row.count, 10);
      total += count;
      if (row.is_draft) onboarding += count;
      else map.set(row.status, (map.get(row.status) ?? 0) + count);
    }

    return {
      total,
      active: map.get('active') ?? 0,
      pending: map.get('pending') ?? 0,
      onboarding,
      suspended: map.get('suspended') ?? 0,
      blacklisted: map.get('blacklisted') ?? 0,
      pendingChanges,
    };
  }
}