@aws-sdk/find-v2 0.7.0 → 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

@@ -0,0 +1,43 @@
+import { dirname, join } from "node:path";
+import { AWS_SDK, AWS_SDK_PACKAGE_JSON, PACKAGE_JSON } from "./constants.js";
+const safeParse = (json) => {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        // ToDo: add warning when logging is supported in future.
+        return {};
+    }
+};
+/**
+ * Maps code file paths to their JS SDK v2 versions.
+ *
+ * Searches up the directory tree from each code path to find package.json,
+ * then resolves SDK version from node_modules/aws-sdk or dependencies.
+ *
+ * @param codePaths - Code file paths to map.
+ * @param packageJsonMap - Map of package.json paths to contents.
+ * @param awsSdkPackageJsonMap - Map of aws-sdk package.json paths to contents.
+ * @returns Map of code paths to SDK versions (undefined if not found).
+ */
+export const getCodePathToSdkVersionMap = (codePaths, packageJsonMap = new Map(), awsSdkPackageJsonMap = new Map()) => {
+    const dirToSdkVersionMap = new Map();
+    const getSdkVersion = (dir) => {
+        if (dirToSdkVersionMap.has(dir))
+            return dirToSdkVersionMap.get(dir);
+        let version;
+        // Assign version from node_modules aws-sdk package.json, if available.
+        const awsSdkPackageJson = awsSdkPackageJsonMap.get(join(dir, AWS_SDK_PACKAGE_JSON)) ??
+            awsSdkPackageJsonMap.get(AWS_SDK_PACKAGE_JSON);
+        version ??= awsSdkPackageJson && safeParse(awsSdkPackageJson).version;
+        // Assign version from package.json dependencies, if not populated yet.
+        const pkgJson = packageJsonMap.get(join(dir, PACKAGE_JSON));
+        version ??= pkgJson && safeParse(pkgJson).dependencies?.[AWS_SDK];
+        // Assign undefined if it's rootDir, else call getSdkVersion on parent dir, if not populated yet.
+        const parentDir = dirname(dir);
+        version ??= parentDir !== dir ? getSdkVersion(parentDir) : undefined;
+        dirToSdkVersionMap.set(dir, version);
+        return version;
+    };
+    return new Map(codePaths.map((codePath) => [codePath, getSdkVersion(dirname(codePath))]));
+};

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,77 @@
-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.
- * Returns string contents of package.json files, if available.
- * Otherwise, returns the contents of bundle 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.
+ *
+ * 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 files from node_modules and layers (for version detection)
  *
- * @param zipPath - The path to the zip file of Lambda Function.
- * @returns Promise<LambdaFunctionContents> - Resolves to an object containing the extracted contents.
+ * @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 });
-    const codeMap = {};
-    const packageJsonMap = {};
-    const awsSdkPackageJsonMap = {};
-    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[zipEntry.name] = packageJsonContent.toString();
-            }
+export const getLambdaFunctionContents = async (client, { codeLocation, runtime, layers = [] }) => {
+    const codeMap = new Map();
+    const packageJsonMap = new Map();
+    const awsSdkPackageJsonMap = new Map();
+    // 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);
         }
-        // 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[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.
-            }
-            continue;
-        }
-        // 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[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,
-        ...(Object.keys(packageJsonMap).length > 0 && { packageJsonMap }),
-        ...(Object.keys(awsSdkPackageJsonMap).length > 0 && { awsSdkPackageJsonMap }),
+        ...(packageJsonMap.size > 0 && { packageJsonMap }),
+        ...(awsSdkPackageJsonMap.size > 0 && { awsSdkPackageJsonMap }),
     };
 };

package/dist/utils/getLambdaFunctionScanOutput.js

@@ -1,25 +1,26 @@
 import { satisfies, validate } from "compare-versions";
