How to fix Error: EEXIST: file already exists, copyfile (COPYFILE_EXCL flag set) in Node.js

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

async function copyFile(src, dest) {
  // Without COPYFILE_EXCL - will overwrite if dest exists
  await fs.copyFile(src, dest);
  console.log('File copied successfully');
}

// Or with callback style
const fs = require('fs');
fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('Copy completed');
});

const fs = require('fs').promises;
const { COPYFILE_EXCL } = require('fs').constants;

async function safeCopyFile(src, dest) {
  try {
    // Try to remove destination if it exists
    await fs.unlink(dest);
  } catch (err) {
    if (err.code !== 'ENOENT') {
      // If error is not "file not found", re-throw
      throw err;
    }
    // File doesn't exist, which is fine
  }

  // Now copy with COPYFILE_EXCL flag
  await fs.copyFile(src, dest, COPYFILE_EXCL);
  console.log('File copied with safety flag');
}

const fs = require('fs').promises;
const { COPYFILE_EXCL } = require('fs').constants;

async function copyFileWithFallback(src, dest) {
  try {
    // Try to copy with safety flag
    await fs.copyFile(src, dest, COPYFILE_EXCL);
    console.log('File copied (destination did not exist)');
  } catch (err) {
    if (err.code === 'EEXIST') {
      console.log('Destination already exists, using existing file');
      // Could also skip, log a warning, or copy to alternate location
    } else {
      throw err; // Re-throw other errors like EACCES or EIO
    }
  }
}

// Or with synchronous code
const fs = require('fs');
try {
  fs.copyFileSync(src, dest, fs.constants.COPYFILE_EXCL);
} catch (err) {
  if (err.code === 'EEXIST') {
    console.log('File already exists');
  } else {
    throw err;
  }
}

const fs = require('fs').promises;
const path = require('path');
const { COPYFILE_EXCL } = require('fs').constants;

async function copyFileWithUniqueName(src, destDir) {
  const baseName = path.basename(src);
  const ext = path.extname(baseName);
  const nameWithoutExt = path.basename(baseName, ext);

  let destPath = path.join(destDir, baseName);
  let counter = 1;

  // Keep incrementing filename until we find an available name
  while (true) {
    try {
      await fs.copyFile(src, destPath, COPYFILE_EXCL);
      console.log(`Copied to: ${destPath}`);
      return destPath;
    } catch (err) {
      if (err.code === 'EEXIST') {
        // Try next numbered version
        destPath = path.join(
          destDir,
          `${nameWithoutExt} (${counter})${ext}`
        );
        counter++;
      } else {
        throw err;
      }
    }
  }
}

// Usage
await copyFileWithUniqueName('upload.txt', './uploads');
// Creates: uploads/upload.txt, uploads/upload (1).txt, uploads/upload (2).txt, etc.

const fs = require('fs').promises;
const { COPYFILE_EXCL } = require('fs').constants;

async function copyFileIfNotExists(src, dest) {
  try {
    // Check if destination exists
    await fs.access(dest);
    console.log('Destination already exists, skipping copy');
    return false;
  } catch (err) {
    if (err.code === 'ENOENT') {
      // Destination doesn't exist, safe to copy
      await fs.copyFile(src, dest, COPYFILE_EXCL);
      console.log('File copied successfully');
      return true;
    } else {
      throw err; // Other errors like EACCES
    }
  }
}

// Or using fs.existsSync for synchronous operations
function copyFileIfNotExistsSync(src, dest) {
  if (fs.existsSync(dest)) {
    console.log('Destination already exists, skipping');
    return false;
  }
  fs.copyFileSync(src, dest, fs.constants.COPYFILE_EXCL);
  console.log('File copied');
  return true;
}

const fs = require('fs').promises;
const path = require('path');
const { COPYFILE_EXCL } = require('fs').constants;

async function robustFileCopy(src, dest, options = {}) {
  const {
    overwrite = false,
    createUnique = false,
    maxRetries = 3,
  } = options;

  // Strategy 1: Overwrite existing file
  if (overwrite) {
    try {
      await fs.unlink(dest);
    } catch (err) {
      if (err.code !== 'ENOENT') throw err;
    }
    await fs.copyFile(src, dest);
    return { success: true, path: dest };
  }

  // Strategy 2: Create unique filename if exists
  if (createUnique) {
    let finalDest = dest;
    let counter = 0;
    while (counter < 100) {
      try {
        await fs.copyFile(src, finalDest, COPYFILE_EXCL);
        return { success: true, path: finalDest };
      } catch (err) {
        if (err.code === 'EEXIST') {
          const ext = path.extname(dest);
          const dir = path.dirname(dest);
          const base = path.basename(dest, ext);
          finalDest = path.join(dir, `${base}-${++counter}${ext}`);
        } else {
          throw err;
        }
      }
    }
    throw new Error('Could not find unique filename after 100 attempts');
  }

  // Strategy 3: Fail if exists (default with COPYFILE_EXCL)
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      await fs.copyFile(src, dest, COPYFILE_EXCL);
      return { success: true, path: dest };
    } catch (err) {
      if (err.code === 'EEXIST' && attempt === maxRetries - 1) {
        return { success: false, error: 'Destination already exists', code: 'EEXIST' };
      }
      if (err.code !== 'EEXIST') throw err;
      // Retry with delay for transient issues
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }
}

// Usage examples
await robustFileCopy('source.txt', 'dest.txt');
await robustFileCopy('source.txt', 'dest.txt', { overwrite: true });
await robustFileCopy('source.txt', 'dest.txt', { createUnique: true });