cf-worker-prune-routes/index.js

Prune unused cloudflare worker routes

import fs from 'fs';
import toml from 'toml';
import { wranglerPruneRoute, wranglerListRoutes } from './lib/execWrangler.js';
let logVerbose = false;

const verboseLogger = (msg) => {
  if (logVerbose) console.log(msg);
};

const wranglerParseError = (msg) => {
  throw new Error(`Wrangler Parse Error: ${msg}`);
};

const pruneWorkerRoutes = async ({ routes, env, config, workerName }) => {
  const allPrunes = routes.map((route) => {
    return wranglerPruneRoute({ id: route.id, env, config });
  });

  const allRoutes = await Promise.all(allPrunes);

  verboseLogger(
    `Pruned ${routes.length} live routes for env:${env} for worker ${workerName}`,
    allRoutes
  );
};

const fetchWorkerRoutes = async ({ config, env, workerName }) => {
  const allRoutes = await wranglerListRoutes({ config, env });
  const envRoutes = allRoutes.filter((r) => r.script === workerName);

  verboseLogger(
    `Found ${envRoutes.length} live routes for env:${env} for worker ${workerName}`,
    envRoutes
  );
  return envRoutes;
};

export const parseWranglerConfig = ({ config, env }) => {
  const rawWranglerConfig = fs.readFileSync(config);
  const wranglerConfig = toml.parse(rawWranglerConfig);
  verboseLogger(`Parsed wrangler config file ${config}`);
  const envConfig = wranglerConfig?.env[env];
  const workerName = envConfig?.name || `${wranglerConfig.name}-${env}`;
  if (!workerName)
    wranglerParseError('Missing "name" property in wrangler.toml');
  const routes = envConfig.routes || [];
  if (!routes.length)
    wranglerParseError(
      `Missing routes config for env "${env}" in wrangler.toml`
    );
  verboseLogger(`Found existing routes for env:${env} =>`, routes);
  return {
    workerName,
    routes,
  };
};

export const cfWorkerPruneRoutes = async ({
  config,
  env,
  verbose,
  execute,
  fail,
}) => {
  logVerbose = verbose;
  const { routes, workerName } = parseWranglerConfig({
    config,
    env,
  });

  const liveRoutes = await fetchWorkerRoutes({
    config,
    env,
    workerName,
  });

  verboseLogger(`Found configured routes for env:${env} =>`);
  verboseLogger(routes);
  verboseLogger(`Found live routes for env:${env} =>`);
  verboseLogger(liveRoutes);

  const routesToPrune = liveRoutes.filter((r) => !routes.includes(r.pattern));
  verboseLogger(
    `Found ${routesToPrune.length} pruneable routes for env:${env}`
  );
  verboseLogger(routesToPrune);

  if (execute) {
    console.log(`Pruning ${routesToPrune.length} routes for env:${env}`);
    await pruneWorkerRoutes({
      routes: routesToPrune,
      env,
      workerName,
      config,
    });
  } else if (fail) {
    console.log(`Found the following unused routes:`);
    if (routesToPrune.length) {
      routesToPrune.forEach((r) => {
        console.log(`${r.pattern}`);
      });
      process.exit(1);
    }
  } else {
    console.log(
      `Would have pruned ${routesToPrune.length} routes for env:${env}`
    );
    console.log(
      `Pass the --execute option to delete these routes on cloudflare`
    );
    routesToPrune.forEach((r) => {
      console.log(`-- ${r.pattern}`);
    });

    if (routesToPrune.length && fail) {
      process.exit(1);
    }
  }
};