@aws-sdk/find-v2 0.4.2 → 0.5.0

package/README.md

@@ -32,31 +32,18 @@ Commands:
 Run `lambda` command to scan Lambda Node.js Functions for JavaScript SDK v2.
 
 ```console
-$ npx @aws-sdk/find-v2 lambda --yes
-[
-  {
-    "FunctionName": "fn-without-aws-sdk-in-bundle",
-    "Region": "us-east-2",
-    "ContainsAwsSdkJsV2": false
-  },
-  {
-    "FunctionName": "fn-with-aws-sdk-in-bundle",
-    "Region": "us-east-2",
-    "ContainsAwsSdkJsV2": true,
-    "AwsSdkJsV2Location": "Bundled in 'index.js'"
-  },
-  {
-    "FunctionName": "fn-with-aws-sdk-in-package-json-deps",
-    "Region": "us-east-2",
-    "ContainsAwsSdkJsV2": true,
-    "AwsSdkJsV2Location": "Defined in dependencies of 'package.json'"
-  },
-  {
-    "FunctionName": "fn-without-aws-sdk-in-package-json-deps",
-    "Region": "us-east-2",
-    "ContainsAwsSdkJsV2": false
-  }
-]
+$ npx @aws-sdk/find-v2 lambda --yes --output table
+┌─────────────────────────────────────────┬───────────┬────────────┬────────────────────────────────────────────────┐
+│ FunctionName                            │ Region    │ Runtime    │ ContainsAwsSdkJsV2                             │
+├─────────────────────────────────────────┼───────────┼────────────┼────────────────────────────────────────────────┤
+│ fn-without-aws-sdk-in-bundle            │ us-east-2 │ nodejs24.x │ No.                                            │
+├─────────────────────────────────────────┼───────────┼────────────┼────────────────────────────────────────────────┤
+│ fn-with-aws-sdk-in-bundle               │ us-east-2 │ nodejs24.x │ Yes. Bundled in 'index.js'                     │
+├─────────────────────────────────────────┼───────────┼────────────┼────────────────────────────────────────────────┤
+│ fn-with-aws-sdk-in-package-json-deps    │ us-east-2 │ nodejs24.x │ Yes. Defined in dependencies of 'package.json' │
+├─────────────────────────────────────────┼───────────┼────────────┼────────────────────────────────────────────────┤
+│ fn-without-aws-sdk-in-package-json-deps │ us-east-2 │ nodejs24.x │ No.                                            │
+└─────────────────────────────────────────┴───────────┴────────────┴────────────────────────────────────────────────┘
 ```
 
 This script requires AWS Managed Policy [AWSLambda_ReadOnlyAccess][].

package/dist/cli.js

@@ -1,7 +1,9 @@
-import { Command } from "commander";
+import { Command, Option } from "commander";
+import { satisfies } from "compare-versions";
 import { cpus } from "node:os";
 import packageJson from "../package.json" with { type: "json" };
 import { scanLambdaFunctions } from "./scanLambdaFunctions.js";
