The File System (fs)

const fs = require('fs');

// --- Asynchronous (non-blocking) ---

// Reading a file
fs.readFile('message.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err.message);
    return;
  }
  console.log('File contents:', data);
});

// Writing a file (creates or overwrites)
fs.writeFile('output.txt', 'Hello, Node.js!', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

// Appending to a file
fs.appendFile('log.txt', 'New log entry\n', (err) => {
  if (err) throw err;
  console.log('Data appended');
});

// --- Synchronous (blocking) ---
const data = fs.readFileSync('message.txt', 'utf8');
console.log(data);

// FINE — startup, before the server accepts anything
const fs = require('node:fs');
const config = JSON.parse(fs.readFileSync('./config.json', 'utf8'));
// If this throws, the app should not start anyway.

app.listen(config.port);

// HARMFUL — inside a request handler
app.get('/report', (req, res) => {
  const data = fs.readFileSync('./big-report.csv', 'utf8');  // freezes everyone
  res.type('text/csv').send(data);
});

// CORRECT — the same route, non-blocking
const fsp = require('node:fs/promises');

app.get('/report', async (req, res, next) => {
  try {
    const data = await fsp.readFile('./big-report.csv', 'utf8');
    res.type('text/csv').send(data);
  } catch (err) {
    next(err);
  }
});

const fs = require('fs').promises;
const path = require('path');

async function processFiles() {
  try {
    // Read a file
    const data = await fs.readFile('input.txt', 'utf8');
    console.log('Read:', data);

    // Write to a file
    await fs.writeFile('output.txt', data.toUpperCase());
    console.log('Written successfully');

    // Check if file exists
    try {
      await fs.access('config.json');
      console.log('Config file exists');
    } catch {
      console.log('Config file not found');
    }

    // Create a directory
    await fs.mkdir('logs', { recursive: true });

    // List files in a directory
    const files = await fs.readdir('.');
    console.log('Files:', files);

    // Get file info
    const stats = await fs.stat('output.txt');
    console.log('Size:', stats.size, 'bytes');
  } catch (err) {
    console.error('Error:', err.message);
  }
}

processFiles();

const fs = require('node:fs');
const readline = require('node:readline');
const { pipeline } = require('node:stream/promises');

// Count error lines in a log of ANY size — memory stays flat
async function countErrors(path) {
  const stream = fs.createReadStream(path, { encoding: 'utf8' });
  const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });

  let errors = 0;
  for await (const line of lines) {
    if (line.includes('ERROR')) errors++;
  }
  return errors;
}

// Send a large file to the client without buffering it in memory
app.get('/download/:name', async (req, res, next) => {
  const filePath = path.join(FILES_DIR, path.basename(req.params.name));
  try {
    await pipeline(fs.createReadStream(filePath), res);
  } catch (err) {
    next(err);
  }
});

// Copy while transforming, again without loading the whole file
await pipeline(
  fs.createReadStream('input.csv'),
  someTransformStream,
  fs.createWriteStream('output.csv')
);

const fsp = require('node:fs/promises');

async function loadConfig(path) {
  let raw;
  try {
    raw = await fsp.readFile(path, 'utf8');
  } catch (err) {
    if (err.code === 'ENOENT') {
      throw new Error(`Config file not found at ${path}`);
    }
    if (err.code === 'EACCES') {
      throw new Error(`No permission to read ${path}`);
    }
    throw err;                       // something unexpected — do not swallow it
  }

  try {
    return JSON.parse(raw);
  } catch {
    throw new Error(`${path} exists but is not valid JSON`);
  }
}

// Why ENOENT usually means "wrong folder", not "missing file"
console.log(process.cwd());   // where you RAN node from
console.log(__dirname);       // where THIS FILE lives
// A relative path is resolved against the first, which is rarely what you meant.