nodry/deprecate.js

A CLI tool and Node.js library that warns about repetitive code to help you stay DRY.

const { exec } = require('child_process');
const inquirer = require('inquirer');

function execPromise(cmd) {
  return new Promise((resolve, reject) => {
    exec(cmd, (error, stdout, stderr) => {
      if (error) return reject({ error, stderr });
      if (stderr) console.warn('npm stderr:', stderr);
      resolve(stdout.trim());
    });
  });
}

async function getVersions(packageName) {
  const stdout = await execPromise(`npm view ${packageName} versions --json`);
  return JSON.parse(stdout);
}

async function getDeprecatedMessage(packageName, version) {
  try {
    const msg = await execPromise(`npm view ${packageName}@${version} deprecated`);
    return msg === 'null' ? null : msg;
  } catch {
    return null;
  }
}

async function deprecateVersion(packageName, version, message) {
  try {
    console.log(`Deprecating version ${version} of ${packageName} with message: "${message}"`);
    await execPromise(`npm deprecate ${packageName}@${version} "${message}"`);
    console.log(`Deprecated version ${version} successfully.`);
  } catch (err) {
    console.error(`Error deprecating version ${version}:`, err.error?.message || err);
  }
}

async function deprecateOldVersions(packageName) {
  try {
    const versions = await getVersions(packageName);
    if (!Array.isArray(versions) || versions.length === 0) {
      console.error('No versions found for package:', packageName);
      return;
    }

    const latestVersion = versions[versions.length - 1];
    const oldVersions = versions.filter(v => v !== latestVersion);
    const message = `This version is deprecated, please upgrade to the latest stable version (${latestVersion}).`;

    for (const version of oldVersions) {
      const currentMsg = await getDeprecatedMessage(packageName, version);
      if (currentMsg === message) {
        console.log(`Version ${version} is already deprecated with correct message.`);
        continue;
      }
      if (currentMsg) {
        console.log(`Version ${version} is deprecated with a different message: "${currentMsg}"`);
      } else {
        console.log(`Version ${version} is not deprecated yet.`);
      }
      await deprecateVersion(packageName, version, message);
    }

    console.log('Finished deprecating old versions.');
  } catch (err) {
    console.error('Failed to fetch or deprecate versions:', err);
  }
}

const readline = require('readline');

function askQuestion(query) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return new Promise(resolve => {
    rl.question(query, answer => {
      rl.close();
      resolve(answer);
    });
  });
}

async function main() {
  let packageName = '';
  while (!packageName.trim()) {
    packageName = await askQuestion('Enter the npm package name you want to deprecate old versions for: ');
    if (!packageName.trim()) {
      console.log('Package name cannot be empty.');
    }
  }

  await deprecateOldVersions(packageName.trim());
}

main();