+import { LambdaCommandOutputType } from "./utils/printLambdaCommandOutput.js";
 /**
  * Creates and configures the CLI program with available commands.
  *
@@ -17,9 +19,21 @@ export const createProgram = () => {
     program
         .command("lambda")
         .description("Scans Lambda Node.js Functions for JavaScript SDK v2")
-        .option("-y, --yes", "answer yes for all prompts")
-        .option("-r, --region <region>", "AWS region to scan")
-        .option("-p, --profile <profile>", "AWS profile to use")
+        .option("-y, --yes", "answer yes for all prompts", false)
+        .option("--node <semver>", "Semver range string to select Lambda Node.js major versions", (value) => {
+        try {
+            satisfies("0", value);
+        }
+        catch {
+            throw new Error(`Invalid semver range: ${value}`);
+        }
+        return value;
+    }, ">=20")
+        .option("--region <region>", "AWS region to scan")
+        .option("--profile <profile>", "AWS profile to use")
+        .addOption(new Option("-o, --output <output>", "Output format")
+        .choices(Object.values(LambdaCommandOutputType))
+        .default(LambdaCommandOutputType.json))
         .option("-j, --jobs <count>", "number of parallel jobs", (value) => {
         const trimmed = value.trim();
         if (!/^\d+$/.test(trimmed)) {

package/dist/scanLambdaFunctions.js

@@ -1,15 +1,22 @@
 import { Lambda } from "@aws-sdk/client-lambda";
 import pLimit from "p-limit";
-import { getLambdaFunctionScanOutput } from "./getLambdaFunctionScanOutput.js";
 import { getDownloadConfirmation } from "./utils/getDownloadConfirmation.js";
 import { getLambdaFunctions } from "./utils/getLambdaFunctions.js";
-export const scanLambdaFunctions = async (options = {}) => {
-    const { region, yes, jobs, profile } = options;
+import { getLambdaFunctionScanOutput } from "./utils/getLambdaFunctionScanOutput.js";
+import { getLambdaNodeJsMatchingVersions } from "./utils/getLambdaNodeJsMatchingVersions.js";
+import { LambdaCommandOutputType, printLambdaCommandOutput, } from "./utils/printLambdaCommandOutput.js";
+export const scanLambdaFunctions = async (options) => {
+    const { yes, node, region, profile, output, jobs } = options;
     const client = new Lambda({
         ...(region && { region }),
         ...(profile && { profile }),
     });
-    const functions = await getLambdaFunctions(client);
+    const lambdaNodeJsMajorVersions = getLambdaNodeJsMatchingVersions(node);
+    if (lambdaNodeJsMajorVersions.length === 0) {
+        printLambdaCommandOutput([], output);
+        return;
+    }
+    const functions = await getLambdaFunctions(client, lambdaNodeJsMajorVersions);
     const functionCount = functions.length;
     const concurrency = Math.min(functionCount, jobs || 1);
     const codeSizeToDownload = functions.reduce((acc, fn) => acc + (fn.CodeSize || 0), 0);
@@ -19,22 +26,23 @@ export const scanLambdaFunctions = async (options = {}) => {
         .slice(0, concurrency)
         .reduce((acc, size) => acc + size, 0);
     if (functionCount === 0) {
-        console.log("[]");
-        process.exit(0);
+        printLambdaCommandOutput([], output);
+        return;
     }
     if (!yes) {
         const confirmation = await getDownloadConfirmation(functionCount, codeSizeToDownload, codeSizeToSaveOnDisk);
         console.log();
         if (!confirmation) {
             console.log("Exiting.");
-            process.exit(0);
+            return;
         }
     }
     const clientRegion = await client.config.region();
     const limit = pLimit(concurrency);
-    const output = await Promise.all(functions.map((fn) => limit(() => getLambdaFunctionScanOutput(client, {
+    const scanOutput = await Promise.all(functions.map((fn) => limit(() => getLambdaFunctionScanOutput(client, {
         functionName: fn.FunctionName,
         region: clientRegion,
+        runtime: fn.Runtime,
     }))));
-    console.log(JSON.stringify(output, null, 2));
+    printLambdaCommandOutput(scanOutput, output);
 };

package/dist/{getLambdaFunctionScanOutput.js → utils/getLambdaFunctionScanOutput.js}

@@ -1,13 +1,14 @@
-import { downloadFile } from "./utils/downloadFile.js";
-import { getLambdaFunctionContents, } from "./utils/getLambdaFunctionContents.js";
-import { hasSdkV2InBundle } from "./utils/hasSdkV2InBundle.js";
+import { downloadFile } from "./downloadFile.js";
+import { getLambdaFunctionContents, } from "./getLambdaFunctionContents.js";
+import { hasSdkV2InBundle } from "./hasSdkV2InBundle.js";
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-export const getLambdaFunctionScanOutput = async (client, { functionName, region }) => {
+export const getLambdaFunctionScanOutput = async (client, { functionName, region, runtime }) => {
     const output = {
         FunctionName: functionName,
         Region: region,
+        Runtime: runtime,
         ContainsAwsSdkJsV2: null,
     };
     const response = await client.getFunction({ FunctionName: functionName });

package/dist/utils/getLambdaFunctions.js

@@ -3,17 +3,19 @@ import { paginateListFunctions } from "@aws-sdk/client-lambda";
  * Retrieves all Lambda functions with Node.js runtime from AWS
  *
  * @param client - AWS Lambda client instance
+ * @param lambdaNodeJsMajorVersions - Array of Node.js major versions to filter (e.g., ["18", "20"])
  * @returns Promise that resolves to array of Lambda function configurations
  * @description
  * - Uses AWS SDK v3 pagination to handle large number of functions
- * - Filters results to only include Node.js runtimes
+ * - Filters results to only include specified Node.js runtimes
  * - Returns empty array if no functions found
  */
