How to fix TypeError: Cannot read property 'length' of null in Node.js

stream.on('data', (chunk) => {
  if (chunk === null) {
    console.error('Received null chunk');
    return;
  }

  // Safe to access chunk.length now
  console.log('Chunk length:', chunk.length);
});

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

const myTransform = new Transform({
  transform(chunk, encoding, callback) {
    if (chunk === null || chunk === undefined) {
      callback(new Error('Invalid null chunk received'));
      return;
    }

    // Process valid chunk
    this.push(chunk);
    callback();
  }
});

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

function writeToStream(data, stream) {
  // Validate before writing
  if (data === null || data === undefined) {
    throw new Error('Cannot write null or undefined to stream');
  }

  // Ensure data is Buffer or string for non-object mode streams
  if (!Buffer.isBuffer(data) && typeof data !== 'string') {
    data = String(data);
  }

  stream.write(data);
}

async function streamDatabaseResults(query, writeStream) {
  const results = await db.query(query);

  for (const row of results) {
    // Filter out null values
    const data = row.data || Buffer.from(''); // Use empty buffer as fallback
    writeStream.write(data);
  }

  // Signal completion
  writeStream.end();
}

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

// ✅ Correct: Use push(null) to signal EOF
const readableStream = new Readable({
  read() {
    this.push('data chunk 1');
    this.push('data chunk 2');
    this.push(null); // Signals end of stream
  }
});

// ❌ Wrong: Don't write null as data
stream.write(null); // This will cause TypeError

// ✅ Correct: Use end() to finish writing
stream.end('final chunk');

const myTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(processChunk(chunk));
    callback();
  },
  flush(callback) {
    // Finalize without pushing null explicitly
    callback();
  }
});

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

pipeline(
  sourceStream,
  transformStream,
  destinationStream,
  (err) => {
    if (err) {
      console.error('Pipeline failed:', err.message);

      // Check if it's a null chunk error
      if (err.message.includes('null')) {
        console.error('Null chunk detected in stream pipeline');
      }

      // Clean up resources
      sourceStream.destroy();
      transformStream.destroy();
      destinationStream.destroy();
    } else {
      console.log('Pipeline completed successfully');
    }
  }
);

stream.on('error', (err) => {
  if (err.message.includes('Cannot read property') && err.message.includes('null')) {
    console.error('Null chunk error detected');
    // Implement recovery logic
    stream.destroy();
  }
});

const { Transform, Writable } = require('stream');

// ✅ Both in object mode
const objectTransform = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    // Chunk can be any value except null
    if (chunk === null) {
      callback(new Error('Null not allowed in object mode'));
      return;
    }
    this.push(chunk);
    callback();
  }
});

const objectWritable = new Writable({
  objectMode: true,
  write(chunk, encoding, callback) {
    console.log('Object:', chunk);
    callback();
  }
});

// ❌ Mixed modes can cause issues
const bufferTransform = new Transform({
  objectMode: false, // Expects Buffer/string
  // ...
});

// objectTransform piped to bufferTransform may fail

// ✅ Convert between modes explicitly
const converter = new Transform({
  writableObjectMode: true,
  readableObjectMode: false,
  transform(obj, encoding, callback) {
    // Convert object to buffer
    this.push(Buffer.from(JSON.stringify(obj)));
    callback();
  }
});