-import { AWS_SDK, NODE_MODULES, PACKAGE_JSON } from "./constants.js";
-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 { dirname, join } from "node:path";
 /**
  * Scans a Lambda function to detect AWS SDK for JavaScript v2 usage.
  *
- * Downloads the function code, extracts it, and checks for v2 SDK in:
- * 1. package.json dependencies
- * 2. Bundled index file
+ * Downloads the function code, extracts it, and checks for JS SDK v2 signature in handled file if it's a bundle.
+ * If not found, it checks for source code files has require/imports JS SDK v2. It also checks dependencies in
+ * package.json for version validation.
  *
  * @param client - AWS Lambda client instance
  * @param options - Scan configuration options
- * @returns Scan results including SDK v2 detection status and location
+ * @param options.functionName - The name of the Lambda function
+ * @param options.region - AWS region the Lambda function is deployed to
+ * @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,
@@ -27,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";
@@ -44,15 +47,13 @@ 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");
     for (const handlerFile of possibleHandlerFiles) {
-        if (handlerFile in codeMap) {
-            if (hasSdkV2InBundle(codeMap[handlerFile], sdkVersionRange)) {
+        const handlerContent = codeMap.get(handlerFile);
+        if (handlerContent !== undefined) {
+            if (hasSdkV2InBundle(handlerContent, sdkVersionRange)) {
                 output.ContainsAwsSdkJsV2 = true;
                 output.AwsSdkJsV2Locations = [handlerFile];
                 return output;
@@ -61,7 +62,7 @@ export const getLambdaFunctionScanOutput = async (client, { functionName, region
     }
     const filesWithJsSdkV2 = [];
     // Search for JS SDK v2 occurrence in source code
-    for (const [filePath, fileContent] of Object.entries(codeMap)) {
+    for (const [filePath, fileContent] of codeMap) {
         try {
             if (hasSdkV2InFile(filePath, fileContent)) {
                 filesWithJsSdkV2.push(filePath);
@@ -69,6 +70,7 @@ export const getLambdaFunctionScanOutput = async (client, { functionName, region
         }
         catch {
             // Skip files that fail to parse
+            // ToDo: add warning when logging is supported in future.
         }
     }
     // JS SDK v2 not found in source code.
@@ -76,59 +78,26 @@ export const getLambdaFunctionScanOutput = async (client, { functionName, region
         output.ContainsAwsSdkJsV2 = false;
         return output;
     }
-    // Search for JS SDK v2 version from package.json
-    if (packageJsonMap && Object.keys(packageJsonMap).length > 0) {
-        for (const [packageJsonPath, packageJsonContent] of Object.entries(packageJsonMap)) {
+    const codePathToSdkVersionMap = getCodePathToSdkVersionMap(filesWithJsSdkV2, packageJsonMap, awsSdkPackageJsonMap);
+    const jsSdkV2FilesInSdkVersionRange = [];
+    for (const [codePath, version] of codePathToSdkVersionMap) {
+        if (version && validate(version)) {
             try {
-                const packageJson = JSON.parse(packageJsonContent);
-                const dependencies = packageJson.dependencies || {};
-                if (AWS_SDK in dependencies) {
-                    const awsSdkVersionInPackageJson = dependencies[AWS_SDK];
-                    const awsSdkPackageJsonPathInNodeModules = join(NODE_MODULES, AWS_SDK, PACKAGE_JSON);
-                    // Get aws-sdk package.json from nested node_modules or root node_modules.
-                    const awsSdkPackageJson = awsSdkPackageJsonMap
-                        ? (awsSdkPackageJsonMap[join(dirname(packageJsonPath), awsSdkPackageJsonPathInNodeModules)] ?? awsSdkPackageJsonMap[awsSdkPackageJsonPathInNodeModules])
-                        : undefined;
-                    let awsSdkVersionInNodeModules;
-                    try {
-                        if (awsSdkPackageJson) {
-                            awsSdkVersionInNodeModules = JSON.parse(awsSdkPackageJson).version;
-                        }
-                    }
-                    catch {
-                        // Skip if JSON can't be parsed.
-                        // ToDo: add warning when logging is supported in future.
-                    }
-                    const sdkVersionToCheck = validate(awsSdkVersionInPackageJson) || awsSdkPackageJson === undefined
-                        ? // Use version in package.json dependencies, if fixed version is defined or aws-sdk package.json is not available.
-                            awsSdkVersionInPackageJson
-                        : // Use version from aws-sdk package.json, if defined
-                            (awsSdkVersionInNodeModules ?? awsSdkVersionInPackageJson);
-                    try {
-                        if (!satisfies(sdkVersionToCheck, sdkVersionRange)) {
-                            continue;
-                        }
-                    }
-                    catch (error) {
-                        const errorPrefix = `Error checking version range '${sdkVersionRange}' for aws-sdk@${dependencies["aws-sdk"]} in '${packageJsonPath}'`;
-                        output.AwsSdkJsV2Error =
-                            error instanceof Error ? `${errorPrefix}: ${error.message}` : errorPrefix;
-                        return output;
-                    }
-                    output.ContainsAwsSdkJsV2 = true;
-                    output.AwsSdkJsV2Locations = filesWithJsSdkV2;
-                    return output;
+                if (satisfies(version, sdkVersionRange)) {
+                    jsSdkV2FilesInSdkVersionRange.push(codePath);
                 }
             }
-            catch (error) {
-                const errorPrefix = `Error parsing '${packageJsonPath}'`;
-                output.AwsSdkJsV2Error =
-                    error instanceof Error ? `${errorPrefix}: ${error.message}` : errorPrefix;
-                return output;
+            catch {
+                // Ignore if satisfies throws error
+                // ToDo: add warning when logging is supported in future.
             }
         }
     }
-    // JS SDK v2 dependency/code not found.
+    if (jsSdkV2FilesInSdkVersionRange.length > 0) {
+        output.ContainsAwsSdkJsV2 = true;
+        output.AwsSdkJsV2Locations = jsSdkV2FilesInSdkVersionRange;
+        return output;
+    }
     output.ContainsAwsSdkJsV2 = false;
     return output;
 };

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.0",
+  "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);
-};