How to fix Error: Invalid trailer header (cannot use trailer with chunked encoding) in Node.js

const http = require('http');
const crypto = require('crypto');

const server = http.createServer((req, res) => {
  // Step 1: Declare which trailers you will send
  res.setHeader('Trailer', 'Content-MD5, X-Checksum');

  // Step 2: Do NOT set Content-Length (forces chunked encoding)
  // Chunked encoding is automatic when Content-Length is not set

  res.writeHead(200, {
    'Content-Type': 'text/plain',
    'Transfer-Encoding': 'chunked'  // Explicitly set (optional, automatic)
  });

  // Step 3: Write the body content
  const hash = crypto.createHash('md5');
  const content = 'Hello, World!';

  hash.update(content);
  res.write(content);

  // Step 4: Add trailers AFTER body, BEFORE end()
  const checksum = hash.digest('hex');
  res.addTrailers({
    'Content-MD5': checksum,
    'X-Checksum': checksum.toUpperCase()
  });

  // Step 5: End the response
  res.end();
});

server.listen(3000, () => {
  console.log('Server with trailers running on port 3000');
});

const http = require('http');
const express = require('express');
const app = express();

// Middleware that prevents Content-Length from being set
app.use((req, res, next) => {
  // Remove Content-Length if set by another middleware
  res.removeHeader('Content-Length');
  next();
});

app.get('/data', (req, res) => {
  // Declare trailers
  res.setHeader('Trailer', 'X-Response-Time');

  const startTime = Date.now();

  // Send response body
  res.write('Processing data...
');

  // Simulate some work
  setTimeout(() => {
    res.write('Done!
');

    // Add trailer with computed metadata
    const duration = Date.now() - startTime;
    res.addTrailers({
      'X-Response-Time': `${duration}ms`
    });

    res.end();
  }, 100);
});

app.listen(3000);

const http = require('http');
const crypto = require('crypto');
const fs = require('fs');

const server = http.createServer((req, res) => {
  const filePath = './large-file.bin';

  // Declare trailer headers upfront
  res.setHeader('Trailer', 'X-SHA256-Checksum, X-Bytes-Sent');
  res.writeHead(200, {
    'Content-Type': 'application/octet-stream',
    'Transfer-Encoding': 'chunked'
  });

  const hash = crypto.createHash('sha256');
  let bytesStreamed = 0;

  const stream = fs.createReadStream(filePath);

  stream.on('data', (chunk) => {
    hash.update(chunk);
    bytesStreamed += chunk.length;
    res.write(chunk);
  });

  stream.on('end', () => {
    // Add trailers with final computed values
    res.addTrailers({
      'X-SHA256-Checksum': hash.digest('hex'),
      'X-Bytes-Sent': bytesStreamed.toString()
    });
    res.end();
  });

  stream.on('error', (err) => {
    console.error('Stream error:', err);
    res.end();
  });
});

server.listen(3000);

const http = require('http');

function clientSupportsTrailers(req) {
  // Check if client accepts trailers via TE header
  const te = req.headers['te'] || '';
  return te.toLowerCase().includes('trailers');
}

const server = http.createServer((req, res) => {
  const useTrailers = clientSupportsTrailers(req);

  if (useTrailers) {
    // Client supports trailers - use them
    res.setHeader('Trailer', 'X-Checksum');
    res.writeHead(200, { 'Content-Type': 'text/plain' });

    const content = 'Data with trailer support';
    res.write(content);

    res.addTrailers({
      'X-Checksum': 'abc123'
    });
  } else {
    // Client doesn't support trailers - use regular headers
    res.writeHead(200, {
      'Content-Type': 'text/plain',
      'X-Checksum': 'abc123'  // Send as regular header instead
    });

    res.write('Data without trailer support');
  }

  res.end();
});

server.listen(3000);

const http = require('http');

// These headers are PROHIBITED as trailers:
const PROHIBITED_TRAILERS = [
  'transfer-encoding',
  'content-length',
  'trailer',
  'host',
  'cache-control',
  'max-forwards',
  'te',
  'authorization',
  'set-cookie',
  'content-encoding',
  'content-type',
  'content-range'
];

function isValidTrailerName(name) {
  return !PROHIBITED_TRAILERS.includes(name.toLowerCase());
}

const server = http.createServer((req, res) => {
  res.setHeader('Trailer', 'X-Custom-Metadata');
  res.writeHead(200, {
    'Content-Type': 'text/plain',
    'Transfer-Encoding': 'chunked'
  });

  res.write('Response body content
');

  // Safe trailers - custom headers
  const trailers = {
    'X-Custom-Metadata': 'value',
    'X-Server-Timing': '150ms'
  };

  // Validate before adding
  const validTrailers = {};
  for (const [name, value] of Object.entries(trailers)) {
    if (isValidTrailerName(name)) {
      validTrailers[name] = value;
    } else {
      console.warn(`Skipping prohibited trailer: ${name}`);
    }
  }

  res.addTrailers(validTrailers);
  res.end();
});

server.listen(3000);

const http = require('http');

function addTrailersSafely(res, trailers) {
  try {
    // Only works with HTTP/1.1+ and chunked encoding
    if (res.req.httpVersion === '1.0') {
      console.log('HTTP/1.0 client - skipping trailers');
      return false;
    }

    if (!res.hasHeader('trailer')) {
      console.warn('Trailer header not declared - cannot add trailers');
      return false;
    }

    res.addTrailers(trailers);
    return true;
  } catch (err) {
    console.error('Failed to add trailers:', err.message);
    return false;
  }
}

const server = http.createServer((req, res) => {
  // Attempt to use trailers
  const wantTrailers = req.httpVersion !== '1.0';

  if (wantTrailers) {
    res.setHeader('Trailer', 'X-Process-Time');
  }

  res.writeHead(200, { 'Content-Type': 'application/json' });

  const startTime = Date.now();

  // Send body
  res.write(JSON.stringify({ status: 'ok', data: [] }));

  // Try to add trailers
  const processTime = Date.now() - startTime;
  const added = addTrailersSafely(res, {
    'X-Process-Time': `${processTime}ms`
  });

  if (!added) {
    console.log(`Process time: ${processTime}ms (not sent as trailer)`);
  }

  res.end();
});

server.listen(3000);