-export const getLambdaFunctions = async (client) => {
+export const getLambdaFunctions = async (client, lambdaNodeJsMajorVersions) => {
     const functions = [];
+    const lambdaNodeJsIdentifiers = lambdaNodeJsMajorVersions.map((version) => `nodejs${version}.x`);
     const paginator = paginateListFunctions({ client }, {});
     for await (const page of paginator) {
-        functions.push(...(page.Functions ?? []).filter((fn) => fn.Runtime?.startsWith("nodejs")));
+        functions.push(...(page.Functions ?? []).filter((fn) => lambdaNodeJsIdentifiers.includes(fn.Runtime ?? "")));
     }
     return functions;
 };

package/dist/utils/getLambdaNodeJsMatchingVersions.js

@@ -0,0 +1,17 @@
+import { satisfies } from "compare-versions";
+// Refs: https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
+export const LambdaNodeJsMajorVersions = ["10", "12", "14", "16", "18", "20", "22", "24"];
+/**
+ * Returns Lambda Node.js major versions that satisfy the given semver range.
+ * @param semverRange - A valid semver range string (e.g., ">=18")
+ * @returns Array of matching Node.js major version strings supported by Lambda
+ */
+export const getLambdaNodeJsMatchingVersions = (semverRange) => {
+    const matchingVersions = [];
+    for (const nodejsVersion of LambdaNodeJsMajorVersions) {
+        if (satisfies(nodejsVersion, semverRange)) {
+            matchingVersions.push(nodejsVersion);
+        }
+    }
+    return matchingVersions;
+};

package/dist/utils/printLambdaCommandOutput.js

@@ -0,0 +1,34 @@
+import Table from "cli-table3";
+export const LambdaCommandOutputType = {
+    // prints output as JSON
+    json: "json",
+    // prints human-readable representation in a table
+    table: "table",
+};
+export const printLambdaCommandOutput = (output, outputType) => {
+    // Output as JSON
+    if (outputType === LambdaCommandOutputType.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    // Output as table
+    const table = new Table({
+        head: ["FunctionName", "Region", "Runtime", "ContainsAwsSdkJsV2"],
+        style: { head: ["bold"] },
+    });
+    for (const scanOutput of output) {
+        let notes = scanOutput.ContainsAwsSdkJsV2 === null
+            ? "N/A."
+            : scanOutput.ContainsAwsSdkJsV2
+                ? "Yes."
+                : "No.";
+        if (scanOutput.AwsSdkJsV2Error !== undefined) {
+            notes += ` ${scanOutput.AwsSdkJsV2Error}`;
+        }
+        if (scanOutput.AwsSdkJsV2Location !== undefined) {
+            notes += ` ${scanOutput.AwsSdkJsV2Location}`;
+        }
+        table.push([scanOutput.FunctionName, scanOutput.Region, scanOutput.Runtime, notes]);
+    }
+    console.log(table.toString());
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@aws-sdk/find-v2",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "CLI to find resources which call AWS using JavaScript SDK v2",
   "main": "dist/cli.js",
   "types": "dist/cli.d.ts",
   "bin": "bin/@aws-sdk/find-v2",
   "dependencies": {
     "@aws-sdk/client-lambda": "^3.942.0",
+    "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
+    "compare-versions": "^6.1.1",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^7.2.0"
   },