Delete Old and Unused Lambda Function Versions

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListFunctions",
      "Effect": "Allow",
      "Action": "lambda:ListFunctions",
      "Resource": "*"
    },
    {
      "Sid": "ReadVersionsAndAliases",
      "Effect": "Allow",
      "Action": [
        "lambda:ListVersionsByFunction",
        "lambda:ListAliases"
      ],
      "Resource": "arn:aws:lambda:*:123456789012:function:*"
    },
    {
      "Sid": "DeleteVersionsOnly",
      "Effect": "Allow",
      "Action": "lambda:DeleteFunction",
      "Resource": "arn:aws:lambda:*:123456789012:function:*:*"
    }
  ]
}

// delete-old-lambda-versions.ts
// Lists published versions of your Lambda functions and deletes the ones nothing uses.
// Never touches $LATEST, any version an alias points to (including weighted routing),
// or the newest N versions of each function (default 3).
// Report-only by default; pass --apply to delete.
import {
  LambdaClient,
  paginateListFunctions,
  paginateListVersionsByFunction,
  paginateListAliases,
  DeleteFunctionCommand,
  type FunctionConfiguration,
} from "@aws-sdk/client-lambda";

const args = process.argv.slice(2);
const APPLY = args.includes("--apply");
const argValue = (name: string): string | undefined => {
  const i = args.indexOf(name);
  return i !== -1 ? args[i + 1] : undefined;
};
const KEEP = Number(argValue("--keep") ?? 3);
if (!Number.isInteger(KEEP) || KEEP < 0) throw new Error("--keep must be a whole number (0 or more)");
const ONLY_FUNCTION = argValue("--function"); // optional: one function name or ARN

const region = process.env.AWS_REGION ?? "us-east-1";
const lambda = new LambdaClient({ region });

async function functionNames(): Promise<string[]> {
  if (ONLY_FUNCTION) return [ONLY_FUNCTION];
  const names: string[] = [];
  for await (const page of paginateListFunctions({ client: lambda }, {})) {
    for (const fn of page.Functions ?? []) if (fn.FunctionName) names.push(fn.FunctionName);
  }
  return names;
}

// Every version an alias routes traffic to: the primary version plus weighted extras.
async function versionsUsedByAliases(functionName: string): Promise<Map<string, string[]>> {
  const used = new Map<string, string[]>();
  const add = (version: string, alias: string) => used.set(version, [...(used.get(version) ?? []), alias]);
  for await (const page of paginateListAliases({ client: lambda }, { FunctionName: functionName })) {
    for (const alias of page.Aliases ?? []) {
      const name = alias.Name ?? "?";
      if (alias.FunctionVersion) add(alias.FunctionVersion, name);
      for (const extra of Object.keys(alias.RoutingConfig?.AdditionalVersionWeights ?? {})) add(extra, name);
    }
  }
  return used;
}

async function publishedVersions(functionName: string): Promise<FunctionConfiguration[]> {
  const versions: FunctionConfiguration[] = [];
  for await (const page of paginateListVersionsByFunction({ client: lambda }, { FunctionName: functionName })) {
    for (const v of page.Versions ?? []) {
      if (v.Version && v.Version !== "$LATEST") versions.push(v); // $LATEST is never a candidate
    }
  }
  // Version numbers only grow, so a numeric sort puts the newest first.
  return versions.sort((a, b) => Number(b.Version) - Number(a.Version));
}

async function main(): Promise<void> {
  console.log(`${APPLY ? "APPLY" : "DRY RUN"} in ${region}: keep the newest ${KEEP} version(s) per function`);
  let planned = 0;
  let deleted = 0;
  let bytes = 0;

  for (const name of await functionNames()) {
    const aliasUse = await versionsUsedByAliases(name);
    const versions = await publishedVersions(name);
    if (versions.length === 0) continue;
    console.log(`\n${name}: ${versions.length} published version(s)`);

    const toDelete: FunctionConfiguration[] = [];
    versions.forEach((v, index) => {
      const version = v.Version as string;
      let reason = "";
      if (aliasUse.has(version)) reason = `alias ${aliasUse.get(version)!.join(", ")}`;
      else if (index < KEEP) reason = `one of the newest ${KEEP}`;
      console.log(`  v${version} ${v.LastModified ?? ""} ${reason ? `keep (${reason})` : "delete"}`);
      if (!reason) toDelete.push(v);
    });

    for (const v of toDelete) {
      planned++;
      bytes += v.CodeSize ?? 0;
      if (!APPLY) continue;
      try {
        await lambda.send(new DeleteFunctionCommand({ FunctionName: name, Qualifier: v.Version }));
        deleted++;
        console.log(`  deleted ${name}:${v.Version}`);
      } catch (err) {
        console.error(`  could not delete ${name}:${v.Version}: ${(err as Error).message}`);
      }
    }
  }

  const mb = (bytes / 1024 / 1024).toFixed(1);
  console.log(`\nPlan: delete ${planned} version(s), about ${mb} MB of deployment packages.`);
  if (APPLY) console.log(`Deleted ${deleted} of ${planned}.`);
  else console.log("Dry run: nothing was changed. Re-run with --apply to delete.");
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

npm install @aws-sdk/client-lambda
npm install --save-dev tsx typescript

# Dry run for every function in the region, keeping the newest 3 versions
AWS_PROFILE=readonly AWS_REGION=eu-west-1 npx tsx delete-old-lambda-versions.ts

# One function, keep the newest 5
AWS_PROFILE=readonly AWS_REGION=eu-west-1 npx tsx delete-old-lambda-versions.ts --function orders-api --keep 5

# Delete after reviewing the plan
AWS_PROFILE=admin AWS_REGION=eu-west-1 npx tsx delete-old-lambda-versions.ts --function orders-api --keep 5 --apply

DRY RUN in eu-west-1: keep the newest 3 version(s) per function

orders-api: 9 published version(s)
  v42 2026-09-21T10:02:11.000+0000 keep (alias live)
  v41 2026-09-18T15:40:03.000+0000 keep (alias live, canary)
  v40 2026-09-12T09:12:55.000+0000 keep (one of the newest 3)
  v39 2026-09-05T08:30:19.000+0000 delete
  v38 2026-08-29T17:01:47.000+0000 delete
  v35 2026-08-02T11:22:08.000+0000 keep (alias rollback)
  v31 2026-07-14T14:10:36.000+0000 delete
  v30 2026-07-10T09:03:29.000+0000 delete
  v12 2026-02-01T12:00:00.000+0000 delete

image-resizer: 2 published version(s)
  v4 2026-06-30T07:45:10.000+0000 keep (alias prod)
  v3 2026-06-01T07:40:02.000+0000 keep (one of the newest 3)

Plan: delete 5 version(s), about 61.4 MB of deployment packages.
Dry run: nothing was changed. Re-run with --apply to delete.