nigerian-mobile-validator/dist/esm/__tests__/batches/batch-validator.js

The most rigorous, up-to-date library for validating Nigerian mobile numbers. Fully NCC-compliant, and security-focused, with enterprise-grade features to prevent the business risks of validation failures in regulated industries.

// src/number-validation/batch-validator.ts
import * as fs from 'fs';
import { NigerianMobileNumberValidator } from '../../number-validation/nigerian-mobile-number-validator';
import { createObjectCsvWriter } from 'csv-writer';
import Chance from 'chance';
import { TestDataGeneratorBase } from '../synthetic-data/test-data-generator-base';
// Initialize Chance with a seed for reproducibility if needed
const chance = new Chance();
/**
 * Implementation of BatchValidationResults
 */
class BatchValidationResultsImpl {
    constructor(results, validCount, invalidCount, processingTimeMs) {
        this.results = results;
        this.validCount = validCount;
        this.invalidCount = invalidCount;
        this.processingTimeMs = processingTimeMs;
    }
    async exportToCsv(filePath) {
        const csvWriter = createObjectCsvWriter({
            path: filePath,
            header: [
                { id: 'number', title: 'PHONE_NUMBER' },
                { id: 'valid', title: 'IS_VALID' },
                { id: 'status', title: 'STATUS' },
                { id: 'message', title: 'MESSAGE' },
                { id: 'telco', title: 'TELCO' },
                { id: 'networkCode', title: 'NETWORK_CODE' },
                { id: 'msisdn', title: 'INTERNATIONAL_FORMAT' }
            ]
        });
        const records = this.results.map(result => {
            var _a, _b, _c;
            return ({
                number: result.userProvidedDigits,
                valid: result.validationSucceeded ? 'YES' : 'NO',
                status: result.validationStatus,
                message: result.validationSucceeded ? 'Success' : result.userMessage,
                telco: result.validationSucceeded ? (_a = result.mobileNumber) === null || _a === void 0 ? void 0 : _a.telco : '',
                networkCode: result.validationSucceeded ? (_b = result.mobileNumber) === null || _b === void 0 ? void 0 : _b.networkCode : '',
                msisdn: result.validationSucceeded ? (_c = result.mobileNumber) === null || _c === void 0 ? void 0 : _c.msisdn : ''
            });
        });
        await csvWriter.writeRecords(records);
    }
}
/**
 * Validates a batch of Nigerian mobile numbers
 */
export async function batchValidate(numbers, options = {}) {
    var _a, _b;
    const startTime = performance.now();
    const validator = (_a = options.validator) !== null && _a !== void 0 ? _a : new NigerianMobileNumberValidator();
    const concurrency = (_b = options.concurrency) !== null && _b !== void 0 ? _b : 1000;
    let validCount = 0;
    let invalidCount = 0;
    // Process in chunks to avoid memory issues with large arrays
    const results = [];
    // Process in batches based on concurrency
    for (let i = 0; i < numbers.length; i += concurrency) {
        const chunk = numbers.slice(i, i + concurrency);
        const chunkResults = chunk.map(number => {
            const result = validator.validate(number);
            if (result.validationSucceeded) {
                validCount++;
            }
            else {
                invalidCount++;
            }
            return result;
        });
        results.push(...chunkResults);
    }
    const endTime = performance.now();
    const processingTimeMs = endTime - startTime;
    // Clean up if we created the validator
    if (!options.validator) {
        validator.dispose();
    }
    return new BatchValidationResultsImpl(results, validCount, invalidCount, processingTimeMs);
}
/**
 * Additional methods for batch validation
 */
batchValidate.fromFile = async function (filePath, options = {}) {
    try {
        const data = await fs.promises.readFile(filePath, 'utf8');
        const numbers = data
            .split(/\r?\n/)
            .map(line => line.trim())
            .filter(line => line.length > 0);
        return batchValidate(numbers, options);
    }
    catch (error) {
        if (options.continueOnError) {
            return new BatchValidationResultsImpl([], 0, 0, 0);
        }
        throw error;
    }
};
/**
 * Performance testing for batch validation
 */
batchValidate.benchmark = async function (sampleSize = 10000) {
    // Generate test phone numbers (mix of valid and invalid)
    const networkCodes = TestDataGeneratorBase.allValidNetworkCodes.concat(TestDataGeneratorBase.invalidNetworkCodes);
    const numbers = [];
    for (let i = 0; i < sampleSize; i++) {
        const networkCode = chance.pickone(networkCodes);
        const subscriberNumber = TestDataGeneratorBase.randomSubscriberNumber(networkCode);
        numbers.push(`0${networkCode}${subscriberNumber}`);
    }
    const startTime = performance.now();
    await batchValidate(numbers);
    const endTime = performance.now();
    const totalTimeMs = endTime - startTime;
    const validationsPerSecond = Math.floor((sampleSize / totalTimeMs) * 1000);
    const averageValidationTimeMs = totalTimeMs / sampleSize;
    return {
        validationsPerSecond,
        averageValidationTimeMs,
        totalTimeMs
    };
};