File Support in Custom Integrations

// Gmail-style email with file attachments
const recipient = data.input.mailRecipient;
const subject = data.input.mailSubject;
const body = data.input.mailBody;
const attachments = data.input.attachments || [];

// Build multipart email
let email = `To: ${recipient}\r\nSubject: ${subject}\r\n`;

if (attachments.length > 0) {
const boundary = `boundary_${Date.now()}`;
email += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n\r\n`;
email += `--${boundary}\r\nContent-Type: text/html\r\n\r\n${body}\r\n`;

  // Add each attachment
  for (const attachment of attachments) {
    email += `--${boundary}\r\n`;
    email += `Content-Type: ${attachment.mimeType}\r\n`;
    email += `Content-Transfer-Encoding: base64\r\n`;
    email += `Content-Disposition: attachment; filename="${attachment.fileName}"\r\n`;
    email += `\r\n${attachment.base64}\r\n`;
  }
  email += `--${boundary}--`;

}

const document = data.input.document;

// Validate file type
if (!document.mimeType.startsWith('application/pdf')) {
  throw new Error('Only PDF files are supported');
}

try {
  const response = await ld.request({
    method: 'POST',
    url: 'https://api.example.com/documents',
    headers: {
      'Authorization': `Bearer ${data.auth.apiKey}`,
      'Content-Type': 'application/json'
    },
    body: {
      filename: document.fileName,
      content: document.base64,
      mimeType: document.mimeType
    }
  });

  return {
    success: true,
    documentId: response.json.id,
    message: `Uploaded ${document.fileName} successfully`
  };
} catch (error) {
  return {
    success: false,
    error: `Failed to upload ${document.fileName}: ${error.message}`
  };
}

const files = data.input.files || [];

if (files.length === 0) {
  return { error: 'No files provided' };
}

const results = [];

for (const file of files) {
  try {
    const buffer = Buffer.from(file.base64, 'base64');
    
    // Process based on file type
    let result;
    if (file.mimeType.startsWith('image/')) {
      result = await processImage(buffer);
    } else if (file.mimeType === 'application/pdf') {
      result = await processPDF(buffer);
    } else {
      throw new Error(`Unsupported file type: ${file.mimeType}`);
    }
    
    results.push({
      filename: file.fileName,
      status: 'success',
      result: result
    });
    
    ld.log(`Processed ${file.fileName} successfully`);
  } catch (error) {
    results.push({
      filename: file.fileName,
      status: 'error',
      error: error.message
    });
    
    ld.log(`Failed to process ${file.fileName}: ${error.message}`);
  }
}

return {
  success: true,
  processed: results.filter(r => r.status === 'success').length,
  failed: results.filter(r => r.status === 'error').length,
  results: results
};

// Generate a PDF report from data
const reportData = await fetchReportData();

// Create PDF content (using custom built function / endpoint)
const pdfBuffer = await generatePDF({
  title: 'Monthly Report',
  data: reportData,
  template: 'standard'
});

return {
  files: {
    fileName: `monthly-report-${new Date().toISOString().slice(0,7)}.pdf`,
    mimeType: 'application/pdf',
    base64: pdfBuffer.toString('base64')
  },
  success: true,
  message: `Generated report with ${reportData.length} entries`
};

// Export data as CSV using text shortcut
const customers = await fetchCustomers();

// Build CSV content
const csvHeader = 'Name,Email,Created,Status';
const csvRows = customers.map(c => 
  `"${c.name}","${c.email}","${c.created}","${c.status}"`
);
const csvContent = [csvHeader, ...csvRows].join('\n');

return {
  files: {
    fileName: `customers-export-${new Date().toISOString().slice(0,10)}.csv`,
    mimeType: 'text/csv',
    text: csvContent  // Use text for UTF-8 content
  },
  success: true,
  exported: customers.length
};

// Download file from external API
const fileId = data.input.fileId;

try {
  const response = await ld.request({
    method: 'GET',
    url: `https://api.example.com/files/${fileId}`,
    headers: {
      'Authorization': `Bearer ${data.auth.apiKey}`
    },
    responseType: 'stream'
  });

  // Get filename from response headers or API
  const filename = response.headers['content-disposition']
    ?.match(/filename="(.+)"/)?.[1] || `file-${fileId}`;

  return {
    files: {
      fileName: filename,
      mimeType: response.headers['content-type'] || 'application/octet-stream',
      base64: Buffer.from(response.buffer).toString('base64')
    },
    success: true,
    message: `Downloaded ${filename}`
  };
} catch (error) {
  return {
    success: false,
    error: `Failed to download file: ${error.message}`
  };
}

// Process input files and return modified versions
const inputFiles = data.input.documents || [];
const outputFiles = [];

for (const file of inputFiles) {
  try {
    const buffer = Buffer.from(file.base64, 'base64');
    
    // Process file (e.g., compress, convert, etc.)
    const processedBuffer = await processFile(buffer, file.mimeType);
    
    outputFiles.push({
      fileName: `processed-${file.fileName}`,
      mimeType: file.mimeType,
      base64: processedBuffer.toString('base64')
    });
  } catch (error) {
    ld.log(`Failed to process ${file.fileName}: ${error.message}`);
  }
}

return {
  files: outputFiles,
  success: true,
  processed: outputFiles.length,
  message: `Processed ${outputFiles.length} of ${inputFiles.length} files`
};

// Gmail trigger processing incoming emails
const emails = await fetchNewEmails();
const results = [];

for (const email of emails) {
  const attachments = [];
  
  // Process email attachments if any
  if (email.attachments && email.attachments.length > 0) {
    for (const attachment of email.attachments) {
      // Download attachment content
      const content = await downloadAttachment(attachment.id);
      
      attachments.push({
        fileName: attachment.filename,
        mimeType: attachment.mimeType,
        base64: content.toString('base64')
      });
    }
  }
  
  results.push({
    id: email.id,                     // Required: unique event ID
    timestamp: email.date,            // Required: event timestamp
    data: {
      from: email.from,
      subject: email.subject,
      body: email.body,
      receivedAt: email.date,
      messageId: email.id,
      threadId: email.threadId,
      files: attachments              // Files inside data object
    }
  });
}

return results;  // Return array of trigger events

// Monitor for new files in a directory
const newFiles = await checkForNewFiles(data.input.directory);
const results = [];

for (const file of newFiles) {
  try {
    // Download file content
    const content = await downloadFile(file.path);
    
    results.push({
      id: file.id || file.path,         // Required: unique file identifier
      timestamp: file.lastModified,     // Required: event timestamp
      data: {
        filePath: file.path,
        fileName: file.name,
        size: file.size,
        modifiedAt: file.lastModified,
        event: 'file_created',
        files: [                        // Files array inside data object
          {
            fileName: file.name,
            mimeType: file.mimeType || 'application/octet-stream',
            base64: content.toString('base64')
          }
        ]
      }
    });
  } catch (error) {
    ld.log(`Failed to process file ${file.name}: ${error.message}`);
  }
}

return results;  // Return array of trigger events