Due Diligence & KYC

// Due Diligence Verification - works in Node.js 18+ and browsers
const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://app.companydata.com/api/company';

interface VerificationResult {
  verified: boolean;
  companyId?: string;
  companyName?: string;
  checks: {
    exists: boolean;
    hasRegistration: boolean;
    hasAddress: boolean;
    hasPhone: boolean;
    yearsInBusiness?: number;
    employeeCount?: number;
    legalStatus?: string;
    isSubsidiary: boolean;
    parentCompany?: string;
  };
  rawData?: Record<string, any>;
}

async function fetchApi<T>(endpoint: string, params: Record<string, string | number>): Promise<T> {
  const url = new URL(`${BASE_URL}/${endpoint}`);
  Object.entries(params).forEach(([key, value]) => {
    if (value) url.searchParams.append(key, String(value));
  });

  const response = await fetch(url.toString(), {
    headers: { 'x-api-key': API_KEY },
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

// Verify by company name and country
async function verifyByName(
  companyName: string,
  countryCode?: string
): Promise<VerificationResult> {
  const params: Record<string, string | number> = {
    search: companyName,
    page: 1,
    pageSize: 1,
  };

  if (countryCode) params.countryCode = countryCode;

  const searchResponse = await fetchApi<{ data: { records: any[] } }>('search', params);

  if (!searchResponse.data?.records?.length) {
    return {
      verified: false,
      checks: {
        exists: false,
        hasRegistration: false,
        hasAddress: false,
        hasPhone: false,
        isSubsidiary: false,
      },
    };
  }

  // Get full details
  return verifyById(searchResponse.data.records[0].ID);
}

// Verify by registration number
async function verifyByRegistration(
  registrationNumber: string,
  countryCode: string
): Promise<VerificationResult> {
  const params: Record<string, string | number> = {
    nationalId: registrationNumber,
    countryCode: countryCode,
    page: 1,
    pageSize: 1,
  };

  const searchResponse = await fetchApi<{ data: { records: any[] } }>('search', params);

  if (!searchResponse.data?.records?.length) {
    return {
      verified: false,
      checks: {
        exists: false,
        hasRegistration: false,
        hasAddress: false,
        hasPhone: false,
        isSubsidiary: false,
      },
    };
  }

  return verifyById(searchResponse.data.records[0].ID);
}

// Verify by BoldData ID
async function verifyById(companyId: string): Promise<VerificationResult> {
  const response = await fetchApi<{ data: { records: any[] } }>('export', {
    ID: companyId,
    page: 1,
    pageSize: 1,
  });

  if (!response.data?.records?.length) {
    return {
      verified: false,
      checks: {
        exists: false,
        hasRegistration: false,
        hasAddress: false,
        hasPhone: false,
        isSubsidiary: false,
      },
    };
  }

  const company = response.data.records[0];
  const currentYear = new Date().getFullYear();
  const foundingYear = company['Founding Year'] ? parseInt(company['Founding Year']) : undefined;

  const checks = {
    exists: true,
    hasRegistration: !!company['Company Registration Number'],
    hasAddress: !!(company['Address 1'] && company['City']),
    hasPhone: !!company['Phone Number'],
    yearsInBusiness: foundingYear ? currentYear - foundingYear : undefined,
    employeeCount: company['Employees Total'] ? parseInt(company['Employees Total']) : undefined,
    legalStatus: getLegalStatusText(company['Business Legal Type']),
    isSubsidiary: company['Subsidiary Code'] === '3',
    parentCompany: company['Global Headquarter Company Name'] || undefined,
  };

  // Company is "verified" if it exists and has basic information
  const verified = checks.exists && (checks.hasRegistration || checks.hasAddress);

  return {
    verified,
    companyId: company['ID'],
    companyName: company['Company Name'],
    checks,
    rawData: company,
  };
}

function getLegalStatusText(code: string): string | undefined {
  const statuses: Record<string, string> = {
    '1': 'Proprietorship',
    '2': 'Partnership',
    '3': 'Corporation',
    '7': 'Partnership',
    '8': 'Joint Venture',
    '9': 'Master Limited Partnership',
    '10': 'General Partnership',
    '11': 'Limited Partnership',
    '13': 'Proprietorship',
    '14': 'Limited Liability',
  };
  return statuses[code];
}

// Example usage
async function main() {
  console.log('=== Verification by Name ===');
  const byName = await verifyByName('Philips', 'NL');
  console.log(`Verified: ${byName.verified}`);
  console.log(`Company: ${byName.companyName}`);
  console.log('Checks:', byName.checks);

  console.log('\n=== Verification by Registration ===');
  const byReg = await verifyByRegistration('17085670', 'NL');
  console.log(`Verified: ${byReg.verified}`);
  console.log(`Company: ${byReg.companyName}`);

  console.log('\n=== Verification by ID ===');
  const byId = await verifyById('407809109');
  console.log(`Verified: ${byId.verified}`);
  console.log('Checks:', byId.checks);
}

main();