How to fix TypeError: readableLength must be a positive integer (stream config) in Node.js

// WRONG: readableLength is not a configuration option
const stream = fs.createReadStream('file.txt', { readableLength: 1024 });

// CORRECT: Use highWaterMark to configure buffer threshold
const stream = fs.createReadStream('file.txt', { highWaterMark: 1024 });

// readableLength is used to check current buffer state
stream.on('readable', () => {
  console.log('Current buffered bytes:', stream.readableLength);
});

const { Readable } = require('stream');

// WRONG: readableLength is not a valid option in constructor
class CustomReadable extends Readable {
  constructor(options) {
    super(options);
    // Don't set readableLength - it's read-only
  }
}

// CORRECT: Use highWaterMark for configuration
class CustomReadable extends Readable {
  constructor(options = {}) {
    super({
      highWaterMark: options.highWaterMark || 16384,
      encoding: options.encoding,
      objectMode: options.objectMode
    });
    this.dataSource = options.dataSource;
  }

  _read(size) {
    // Read data from source
    const data = this.dataSource.read(size);
    if (data) {
      this.push(data);
    }
  }
}

// Create instance
const readable = new CustomReadable({ highWaterMark: 2048 });

// Check readableLength (read-only property)
readable.on('data', (chunk) => {
  console.log('Bytes buffered:', readable.readableLength);
});

// WRONG: Configuration with readableLength
const streamOptions = {
  encoding: 'utf8',
  readableLength: 4096,  // Invalid configuration
  objectMode: false
};
const stream = fs.createReadStream('file.txt', streamOptions);

// CORRECT: Use highWaterMark for buffering control
const streamOptions = {
  encoding: 'utf8',
  highWaterMark: 4096,  // Controls buffer threshold
  objectMode: false
};
const stream = fs.createReadStream('file.txt', streamOptions);

// WRONG: String value and wrong property name
const config = {
  readableLength: '4096',  // String and invalid property
};
const stream = fs.createReadStream('file.txt', config);

// CORRECT: Parse to integer and use highWaterMark
const config = {
  highWaterMark: parseInt(process.env.STREAM_BUFFER || '16384', 10),
};
const stream = fs.createReadStream('file.txt', config);

// CORRECT: Type-safe configuration
function validateStreamConfig(options) {
  if (options.highWaterMark) {
    const hwm = options.highWaterMark;
    if (typeof hwm !== 'number' || !Number.isInteger(hwm) || hwm < 0) {
      throw new TypeError('highWaterMark must be a non-negative integer');
    }
  }
  // Never set readableLength in options
  if (options.readableLength !== undefined) {
    throw new TypeError('readableLength is read-only, use highWaterMark instead');
  }
  return options;
}

const validConfig = validateStreamConfig({
  highWaterMark: 8192,
  encoding: 'utf8'
});
const stream = fs.createReadStream('file.txt', validConfig);

const fs = require('fs');

const stream = fs.createReadStream('large-file.txt', { highWaterMark: 16384 });

// Monitor readableLength (read-only)
stream.on('readable', () => {
  console.log('Bytes waiting to be read:', stream.readableLength);

  // Read data
  let chunk;
  while ((chunk = stream.read()) !== null) {
    console.log('Read', chunk.length, 'bytes');
    console.log('Remaining buffered:', stream.readableLength);
  }
});

// DO NOT attempt to set readableLength
// stream.readableLength = 1024;  // This won't work and may cause issues

stream.on('end', () => {
  console.log('Stream ended');
});

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

// Example: axios with streams
import axios from 'axios';
import fs from 'fs';

// WRONG: Some libraries might accept stream options, but readableLength is invalid
const response = await axios({
  method: 'get',
  url: 'https://example.com/file.bin',
  responseType: 'stream',
  // Don't add readableLength here
});

// CORRECT: Configure stream options properly
const stream = fs.createReadStream('input.txt', {
  highWaterMark: 32768,  // Valid option
  encoding: 'utf8'
});

// If using a custom stream wrapper, ensure it validates options
class StreamWrapper {
  constructor(options = {}) {
    const validOptions = {};

    // Only set valid stream options
    if (options.highWaterMark !== undefined) {
      validOptions.highWaterMark = options.highWaterMark;
    }
    if (options.encoding) {
      validOptions.encoding = options.encoding;
    }

    // Never copy readableLength to stream options
    if (options.readableLength !== undefined) {
      console.warn('readableLength is read-only, ignoring this option');
    }

    this.stream = fs.createReadStream(options.path, validOptions);
  }
}