BinaryDataHandlers.js•4 kB
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.processBinaryOutputData = exports.handleBinaryInputData = void 0;
/**
* Check if data is base64 encoded
*/
function isBase64(str) {
try {
return Buffer.from(str, 'base64').toString('base64') === str;
}
catch (error) {
return false;
}
}
/**
* Extract mime type from data URL
*/
function getMimeTypeFromDataUrl(dataUrl) {
if (!dataUrl.startsWith('data:'))
return 'application/octet-stream';
const matches = dataUrl.match(/^data:([^;]+);base64,/);
return matches ? matches[1] : 'application/octet-stream';
}
/**
* Convert binary data to base64 for API input
*/
function handleBinaryInputData(parameters, item) {
// Process each parameter
for (const key of Object.keys(parameters)) {
if (parameters[key] === '={{ $binary }}') {
// Remove the placeholder
delete parameters[key];
// Check if we have binary data - safeguarded version
if (item.binary === undefined) {
console.error(`No binary data found for parameter "${key}"`);
return;
}
// Find first available binary property
const binaryPropertyName = Object.keys(item.binary)[0];
if (!binaryPropertyName) {
console.error(`No binary property found for parameter "${key}"`);
return;
}
// Get binary data
const binaryData = item.binary[binaryPropertyName];
if (!binaryData) {
console.error(`Binary data is empty for parameter "${key}"`);
return;
}
// Set the base64 data
parameters[key] = binaryData.data;
}
}
}
exports.handleBinaryInputData = handleBinaryInputData;
/**
* Process API response and convert binary data fields to n8n binary data
*/
function processBinaryOutputData(response, item, executionId) {
const returnItem = { ...item, json: response };
const binaryData = {}; // Use IBinaryKeyData instead
// Check for binary data in response
for (const [key, value] of Object.entries(response)) {
// Skip if not a string or not a potential binary/base64 field
if (typeof value !== 'string')
continue;
const trimmedValue = value.trim();
// Check if this is a data URL
if (trimmedValue.startsWith('data:')) {
try {
// Extract the base64 part
const base64Data = trimmedValue.split(',')[1] || '';
if (!base64Data)
continue;
// Get the mime type
const mimeType = getMimeTypeFromDataUrl(trimmedValue);
// Create file extension from mime type
const fileExtension = mimeType.split('/')[1] || 'dat';
// Create binary data entry
binaryData[key] = {
data: base64Data,
mimeType,
fileName: `${key}.${fileExtension}`,
fileExtension,
};
}
catch (error) {
// Skip if we can't process
continue;
}
}
// Check if this might be raw base64 data
else if (isBase64(trimmedValue) && trimmedValue.length > 100) {
// Since we don't know the mime type, use generic binary
binaryData[key] = {
data: trimmedValue,
mimeType: 'application/octet-stream',
fileName: `${key}.bin`,
fileExtension: 'bin',
};
}
}
// If we found binary data, add it to the item
if (Object.keys(binaryData).length > 0) {
returnItem.binary = binaryData;
}
return returnItem;
}
exports.processBinaryOutputData = processBinaryOutputData;
//# sourceMappingURL=BinaryDataHandlers.js.map