How to fix Error: zlib deflate error (compression algorithm failed) in Node.js

const zlib = require('zlib');

// For callback-based API
zlib.deflate(buffer, (err, result) => {
  if (err) {
    if (err.code === 'Z_DATA_ERROR') {
      console.error('Invalid input data for compression');
    } else if (err.code === 'Z_BUF_ERROR') {
      console.error('Insufficient buffer space');
    } else {
      console.error('Deflate error:', err.message);
    }
    return;
  }
  // Process compressed data
  console.log('Compressed successfully');
});

// For promise-based API (Node.js 14+)
const { promisify } = require('util');
const deflateAsync = promisify(zlib.deflate);

async function compressData(data) {
  try {
    const compressed = await deflateAsync(data);
    return compressed;
  } catch (err) {
    console.error('Compression failed:', err.code, err.message);
    throw err;
  }
}

const zlib = require('zlib');

function safeDeflate(data, options = {}) {
  // Validate input
  if (!Buffer.isBuffer(data) && typeof data !== 'string') {
    throw new TypeError('Input must be a Buffer or string');
  }

  // Check size limits (e.g., 100MB max)
  const MAX_INPUT_SIZE = 100 * 1024 * 1024;
  const inputSize = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);

  if (inputSize > MAX_INPUT_SIZE) {
    throw new Error(`Input size ${inputSize} exceeds maximum ${MAX_INPUT_SIZE}`);
  }

  // Set maxOutputLength to prevent excessive memory usage
  const deflateOptions = {
    ...options,
    maxOutputLength: inputSize * 2 // Allow 2x expansion for safety
  };

  return new Promise((resolve, reject) => {
    zlib.deflate(data, deflateOptions, (err, result) => {
      if (err) reject(err);
      else resolve(result);
    });
  });
}

const zlib = require('zlib');

const compressionOptions = {
  level: zlib.constants.Z_DEFAULT_COMPRESSION, // -1 (default) or 0-9
  memLevel: 8, // Default is 8, reduce to 1-7 for lower memory usage
  windowBits: 15, // Default is 15, reduce for lower memory (9-15)
  maxOutputLength: 10 * 1024 * 1024, // 10MB max output
};

// Using streaming API for large data
const fs = require('fs');
const input = fs.createReadStream('large-file.txt');
const output = fs.createWriteStream('large-file.txt.gz');
const compress = zlib.createDeflate(compressionOptions);

compress.on('error', (err) => {
  console.error('Compression error:', err.message);
  input.destroy();
  output.destroy();
});

input.pipe(compress).pipe(output);

const zlib = require('zlib');
const { pipeline } = require('stream');

// Streaming compression
function compressStream(inputStream, outputStream) {
  const deflate = zlib.createDeflate({
    level: zlib.constants.Z_BEST_SPEED,
    maxOutputLength: Infinity // Or set a specific limit
  });

  return new Promise((resolve, reject) => {
    pipeline(
      inputStream,
      deflate,
      outputStream,
      (err) => {
        if (err) {
          console.error('Pipeline failed:', err);
          reject(err);
        } else {
          console.log('Compression completed');
          resolve();
        }
      }
    );
  });
}

// For in-memory data with backpressure handling
const { Readable, Writable } = require('stream');

function compressBuffer(buffer) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    const deflate = zlib.createDeflate();

    deflate.on('data', (chunk) => chunks.push(chunk));
    deflate.on('end', () => resolve(Buffer.concat(chunks)));
    deflate.on('error', reject);

    deflate.write(buffer);
    deflate.end();
  });
}

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

const compressionCache = new Map();

async function cachedDeflate(data) {
  // Generate hash of input data
  const hash = crypto.createHash('sha256').update(data).digest('hex');

  // Check cache
  if (compressionCache.has(hash)) {
    console.log('Using cached compression result');
    return compressionCache.get(hash);
  }

  // Compress and cache
  try {
    const compressed = await new Promise((resolve, reject) => {
      zlib.deflate(data, (err, result) => {
        if (err) reject(err);
        else resolve(result);
      });
    });

    // Limit cache size (e.g., 100 entries)
    if (compressionCache.size >= 100) {
      const firstKey = compressionCache.keys().next().value;
      compressionCache.delete(firstKey);
    }

    compressionCache.set(hash, compressed);
    return compressed;
  } catch (err) {
    console.error('Compression failed:', err);
    throw err;
  }
}