How to fix TypeError: path.relative() requires both arguments to be strings in Node.js

// Example error stack trace
TypeError [ERR_INVALID_ARG_TYPE]: The "path" argument must be of type string. Received undefined
    at new NodeError (node:internal/errors:372:5)
    at validateString (node:internal/validators:124:11)
    at Object.relative (node:internal/path:1171:5)

const path = require('path');

function getRelativePath(fromPath, toPath) {
  console.log('fromPath:', fromPath, 'type:', typeof fromPath);
  console.log('toPath:', toPath, 'type:', typeof toPath);

  return path.relative(fromPath, toPath);
}

const path = require('path');

function getRelativePath(fromPath, toPath) {
  if (typeof fromPath !== 'string' || typeof toPath !== 'string') {
    throw new Error(`Invalid path arguments: from=${fromPath}, to=${toPath}`);
  }

  return path.relative(fromPath, toPath);
}

const path = require('path');

function getRelativePath(fromPath, toPath) {
  // Use current working directory as fallback
  const from = fromPath || process.cwd();
  const to = toPath || process.cwd();

  return path.relative(from, to);
}

const relativePath = path.relative(
  fromPath ?? process.cwd(),
  toPath ?? process.cwd()
);

const path = require('path');

// Check environment variable
const baseDir = process.env.BASE_DIR;
if (!baseDir) {
  throw new Error('BASE_DIR environment variable is not set');
}

const targetDir = process.env.TARGET_DIR;
if (!targetDir) {
  throw new Error('TARGET_DIR environment variable is not set');
}

const relativePath = path.relative(baseDir, targetDir);

const config = require('./config.json');

if (!config.sourcePath || typeof config.sourcePath !== 'string') {
  throw new Error('Invalid or missing sourcePath in config');
}

if (!config.destPath || typeof config.destPath !== 'string') {
  throw new Error('Invalid or missing destPath in config');
}

const relativePath = path.relative(config.sourcePath, config.destPath);

const path = require('path');

function calculateRelativePath(
  fromPath = process.cwd(),
  toPath = process.cwd()
) {
  // Validate they're still strings (in case null was explicitly passed)
  if (typeof fromPath !== 'string') {
    throw new TypeError('fromPath must be a string');
  }
  if (typeof toPath !== 'string') {
    throw new TypeError('toPath must be a string');
  }

  return path.relative(fromPath, toPath);
}

const path = require('path');

/**
 * Safely calculate relative path between two directories
 * @param {string} from - Source directory path
 * @param {string} to - Destination directory path
 * @returns {string} Relative path from 'from' to 'to'
 * @throws {TypeError} If arguments are not strings
 */
function safeRelativePath(from, to) {
  if (typeof from !== 'string') {
    throw new TypeError(
      `First argument 'from' must be a string, received ${typeof from}`
    );
  }

  if (typeof to !== 'string') {
    throw new TypeError(
      `Second argument 'to' must be a string, received ${typeof to}`
    );
  }

  if (from.length === 0) {
    throw new Error('First argument cannot be an empty string');
  }

  if (to.length === 0) {
    throw new Error('Second argument cannot be an empty string');
  }

  return path.relative(from, to);
}

// Usage
try {
  const result = safeRelativePath('/src', '/dist');
  console.log(result);
} catch (error) {
  console.error('Path calculation failed:', error.message);
}