Upload Onboarding Files

{
  "statusCode": 400,
  "message": "Invalid merchant ID",
  "error": "Bad Request",
  "details": {
    "merchantIdReceived": "abc"
  }
}

{
  "statusCode": 400,
  "message": "Merchant ID mismatch",
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": "No files received",
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": "Invalid file content type",
  "error": "Bad Request",
  "details": {
    "fileContentTypeReceived": "application/x-msdownload"
  }
}

{
  "statusCode": 400,
  "message": "Invalid file MIME type",
  "error": "Bad Request",
  "details": {
    "mimeTypeReceived": "application/octet-stream"
  }
}

{
  "statusCode": 400,
  "message": "Invalid file extension",
  "error": "Bad Request",
  "details": {
    "fileExtensionReceived": ".exe"
  }
}

{
  "statusCode": 400,
  "message": "File name too long",
  "error": "Bad Request",
  "details": {
    "fileNameLengthReceived": 300
  }
}

{
  "statusCode": 400,
  "message": "File size exceeds 25MB limit",
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": "Failed to save merchant's VALID_IDS_OF_SIGNATORY file/s",
  "error": "Bad Request"
}

{
  "statusCode": 401,
  "message": "Account not found",
  "error": "Unauthorized"
}

{
  "statusCode": 429,
  "message": "ThrottlerException: Too Many Requests"
}

// 1. Upload files first
const uploadResponse = await uploadOnboardingFiles(merchantId, files);

// 2. Extract file IDs
const fileIds = uploadResponse.files.map(f => f.id);

// 3. Submit onboarding with file references
const onboardingData = {
  merchantName: 'Acme Store',
  // ... other fields
  documentIds: fileIds
};

await onboardMerchant(onboardingData);

function validateFile(file) {
  const errors = [];

  // Check file size (25MB = 26214400 bytes)
  if (file.size > 26214400) {
    errors.push('File exceeds 25MB limit');
  }

  // Check file extension
  const allowedExtensions = ['.jpg', '.jpeg', '.png', '.pdf'];
  const ext = '.' + file.name.split('.').pop().toLowerCase();
  if (!allowedExtensions.includes(ext)) {
    errors.push('Invalid file extension. Only JPG, PNG, PDF allowed');
  }

  // Check file name length
  if (file.name.length > 255) {
    errors.push('File name too long (max 255 characters)');
  }

  return errors;
}

async function uploadWithRetry(merchantId, files, maxRetries = 3) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      return await uploadOnboardingFiles(merchantId, files);
    } catch (error) {
      if (error.response?.status === 429) {
        const waitTime = Math.pow(2, retries) * 1000; // Exponential backoff
        console.log(`Rate limited. Waiting ${waitTime}ms before retry...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        retries++;
      } else {
        throw error;
      }
    }
  }

  throw new Error('Max retries exceeded');
}

const documentFiles = {
  validIds: {
    front: '/path/to/id_front.jpg',
    back: '/path/to/id_back.jpg'
  },
  businessPermit: {
    front: '/path/to/permit.pdf'
  },
  storePhoto: '/path/to/store.jpg'
};

// Map to form field names
const formData = new FormData();
formData.append('idsOfValidSignatories', documentFiles.validIds.front);
formData.append('idsOfValidSignatoriesBack', documentFiles.validIds.back);
formData.append('mayorsOrBusinessPermit', documentFiles.businessPermit.front);
formData.append('storePhoto', documentFiles.storePhoto);

async function compressImage(file, maxSizeMB = 5) {
  const options = {
    maxSizeMB: maxSizeMB,
    maxWidthOrHeight: 1920,
    useWebWorker: true,
    fileType: file.type
  };

  try {
    const compressedFile = await imageCompression(file, options);
    console.log(`Compressed from ${file.size} to ${compressedFile.size}`);
    return compressedFile;
  } catch (error) {
    console.error('Compression failed:', error);
    return file; // Return original if compression fails
  }
}

async function uploadWithProgress(merchantId, files, onProgress) {
  const formData = new FormData();

  Object.entries(files).forEach(([fieldName, file]) => {
    formData.append(fieldName, file);
  });

  const response = await axios.post(
    `https://kyc.sbx.moduluslabs.io/v2/onboard/${merchantId}/files`,
    formData,
    {
      headers: {
        'Authorization': `Bearer ${token}`,
      },
      onUploadProgress: (progressEvent) => {
        const percentCompleted = Math.round(
          (progressEvent.loaded * 100) / progressEvent.total
        );
        onProgress(percentCompleted);
      }
    }
  );

  return response.data;
}

// Usage
uploadWithProgress(merchantId, files, (percent) => {
  console.log(`Upload progress: ${percent}%`);
  updateProgressBar(percent);
});

//  WRONG - Sending file path as string
formData.append('idsOfValidSignatories', '/path/to/file.jpg');

//  WRONG - Sending base64 string
formData.append('idsOfValidSignatories', 'data:image/jpeg;base64,/9j/4AAQ...');

//  WRONG - Sending URL
formData.append('idsOfValidSignatories', 'https://example.com/file.jpg');

//  CORRECT - Node.js with file stream
const fs = require('fs');
formData.append('idsOfValidSignatories',
  fs.createReadStream('/path/to/file.jpg'));

//  CORRECT - Browser with File object
const fileInput = document.getElementById('fileInput');
formData.append('idsOfValidSignatories', fileInput.files[0]);

//  CORRECT - Python with file handle
files = {'idsOfValidSignatories': open('/path/to/file.jpg', 'rb')}

//  CORRECT - PHP with CURLFile
$file = new CURLFile('/path/to/file.jpg', 'image/jpeg', 'file.jpg');

const delay = ms => new Promise(resolve => setTimeout(resolve, ms));

async function uploadForMultipleMerchants(merchantFileMap) {
  const results = [];

  for (const [merchantId, files] of Object.entries(merchantFileMap)) {
    try {
      const result = await uploadOnboardingFiles(merchantId, files);
      results.push({ merchantId, success: true, data: result });
    } catch (error) {
      results.push({ merchantId, success: false, error: error.message });
    }

    // Wait 12 seconds between uploads (5 requests per 60s = 1 per 12s)
    await delay(12000);
  }

  return results;
}

// Use form-data package, not URLSearchParams
const FormData = require('form-data');
const form = new FormData();
form.append('idsOfValidSignatories', fs.createReadStream(filePath));

// Include form headers
axios.post(url, form, {
  headers: {
    'Authorization': `Bearer ${token}`,
    ...form.getHeaders()  // Important!
  }
});

# Let requests handle Content-Type header
files = {'idsOfValidSignatories': open(file_path, 'rb')}
headers = {'Authorization': f'Bearer {token}'}
# Don't set Content-Type manually
requests.post(url, headers=headers, files=files)

// Use CURLFile, not @ syntax (deprecated)
$file = new CURLFile($filePath, 'image/jpeg', 'filename.jpg');