index.js

const core = require("@actions/core");
const { Octokit } = require("@octokit/action");
const { throttling } = require("@octokit/plugin-throttling");
const moment = require("moment");

const devEnv = process.env.NODE_ENV === "dev";

const inputKeys = {
  AGE: devEnv ? "AGE" : "age",
};

if (devEnv) {
  // eslint-disable-next-line global-require, import/no-extraneous-dependencies
  require("dotenv-safe").config();
}

function readInput(key, isRequired = false) {
  if (devEnv) {
    return process.env[key];
  }

  return core.getInput(key, { required: isRequired });
}

function getConfig() {
  const [owner, repo] = process.env.GITHUB_REPOSITORY.split("/");
  const [age, units] = readInput(inputKeys.AGE, true).split(" ");
  const maxAge = moment().subtract(age, units);

  console.log(
    "Maximum artifact age:",
    age,
    units,
    "( created before",
    maxAge.format(),
    ")"
  );

  return {
    repo: {
      owner,
      repo,
    },
    pagination: {
      perPage: 100,
    },
    maxAge: moment().subtract(age, units),
    retriesEnabled: true,
  };
}

const ThrottledOctokit = Octokit.plugin(throttling);

async function run() {
  const config = getConfig();
  const octokit = new ThrottledOctokit({
    throttle: {
      onRateLimit: (retryAfter, options) => {
        console.error(
          `Request quota exhausted for request ${options.method} ${options.url}, number of total global retries: ${options.request.retryCount}`
        );

        console.log(`Retrying after ${retryAfter} seconds!`);

        return config.retriesEnabled;
      },
      onAbuseLimit: (retryAfter, options) => {
        console.error(
          `Abuse detected for request ${options.method} ${options.url}, retry count: ${options.request.retryCount}`
        );

        console.log(`Retrying after ${retryAfter} seconds!`);

        return config.retriesEnabled;
      },
    },
  });

  const artifactRequest = octokit.actions.listArtifactsForRepo.endpoint.merge({
    ...config.repo,
    per_page: config.pagination.perPage,
  });

  const artifacts = await octokit.paginate(
    artifactRequest,
    // eslint-disable-next-line no-unused-vars
    ({ data }, done) => {
      console.log("Received a page");
      return data;
    }
  );
  console.log(`Considering ${artifacts.length} artifacts...`);
  const artifactPromises = artifacts
    .filter(artifact => {
      const createdAt = moment(artifact.created_at);
      const toBeDeleted = createdAt.isBefore(config.maxAge);

      if (!toBeDeleted) {
        console.log(
          ` Keeping ${artifact.name} (id ${artifact.id}) from ${artifact.created_at}`
        );
      }

      return toBeDeleted;
    })
    .map(artifact => {
      console.log(
        `About to remove id: ${artifact.id}, name: ${artifact.name}).`
      );

      return octokit.actions
        .deleteArtifact({
          ...config.repo,
          artifact_id: artifact.id,
        })
        .then(() => {
          console.log(
            `Successfully removed artifact (id: ${artifact.id}, name: ${artifact.name}).`
          );
        })
        .catch(e => {
          console.log(
            `Error on deleting (id: ${artifact.id}, name: ${artifact.name}): ${e}.`
          );
          throw e;
        });
    });

  return Promise.all(artifactPromises).then(artifactDeletePromises =>
    Promise.all([].concat(...artifactDeletePromises))
  );
}

run().catch(err => {
  core.setFailed(err.toString());
});