Assist_Design/apps/bff/src/modules/id-mappings/validation/mapping-validator.service.ts

import { Injectable, Inject } from "@nestjs/common";
import { Logger } from "nestjs-pino";
import {
  CreateMappingRequest,
  UpdateMappingRequest,
  MappingValidationResult,
  UserIdMapping,
} from "../types/mapping.types";

@Injectable()
export class MappingValidatorService {
  constructor(@Inject(Logger) private readonly logger: Logger) {}

  validateCreateRequest(request: CreateMappingRequest): MappingValidationResult {
    const errors: string[] = [];
    const warnings: string[] = [];
    if (!request.userId) {
      errors.push("User ID is required");
    } else if (!this.isValidUuid(request.userId)) {
      errors.push("User ID must be a valid UUID");
    }
    if (!request.whmcsClientId) {
      errors.push("WHMCS client ID is required");
    } else if (!Number.isInteger(request.whmcsClientId) || request.whmcsClientId < 1) {
      errors.push("WHMCS client ID must be a positive integer");
    }
    if (request.sfAccountId) {
      if (!this.isValidSalesforceId(request.sfAccountId)) {
        errors.push("Salesforce account ID must be a valid 15 or 18 character ID");
      }
    } else {
      warnings.push("Salesforce account ID not provided - mapping will be incomplete");
    }
    return { isValid: errors.length === 0, errors, warnings };
  }

  validateUpdateRequest(userId: string, request: UpdateMappingRequest): MappingValidationResult {
    const errors: string[] = [];
    const warnings: string[] = [];
    if (!userId) {
      errors.push("User ID is required");
    } else if (!this.isValidUuid(userId)) {
      errors.push("User ID must be a valid UUID");
    }
    if (!request.whmcsClientId && !request.sfAccountId) {
      errors.push("At least one field must be provided for update");
    }
    if (request.whmcsClientId !== undefined) {
      if (!Number.isInteger(request.whmcsClientId) || request.whmcsClientId < 1) {
        errors.push("WHMCS client ID must be a positive integer");
      }
    }
    if (request.sfAccountId !== undefined) {
      if (request.sfAccountId && !this.isValidSalesforceId(request.sfAccountId)) {
        errors.push("Salesforce account ID must be a valid 15 or 18 character ID");
      }
    }
    return { isValid: errors.length === 0, errors, warnings };
  }

  validateExistingMapping(mapping: UserIdMapping): MappingValidationResult {
    const errors: string[] = [];
    const warnings: string[] = [];
    if (!mapping.userId || !this.isValidUuid(mapping.userId)) {
      errors.push("Invalid user ID in existing mapping");
    }
    if (!mapping.whmcsClientId || !Number.isInteger(mapping.whmcsClientId) || mapping.whmcsClientId < 1) {
      errors.push("Invalid WHMCS client ID in existing mapping");
    }
    if (mapping.sfAccountId && !this.isValidSalesforceId(mapping.sfAccountId)) {
      errors.push("Invalid Salesforce account ID in existing mapping");
    }
    if (!mapping.sfAccountId) {
      warnings.push("Mapping is missing Salesforce account ID");
    }
    return { isValid: errors.length === 0, errors, warnings };
  }

  validateBulkMappings(mappings: CreateMappingRequest[]): Array<{ index: number; validation: MappingValidationResult }> {
    return mappings.map((mapping, index) => ({ index, validation: this.validateCreateRequest(mapping) }));
  }

  validateNoConflicts(request: CreateMappingRequest, existingMappings: UserIdMapping[]): MappingValidationResult {
    const errors: string[] = [];
    const warnings: string[] = [];
    const duplicateUser = existingMappings.find(m => m.userId === request.userId);
    if (duplicateUser) {
      errors.push(`User ${request.userId} already has a mapping`);
    }
    const duplicateWhmcs = existingMappings.find(m => m.whmcsClientId === request.whmcsClientId);
    if (duplicateWhmcs) {
      errors.push(`WHMCS client ${request.whmcsClientId} is already mapped to user ${duplicateWhmcs.userId}`);
    }
    if (request.sfAccountId) {
      const duplicateSf = existingMappings.find(m => m.sfAccountId === request.sfAccountId);
      if (duplicateSf) {
        warnings.push(`Salesforce account ${request.sfAccountId} is already mapped to user ${duplicateSf.userId}`);
      }
    }
    return { isValid: errors.length === 0, errors, warnings };
  }

  validateDeletion(mapping: UserIdMapping): MappingValidationResult {
    const errors: string[] = [];
    const warnings: string[] = [];
    if (!mapping) {
      errors.push("Cannot delete non-existent mapping");
      return { isValid: false, errors, warnings };
    }
    warnings.push("Deleting this mapping will prevent access to WHMCS/Salesforce data for this user");
    if (mapping.sfAccountId) {
      warnings.push("This mapping includes Salesforce integration - deletion will affect case management");
    }
    return { isValid: true, errors, warnings };
  }

  sanitizeCreateRequest(request: CreateMappingRequest): CreateMappingRequest {
    return {
      userId: request.userId?.trim(),
      whmcsClientId: Number(request.whmcsClientId),
      sfAccountId: request.sfAccountId?.trim() || undefined,
    };
  }

  sanitizeUpdateRequest(request: UpdateMappingRequest): UpdateMappingRequest {
    const sanitized: UpdateMappingRequest = {};
    if (request.whmcsClientId !== undefined) {
      sanitized.whmcsClientId = Number(request.whmcsClientId);
    }
    if (request.sfAccountId !== undefined) {
      sanitized.sfAccountId = request.sfAccountId?.trim() || undefined;
    }
    return sanitized;
  }

  private isValidUuid(uuid: string): boolean {
    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    return uuidRegex.test(uuid);
  }

  private isValidSalesforceId(sfId: string): boolean {
    if (!sfId) return false;
    const sfIdRegex = /^[a-zA-Z0-9]{15}$|^[a-zA-Z0-9]{18}$/;
    return sfIdRegex.test(sfId);
  }
}