How to fix TypeError: list argument must be an Array of Buffer instances in Node.js

// Check what you're trying to concatenate
console.log('Data types:', chunks.map(c => typeof c));
console.log('Is Buffer:', chunks.map(c => Buffer.isBuffer(c)));
console.log('Actual values:', chunks);

const result = Buffer.concat(chunks);

// Filter out invalid elements and convert if possible
const validChunks = chunks
  .filter(chunk => chunk != null) // Remove null/undefined
  .map(chunk => {
    if (Buffer.isBuffer(chunk)) {
      return chunk;
    }
    if (typeof chunk === 'string') {
      return Buffer.from(chunk); // Convert strings to Buffer
    }
    if (chunk instanceof Uint8Array) {
      return Buffer.from(chunk); // Convert Uint8Array to Buffer
    }
    console.warn('Skipping invalid chunk:', typeof chunk);
    return null;
  })
  .filter(chunk => chunk !== null);

const result = Buffer.concat(validChunks);

// BAD - mixing strings and Buffers
stream.on('data', (chunk) => {
  if (someCondition) {
    chunks.push(chunk.toString()); // String!
  } else {
    chunks.push(chunk); // Buffer
  }
});

// GOOD - keep everything as Buffer
stream.on('data', (chunk) => {
  chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
});

// BAD - JSON stringified data
const data = JSON.stringify(obj);
chunks.push(data); // String, not Buffer

// GOOD - convert to Buffer explicitly
const data = JSON.stringify(obj);
chunks.push(Buffer.from(data, 'utf8'));

let chunks = []; // Start with empty array

// Always validate before adding
function addChunk(data) {
  if (data == null) return; // Skip null/undefined

  const chunk = Buffer.isBuffer(data)
    ? data
    : Buffer.from(data);

  chunks.push(chunk);
}

// Safe concatenation with empty check
function getResult() {
  if (chunks.length === 0) {
    return Buffer.alloc(0); // Return empty Buffer
  }
  return Buffer.concat(chunks);
}

function safeConcatBuffers(bufferList) {
  if (!Array.isArray(bufferList)) {
    throw new TypeError('Expected an array of Buffers');
  }

  // Validate all elements
  const invalidIndex = bufferList.findIndex(
    item => !Buffer.isBuffer(item) && !(item instanceof Uint8Array)
  );

  if (invalidIndex !== -1) {
    throw new TypeError(
      `Element at index ${invalidIndex} is not a Buffer or Uint8Array. ` +
      `Got: ${typeof bufferList[invalidIndex]}`
    );
  }

  return Buffer.concat(bufferList);
}

// Usage
try {
  const result = safeConcatBuffers(chunks);
} catch (err) {
  console.error('Buffer concatenation failed:', err.message);
}