index.js

const fetch = require("./fetch");

if (!process.env.GITHUB_TOKEN) {
  console.error("🔴 no GITHUB_TOKEN found. pass `GITHUB_TOKEN` as env");
  process.exitCode = 1;
  return;
}
const GITHUB_TOKEN = process.env.GITHUB_TOKEN;

if (!process.env.GITHUB_REPOSITORY) {
  console.error(
    "🔴 no GITHUB_REPOSITORY found. pass `GITHUB_REPOSITORY` as env"
  );
  process.exitCode = 1;
  return;
}

if (!process.env.INPUT_REPO) {
  console.warn("💬  no `repo` name given. fall-ing back to this repo");
}

const [owner, repo] = (
  process.env.INPUT_REPO || process.env.GITHUB_REPOSITORY
).split("/");

if (!owner || !repo) {
  console.error("☠️  either owner or repo name is empty. exiting...");
  process.exitCode = 1;
  return;
}

if (!process.env.INPUT_KEEP_LATEST) {
  console.error("✋🏼  no `keep_latest` given. exiting...");
  process.exitCode = 1;
  return;
}

const keepLatest = Number(process.env.INPUT_KEEP_LATEST);

if (Number.isNaN(keepLatest) || keepLatest < 0) {
  console.error("🤮  invalid `keep_latest` given. exiting...");
  process.exitCode = 1;
  return;
}

if (keepLatest === 0) {
  console.error("🌶  given `keep_latest` is 0, this will wipe out all releases");
}

const shouldDeleteTags = process.env.INPUT_DELETE_TAGS === "true";

if (shouldDeleteTags) {
  console.log("🔖  corresponding tags also will be deleted");
}

let deletePattern = process.env.INPUT_DELETE_TAG_PATTERN || "";
if (deletePattern) {
  console.log(`releases containing ${deletePattern} will be targeted`);
}

let delete_branch = process.env.INPUT_TARGET_BRANCH || "master";
let delete_type = process.env.INPUT_DELETE_TYPE || "release";
console.log(`${delete_type} from ${delete_branch} will be targeted`);


const commonOpts = {
  host: "api.github.com",
  port: 443,
  protocol: "https:",
  auth: `user:${GITHUB_TOKEN}`,
  headers: {
    "Content-Type": "application/json",
    "User-Agent": "node.js",
  },
};

async function deleteOlderReleases(keepLatest) {
  let releaseIdsAndTags = [];
  try {
    let data = await fetch({
      ...commonOpts,
      path: `/repos/${owner}/${repo}/releases?per_page=100`,
      method: "GET",
    });
    data = data || [];
    // filter for delete_pattern
    const activeMatchedReleases = data.filter(
      ({ draft, tag_name, prerelease, target_commitish }) => !draft
        && delete_branch === target_commitish
        && tag_name.indexOf(deletePattern) !== -1
        && (
          (delete_type === 'release' && prerelease === false)
          || (delete_type === 'prerelease' && prerelease === true)
        )
    );

    if (activeMatchedReleases.length === 0) {
      console.log(`😕  no active releases found. exiting...`);
      return;
    }

    const matchingLoggingAddition = deletePattern.length > 0 ? " matching" : "";

    console.log(
      `💬  found total of ${activeMatchedReleases.length}${matchingLoggingAddition} active release(s)`
    );
    releaseIdsAndTags = activeMatchedReleases
      .map(({ id, tag_name: tagName }) => ({ id, tagName }))
      .slice(keepLatest);
  } catch (error) {
    console.error(`🌶  failed to get list of releases <- ${error.message}`);
    console.error(`exiting...`);
    process.exitCode = 1;
    return;
  }

  if (releaseIdsAndTags.length === 0) {
    console.error(`😕  no older releases found. exiting...`);
    return;
  }
  console.log(`🍻  found ${releaseIdsAndTags.length} older release(s)`);

  let hasError = false;
  for (let i = 0; i < releaseIdsAndTags.length; i++) {
    const { id: releaseId, tagName } = releaseIdsAndTags[i];

    try {
      console.log(`starting to delete ${tagName} with id ${releaseId}`);

      const _ = await fetch({
        ...commonOpts,
        path: `/repos/${owner}/${repo}/releases/${releaseId}`,
        method: "DELETE",
      });

      if (shouldDeleteTags) {
        try {
          const _ = await fetch({
            ...commonOpts,
            path: `/repos/${owner}/${repo}/git/refs/tags/${tagName}`,
            method: "DELETE",
          });
        } catch (error) {
          console.error(
            `🌶  failed to delete tag "${tagName}"  <- ${error.message}`
          );
          hasError = true;
          break;
        }
      }
    } catch (error) {
      console.error(
        `🌶  failed to delete release with id "${releaseId}"  <- ${error.message}`
      );
      hasError = true;
      break;
    }
  }

  if (hasError) {
    process.exitCode = 1;
    return;
  }

  console.log(
    `👍🏼  ${releaseIdsAndTags.length} older release(s) deleted successfully!`
  );
}

async function run() {
  await deleteOlderReleases(keepLatest);
}

run();