@aws-sdk/find-v2 0.7.1 → 0.7.2

package/dist/scanLambdaFunctions.js

@@ -1,5 +1,7 @@
 import { Lambda } from "@aws-sdk/client-lambda";
 import pLimit from "p-limit";
+import { getCodeSizeToDownload } from "./utils/getCodeSizeToDownload.js";
+import { getCodeSizeToSaveOnDisk } from "./utils/getCodeSizeToSaveOnDisk.js";
 import { getDownloadConfirmation } from "./utils/getDownloadConfirmation.js";
 import { getLambdaFunctions } from "./utils/getLambdaFunctions.js";
 import { getLambdaFunctionScanOutput } from "./utils/getLambdaFunctionScanOutput.js";
@@ -18,19 +20,13 @@ export const scanLambdaFunctions = async (options) => {
     }
     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);
-    const codeSizeToSaveOnDisk = functions
-        .map((fn) => fn.CodeSize || 0)
-        .sort((a, b) => b - a)
-        .slice(0, concurrency)
-        .reduce((acc, size) => acc + size, 0);
     if (functionCount === 0) {
         printLambdaCommandOutput([], output);
         return;
     }
+    const concurrency = Math.min(functionCount, jobs || 1);
     if (!yes) {
-        const confirmation = await getDownloadConfirmation(functionCount, codeSizeToDownload, codeSizeToSaveOnDisk);
+        const confirmation = await getDownloadConfirmation(functionCount, getCodeSizeToDownload(functions), getCodeSizeToSaveOnDisk(functions, concurrency));
         console.log();
         if (!confirmation) {
             console.log("Exiting.");
@@ -42,7 +38,6 @@ export const scanLambdaFunctions = async (options) => {
     const scanOutput = await Promise.all(functions.map((fn) => limit(() => getLambdaFunctionScanOutput(client, {
         functionName: fn.FunctionName,
         region: clientRegion,
-        runtime: fn.Runtime,
         sdkVersionRange: sdk,
     }))));
     printLambdaCommandOutput(scanOutput, output);

package/dist/utils/constants.js

@@ -1,3 +1,5 @@
-export const PACKAGE_JSON = "package.json";
+import { join } from "node:path";
 export const NODE_MODULES = "node_modules";
 export const AWS_SDK = "aws-sdk";
+export const PACKAGE_JSON = "package.json";
+export const AWS_SDK_PACKAGE_JSON = join(NODE_MODULES, AWS_SDK, PACKAGE_JSON);

package/dist/utils/getCodePathToSdkVersionMap.js

@@ -1,6 +1,5 @@
 import { dirname, join } from "node:path";
-import { AWS_SDK, NODE_MODULES, PACKAGE_JSON } from "./constants.js";
-const AWS_SDK_PACKAGE_JSON = join(NODE_MODULES, AWS_SDK, PACKAGE_JSON);
+import { AWS_SDK, AWS_SDK_PACKAGE_JSON, PACKAGE_JSON } from "./constants.js";
 const safeParse = (json) => {
     try {
         return JSON.parse(json);

package/dist/utils/getCodeSizeToDownload.js

@@ -0,0 +1,3 @@
+import { getLambdaLayerToCodeSizeMap } from "./getLambdaLayerToCodeSizeMap.js";
+export const getCodeSizeToDownload = (functions) => functions.reduce((acc, fn) => acc + (fn.CodeSize || 0), 0) +
+    [...getLambdaLayerToCodeSizeMap(functions).values()].reduce((acc, size) => acc + size, 0);

package/dist/utils/getCodeSizeToSaveOnDisk.js

@@ -0,0 +1,10 @@
+import { getLambdaLayerToCodeSizeMap } from "./getLambdaLayerToCodeSizeMap.js";
+const getFunctionTotalSize = (fn) => (fn.CodeSize || 0) + (fn.Layers?.reduce((acc, l) => acc + (l.CodeSize || 0), 0) || 0);
+export const getCodeSizeToSaveOnDisk = (functions, num) => {
+    const largestFunctions = [...functions]
+        .sort((a, b) => getFunctionTotalSize(b) - getFunctionTotalSize(a))
+        .slice(0, num);
+    const functionSize = largestFunctions.reduce((acc, fn) => acc + (fn.CodeSize || 0), 0);
+    const layerSize = [...getLambdaLayerToCodeSizeMap(largestFunctions).values()].reduce((acc, size) => acc + size, 0);
+    return functionSize + layerSize;
+};

package/dist/utils/getLambdaFunctionContents.js

@@ -1,68 +1,74 @@
-import StreamZip from "node-stream-zip";
-import { AWS_SDK, NODE_MODULES, PACKAGE_JSON } from "./constants.js";
-import { join } from "node:path";
+import { AWS_SDK_PACKAGE_JSON, NODE_MODULES, PACKAGE_JSON } from "./constants.js";
+import { getLambdaLayerContents } from "./getLambdaLayerContents.js";
+import { getSdkVersionFromLambdaLayerContents } from "./getSdkVersionFromLambdaLayerContents.js";
+import { processRemoteZip } from "./processRemoteZip.js";
+import { processZipEntries } from "./processZipEntries.js";
 /**
- * Extracts the contents of a Lambda Function zip file.
+ * Cache for Lambda layer contents to avoid redundant downloads.
+ * Maps layer ARN to extracted layer contents.
+ */
+const lambdaLayerCache = new Map();
+/**
+ * Extracts and categorizes contents from a Lambda Function deployment package.
  *
- * Parses the zip and returns:
- * - JS/TS source files (excluding node_modules)
+ * Downloads and processes the Lambda function's zip file to extract:
+ * - JavaScript/TypeScript source files (excluding node_modules)
  * - package.json files (excluding node_modules)
- * - aws-sdk package.json from node_modules (for version detection)
+ * - AWS SDK package.json files from node_modules and layers (for version detection)
  *
- * @param zipPath - The path to the zip file of Lambda Function.
- * @returns Extracted contents categorized by file type.
+ * @param client - The Lambda client instance for API calls
+ * @param options - Configuration options for content extraction
+ * @param options.codeLocation - Presigned URL to download the Lambda function code
+ * @param options.runtime - Lambda runtime identifier (e.g., 'nodejs20.x')
+ * @param options.layers - Array of Lambda layers attached to the function
+ * @returns Promise resolving to categorized file contents with optional maps for package.json and AWS SDK files
  */
-export const getLambdaFunctionContents = async (zipPath) => {
-    const zip = new StreamZip.async({ file: zipPath });
+export const getLambdaFunctionContents = async (client, { codeLocation, runtime, layers = [] }) => {
     const codeMap = new Map();
     const packageJsonMap = new Map();
     const awsSdkPackageJsonMap = new Map();
-    let zipEntries = {};
-    try {
-        zipEntries = await zip.entries();
-    }
-    catch {
-        // Continue with empty object, if zip entries can't be read.
-        // ToDo: add warning when logging is supported in future.
-    }
-    for (const zipEntry of Object.values(zipEntries)) {
-        // Skip 'node_modules' directory, except for aws-sdk package.json file.
-        if (zipEntry.name.includes(`${NODE_MODULES}/`)) {
-            if (zipEntry.name.endsWith(join(NODE_MODULES, AWS_SDK, PACKAGE_JSON)) && zipEntry.isFile) {
-                const packageJsonContent = await zip.entryData(zipEntry.name);
-                awsSdkPackageJsonMap.set(zipEntry.name, packageJsonContent.toString());
-            }
-            continue;
-        }
-        // Skip if it is not a file
-        if (!zipEntry.isFile)
-            continue;
-        // Populate 'package.json' files.
-        if (zipEntry.name.endsWith(PACKAGE_JSON)) {
-            try {
-                const packageJsonContent = await zip.entryData(zipEntry.name);
-                packageJsonMap.set(zipEntry.name, packageJsonContent.toString());
-            }
-            catch {
-                // Continue without adding package.json file, if entry data can't be read.
-                // ToDo: add warning when logging is supported in future.
-            }
+    // Populate awsSdkPackageJsonMap with layers first.
+    for (const layer of layers) {
+        if (!layer.Arn)
             continue;
+        if (!lambdaLayerCache.has(layer.Arn)) {
+            const response = await client.getLayerVersionByArn({ Arn: layer.Arn });
+            const layerContents = response.Content?.Location
+                ? await getLambdaLayerContents(response.Content.Location)
+                : new Map();
+            lambdaLayerCache.set(layer.Arn, layerContents);
         }
-        // Populate JavaScript/TypeScript files.
-        if (zipEntry.name.match(/\.(js|ts|mjs|cjs)$/)) {
+        const layerContents = lambdaLayerCache.get(layer.Arn) || new Map();
+        const version = getSdkVersionFromLambdaLayerContents(layerContents, runtime);
+        if (version)
+            awsSdkPackageJsonMap.set(AWS_SDK_PACKAGE_JSON, JSON.stringify({ version }));
+    }
+    await processRemoteZip(codeLocation, async (zipPath) => {
+        await processZipEntries(zipPath, async (entry, getData) => {
+            if (!entry.isFile)
+                return;
             try {
-                const codeContent = await zip.entryData(zipEntry.name);
-                codeMap.set(zipEntry.name, codeContent.toString());
+                // Handle aws-sdk package.json in node_modules
+                if (entry.name.endsWith(AWS_SDK_PACKAGE_JSON)) {
+                    awsSdkPackageJsonMap.set(entry.name, (await getData()).toString());
+                }
+                // Handle files outside of node_modules
+                else if (!entry.name.includes(`${NODE_MODULES}/`)) {
+                    // Handle package.json
+                    if (entry.name.endsWith(PACKAGE_JSON)) {
+                        packageJsonMap.set(entry.name, (await getData()).toString());
+                    }
+                    // Handle JS/TS files
+                    else if (entry.name.match(/\.(js|ts|mjs|cjs)$/)) {
+                        codeMap.set(entry.name, (await getData()).toString());
+                    }
+                }
             }
             catch {
-                // Continue without adding code, if entry data can't be read.
-                // ToDo: add warning when logging is supported in future.
+                // Continue if entry data can't be read.
             }
-            continue;
-        }
-    }
-    await zip.close();
+        });
+    });
     return {
         codeMap,
         ...(packageJsonMap.size > 0 && { packageJsonMap }),

package/dist/utils/getLambdaFunctionScanOutput.js

@@ -1,13 +1,9 @@
 import { satisfies, validate } from "compare-versions";
-import { downloadFile } from "./downloadFile.js";
+import { getCodePathToSdkVersionMap } from "./getCodePathToSdkVersionMap.js";
 import { getLambdaFunctionContents, } from "./getLambdaFunctionContents.js";
 import { getPossibleHandlerFiles } from "./getPossibleHandlerFiles.js";
 import { hasSdkV2InBundle } from "./hasSdkV2InBundle.js";
 import { hasSdkV2InFile } from "./hasSdkV2InFile.js";
-import { rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getCodePathToSdkVersionMap } from "./getCodePathToSdkVersionMap.js";
 /**
  * Scans a Lambda function to detect AWS SDK for JavaScript v2 usage.
  *
@@ -19,11 +15,12 @@ import { getCodePathToSdkVersionMap } from "./getCodePathToSdkVersionMap.js";
  * @param options - Scan configuration options
  * @param options.functionName - The name of the Lambda function
  * @param options.region - AWS region the Lambda function is deployed to
- * @param options.runtime - Lambda Function's Node.js runtime
  * @param options.sdkVersionRange - Semver range string to check for AWS SDK for JavaScript v2
  * @returns Scan results including SDK v2 detection status and locations
  */
-export const getLambdaFunctionScanOutput = async (client, { functionName, region, runtime, sdkVersionRange }) => {
+export const getLambdaFunctionScanOutput = async (client, { functionName, region, sdkVersionRange }) => {
+    const response = await client.getFunction({ FunctionName: functionName });
+    const runtime = response.Configuration?.Runtime;
     const output = {
         FunctionName: functionName,
         Region: region,
@@ -31,16 +28,18 @@ export const getLambdaFunctionScanOutput = async (client, { functionName, region
         SdkVersion: sdkVersionRange,
         ContainsAwsSdkJsV2: null,
     };
-    const response = await client.getFunction({ FunctionName: functionName });
-    if (!response.Code?.Location) {
+    const codeLocation = response.Code?.Location;
+    if (!codeLocation) {
         output.AwsSdkJsV2Error = "Function Code location not found.";
         return output;
     }
-    const zipPath = join(tmpdir(), `${functionName}.zip`);
     let lambdaFunctionContents;
     try {
-        await downloadFile(response.Code.Location, zipPath);
-        lambdaFunctionContents = await getLambdaFunctionContents(zipPath);
+        lambdaFunctionContents = await getLambdaFunctionContents(client, {
+            codeLocation,
+            runtime,
+            layers: response.Configuration?.Layers,
+        });
     }
     catch (error) {
         const errorPrefix = "Error downloading or reading Lambda function code";
@@ -48,9 +47,6 @@ export const getLambdaFunctionScanOutput = async (client, { functionName, region
             error instanceof Error ? `${errorPrefix}: ${error.message}` : errorPrefix;
         return output;
     }
-    finally {
-        await rm(zipPath, { force: true });
-    }
     const { packageJsonMap, awsSdkPackageJsonMap, codeMap } = lambdaFunctionContents;
     // Process handler as bundle file first.
     const possibleHandlerFiles = getPossibleHandlerFiles(response.Configuration?.Handler ?? "index.handler");

package/dist/utils/getLambdaLayerContents.js

@@ -0,0 +1,27 @@
+import { AWS_SDK_PACKAGE_JSON } from "./constants.js";
+import { processZipEntries } from "./processZipEntries.js";
+import { processRemoteZip } from "./processRemoteZip.js";
+/**
+ * Downloads and extracts the contents of a Lambda layer from its presigned URL.
+ * Parses the zip and returns aws-sdk package.json from node_modules
+ *
+ * @param codeLocation - The presigned URL to download the Lambda layer.
+ * @returns Map of aws-sdk package.json files with their versions found in the layer.
+ */
+export const getLambdaLayerContents = async (codeLocation) => {
+    const lambdaLayerContents = new Map();
+    await processRemoteZip(codeLocation, async (zipPath) => {
+        await processZipEntries(zipPath, async (entry, getData) => {
+            if (!entry.isFile || !entry.name.endsWith(AWS_SDK_PACKAGE_JSON))
+                return;
+            try {
+                const { version } = JSON.parse((await getData()).toString());
+                lambdaLayerContents.set(entry.name, { version });
+            }
+            catch {
+                // Continue without adding package.json file, if entry data can't be read or there's parse error.
+            }
+        });
+    });
+    return lambdaLayerContents;
+};

package/dist/utils/getLambdaLayerToCodeSizeMap.js

@@ -0,0 +1,4 @@
+export const getLambdaLayerToCodeSizeMap = (functions) => new Map(functions
+    .flatMap((fn) => fn.Layers ?? [])
+    .filter((layer) => layer.Arn && layer.CodeSize)
+    .map((layer) => [layer.Arn, layer.CodeSize]));

package/dist/utils/getSdkVersionFromLambdaLayerContents.js

@@ -0,0 +1,24 @@
+import { AWS_SDK_PACKAGE_JSON } from "./constants.js";
+/**
+ * Returns version from aws-sdk package.json value based on specificity
+ * - nodejs/node{major-version}/node_modules/aws-sdk/package.json
+ * - nodejs/node_modules/aws-sdk/package.json
+ * - node_modules/aws-sdk/package.json
+ *
+ * @param lambdaLayerContents - Map with aws-sdk package.json filepath as key and contents as value.
+ * @param runtime - Lambda runtime (e.g., nodejs20.x)
+ * @returns The sdk version string, or undefined if not found.
+ */
+export const getSdkVersionFromLambdaLayerContents = (lambdaLayerContents, runtime) => {
+    const majorVersion = runtime.match(/nodejs(\d+)/)?.[1];
+    const paths = [
+        `nodejs/node${majorVersion}/${AWS_SDK_PACKAGE_JSON}`,
+        `nodejs/${AWS_SDK_PACKAGE_JSON}`,
+        AWS_SDK_PACKAGE_JSON,
+    ];
+    for (const path of paths) {
+        const content = lambdaLayerContents.get(path);
+        if (content)
+            return content.version;
+    }
+};

package/dist/utils/processRemoteZip.js

@@ -0,0 +1,27 @@
+import { randomUUID } from "node:crypto";
+import { rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Downloads a zip file, runs a processor, then cleans up.
+ *
+ * @param url - The URL to download the zip from.
+ * @param processor - Function that processes the zip file at the given path.
+ */
+export const processRemoteZip = async (url, processor) => {
+    const zipPath = join(tmpdir(), `${randomUUID()}.zip`);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download '${url}'. Received ${response.status} with '${response.statusText}'.`);
+    }
+    if (!response.body) {
+        throw new Error(`Response body is null for '${url}'`);
+    }
+    await writeFile(zipPath, response.body);
+    try {
+        await processor(zipPath);
+    }
+    finally {
+        await rm(zipPath, { force: true });
+    }
+};

package/dist/utils/processZipEntries.js

@@ -0,0 +1,17 @@
+import StreamZip from "node-stream-zip";
+/**
+ * Processes entries in a zip file using a callback function.
+ *
+ * @param zipPath - Path to the zip file.
+ * @param processor - Callback to process each entry.
+ */
+export const processZipEntries = async (zipPath, processor) => {
+    const zip = new StreamZip.async({ file: zipPath });
+    // Continue with empty object, if zip entries can't be read.
+    const zipEntries = await zip.entries().catch(() => ({}));
+    for (const entry of Object.values(zipEntries)) {
+        // Processor callback is provided by callee, and it should handle errors.
+        await processor(entry, () => zip.entryData(entry.name)).catch(() => { });
+    }
+    await zip.close();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/find-v2",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "CLI to find resources which call AWS using JavaScript SDK v2",
   "main": "dist/cli.js",
   "types": "dist/cli.d.ts",
@@ -31,7 +31,7 @@
     "oxfmt": "^0.21.0",
     "oxlint": "^1.33.0",
     "parcel": "^2.16.3",
-    "rolldown": "1.0.0-beta.58",
+    "rolldown": "1.0.0-beta.59",
     "rollup": "^4.53.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.15",

package/dist/utils/downloadFile.js

@@ -1,19 +0,0 @@
-import { writeFile } from "node:fs/promises";
-/**
- * Downloads a file from a URL and saves it to the specified path.
- *
- * @param url - The URL of the file to download.
- * @param outputPath - The local file path where the downloaded file should be saved.
- * @throws {Error} If the download fails or response body is null.
- * @returns Promise that resolves when file is downloaded and saved.
- */
-export const downloadFile = async (url, outputPath) => {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download '${url}'. Received ${response.status} with '${response.statusText}'.`);
-    }
-    if (!response.body) {
-        throw new Error(`Response body is null for '${url}'`);
-    }
-    await writeFile(outputPath, response.body);
-};