Rails中压缩API响应后在JavaScript端解压失败的问题求助

Hey there, let's work through this problem step by step—looks like we've got two main issues to tackle: the invalid Base64 string flagged by your third-party service, and the "unknown compression method" error in your JS decompression.

First: Fix the Invalid Base64 Issue #

Your Rails code uses Base64.encode64, which adds line breaks every 60 characters to make the output human-readable. Most third-party services reject Base64 strings with line breaks, which is almost certainly why it's being marked as invalid.

Replace it with Base64.strict_encode64 instead—it produces a clean, line-break-free Base64 string that should pass validation:

compressed_data = Zlib::Deflate.deflate(json_data.to_s)
encoded_data = Base64.strict_encode64(compressed_data) # No more line breaks!
broadcast encoded_data

Second: Fix the Decompression Error in JS #

The "unknown compression method" error usually happens because we're mixing up binary data handling between Rails and JavaScript. Here's what's going wrong:

• Rails outputs compressed binary data, which you Base64-encode.
• Your current JS code decodes the Base64 into a string, but compressed data is binary—not UTF-8 text. Converting it to a string corrupts the bytes, making pako unable to recognize the compression format.

Fixed JS Code (Using Default Zlib Compression)

Use js-base64's decodeUint8Array to get a raw byte array directly, then pass that to pako. This preserves the binary data correctly:

import pako from 'pako';
import { decodeUint8Array } from 'js-base64';

// Handle the broadcast payload
const handleBroadcast = (payload) => {
  try {
    // Decode Base64 straight to a Uint8Array (binary-safe)
    const compressedBytes = decodeUint8Array(payload.data);
    // Inflate the compressed data (works with Rails' default Zlib output)
    const decompressedBytes = pako.inflate(compressedBytes);
    // Convert back to a JSON string and parse
    const jsonString = new TextDecoder('utf-8').decode(decompressedBytes);
    const originalData = JSON.parse(jsonString);
    
    // Do something with your original data here!
    console.log('Decompressed data:', originalData);
  } catch (err) {
    console.error('Decompression failed:', err);
  }
};

If That Still Fails: Try Raw Deflate

Occasionally, Rails' default Zlib compression includes extra headers that pako struggles with. If you still get errors, switch to raw deflate (no Zlib headers) in Rails, and use pako.inflateRaw in JS:

Rails Code:

// Create a deflator for raw deflate (no Zlib headers)
deflater = Zlib::Deflate.new(-Zlib::MAX_WBITS)
compressed_data = deflater.deflate(json_data.to_s, Zlib::FINISH)
deflater.close
encoded_data = Base64.strict_encode64(compressed_data)
broadcast encoded_data

JS Code:

import pako from 'pako';
import { decodeUint8Array } from 'js-base64';

const handleBroadcast = (payload) => {
  try {
    const compressedBytes = decodeUint8Array(payload.data);
    // Use inflateRaw for raw deflate data
    const decompressedBytes = pako.inflateRaw(compressedBytes);
    const jsonString = new TextDecoder('utf-8').decode(decompressedBytes);
    const originalData = JSON.parse(jsonString);
  } catch (err) {
    console.error('Decompression failed:', err);
  }
};

Quick Validation Step #

Before deploying, verify that your Rails compression works correctly by decompressing it locally:

original_json = json_data.to_s
compressed = Zlib::Deflate.deflate(original_json)
decompressed = Zlib::Inflate.inflate(compressed)
puts original_json == decompressed # Should print "true"

This confirms your compression logic isn't corrupting the data before it even gets to the third-party service.

Bonus: Check Compressed Size #

Remember that Base64 adds ~33% overhead (since it converts 3 bytes to 4 characters). If your compressed binary data is over ~18.75KB, the Base64 version will exceed 25KB. Since you said this is rare, but if it still happens, you could add a check in Rails to fall back to chunking or another strategy for large payloads.

内容的提问来源于stack exchange，提问作者HermannHH