terraconstructs 0.0.25 → 0.1.1

package/lib/aws/compute/function-nodejs/bundling.d.ts

@@ -0,0 +1,75 @@
+import { IConstruct } from "constructs";
+import { Architecture, AssetCode, Runtime } from "..";
+import { BundlingOptions } from "./types";
+import { BundlingFileAccess, BundlingOptions as CoreBundlingOptions, DockerImage, DockerVolume, ILocalBundling } from "../../../bundling";
+/**
+ * Bundling properties
+ */
+export interface BundlingProps extends BundlingOptions {
+    /**
+     * Path to lock file
+     */
+    readonly depsLockFilePath: string;
+    /**
+     * Entry file
+     */
+    readonly entry: string;
+    /**
+     * The runtime of the lambda function
+     */
+    readonly runtime: Runtime;
+    /**
+     * The system architecture of the lambda function
+     */
+    readonly architecture: Architecture;
+    /**
+     * Path to project root
+     */
+    readonly projectRoot: string;
+    /**
+     * Run compilation using `tsc` before bundling
+     */
+    readonly preCompilation?: boolean;
+    /**
+     * Which option to use to copy the source files to the docker container and output files back
+     * @default - BundlingFileAccess.BIND_MOUNT
+     */
+    readonly bundlingFileAccess?: BundlingFileAccess;
+}
+/**
+ * Bundling with esbuild
+ */
+export declare class Bundling implements CoreBundlingOptions {
+    private readonly props;
+    /**
+     * esbuild bundled Lambda asset code
+     */
+    static bundle(scope: IConstruct, options: BundlingProps): AssetCode;
+    static clearEsbuildInstallationCache(): void;
+    static clearTscInstallationCache(): void;
+    private static esbuildInstallation?;
+    private static tscInstallation?;
+    readonly image: DockerImage;
+    readonly entrypoint?: string[];
+    readonly command: string[];
+    readonly volumes?: DockerVolume[];
+    readonly volumesFrom?: string[];
+    readonly environment?: {
+        [key: string]: string;
+    };
+    readonly workingDirectory: string;
+    readonly user?: string;
+    readonly securityOpt?: string;
+    readonly network?: string;
+    readonly local?: ILocalBundling;
+    readonly bundlingFileAccess?: BundlingFileAccess;
+    private readonly projectRoot;
+    private readonly relativeEntryPath;
+    private readonly relativeTsconfigPath?;
+    private readonly relativeDepsLockFilePath;
+    private readonly externals;
+    private readonly packageManager;
+    constructor(scope: IConstruct, props: BundlingProps);
+    private createBundlingCommand;
+    private getLocalBundlingProvider;
+}

package/lib/aws/compute/function-nodejs/bundling.js

@@ -0,0 +1,405 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-lambda-nodejs/lib/bundling.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundling = void 0;
+const os = require("os");
+const path = require("path");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const package_installation_1 = require("./package-installation");
+const package_manager_1 = require("./package-manager");
+const types_1 = require("./types");
+const util_1 = require("./util");
+const asset_staging_1 = require("../../../asset-staging");
+const assets_1 = require("../../../assets");
+const bundling_1 = require("../../../bundling");
+const ESBUILD_MAJOR_VERSION = "0";
+const ESBUILD_DEFAULT_VERSION = "0.21";
+/**
+ * Bundling with esbuild
+ */
+class Bundling {
+    /**
+     * esbuild bundled Lambda asset code
+     */
+    static bundle(scope, options) {
+        return __1.Code.fromAsset(options.projectRoot, {
+            assetHash: options.assetHash,
+            assetHashType: options.assetHash
+                ? assets_1.AssetHashType.CUSTOM
+                : assets_1.AssetHashType.OUTPUT,
+            bundling: new Bundling(scope, options),
+        });
+    }
+    static clearEsbuildInstallationCache() {
+        this.esbuildInstallation = undefined;
+    }
+    static clearTscInstallationCache() {
+        this.tscInstallation = undefined;
+    }
+    constructor(scope, props) {
+        this.props = props;
+        this.packageManager = package_manager_1.PackageManager.fromLockFile(props.depsLockFilePath, props.logLevel);
+        Bundling.esbuildInstallation =
+            Bundling.esbuildInstallation ?? package_installation_1.PackageInstallation.detect("esbuild");
+        Bundling.tscInstallation =
+            Bundling.tscInstallation ?? package_installation_1.PackageInstallation.detect("typescript");
+        this.projectRoot = props.projectRoot;
+        this.relativeEntryPath = path.relative(this.projectRoot, path.resolve(props.entry));
+        this.relativeDepsLockFilePath = path.relative(this.projectRoot, path.resolve(props.depsLockFilePath));
+        if (this.relativeDepsLockFilePath.includes("..")) {
+            throw new Error(`Expected depsLockFilePath: ${props.depsLockFilePath} to be under projectRoot: ${this.projectRoot} (${this.relativeDepsLockFilePath})`);
+        }
+        if (props.tsconfig) {
+            this.relativeTsconfigPath = path.relative(this.projectRoot, path.resolve(props.tsconfig));
+        }
+        if (props.preCompilation && !/\.tsx?$/.test(props.entry)) {
+            throw new Error("preCompilation can only be used with typescript files");
+        }
+        if (props.format === types_1.OutputFormat.ESM && !isEsmRuntime(props.runtime)) {
+            throw new Error(`ECMAScript module output format is not supported by the ${props.runtime.name} runtime`);
+        }
+        /**
+         * For Lambda runtime that uses AWS SDK v3, we need to remove both `aws-sdk/*` modules
+         * and `smithy/*` modules to prevent version mismatches.
+         *
+         * Issue reference: https://github.com/aws/aws-cdk/issues/31610#issuecomment-2389983347
+         */
+        const sdkV3Externals = ["@aws-sdk/*", "@smithy/*"];
+        // Modules to externalize when using a constant known version of the runtime.
+        // Mark aws-sdk as external by default (available in the runtime)
+        const isV2Runtime = (0, util_1.isSdkV2Runtime)(props.runtime);
+        const versionedExternals = isV2Runtime ? ["aws-sdk"] : sdkV3Externals;
+        // Don't automatically externalize any dependencies when using a `latest` runtime which may
+        // update versions in the future.
+        // Don't automatically externalize aws sdk if `bundleAwsSDK` is true so it can be
+        // include in the bundle asset
+        const defaultExternals = props.runtime?.isVariable || props.bundleAwsSDK ? [] : versionedExternals;
+        const externals = props.externalModules ?? defaultExternals;
+        // warn users if they are using a runtime that does not support sdk v2
+        // and the sdk is not explicitly bundled
+        if (externals.length && isV2Runtime) {
+            // "aws-cdk-lib/aws-lambda-nodejs:runtimeUpdateSdkV2Breakage",
+            cdktf_1.Annotations.of(scope).addWarning("Be aware that the NodeJS runtime of Node 16 will be deprecated by Lambda on June 12, 2024. Lambda runtimes Node 18 and higher include SDKv3 and not SDKv2. Updating your Lambda runtime will require bundling the SDK, or updating all SDK calls in your handler code to use SDKv3 (which is not a trivial update). Please account for this added complexity and update as soon as possible.");
+        }
+        // Warn users if they are trying to rely on global versions of the SDK that aren't available in
+        // their environment.
+        if (isV2Runtime &&
+            externals.some((pkgName) => pkgName.startsWith("@aws-sdk/"))) {
+            // "@aws-cdk/aws-lambda-nodejs:sdkV3NotInRuntime",
+            cdktf_1.Annotations.of(scope).addWarning("If you are relying on AWS SDK v3 to be present in the Lambda environment already, please explicitly configure a NodeJS runtime of Node 18 or higher.");
+        }
+        else if (!isV2Runtime && externals.includes("aws-sdk")) {
+            // "@aws-cdk/aws-lambda-nodejs:sdkV2NotInRuntime",
+            cdktf_1.Annotations.of(scope).addWarning("If you are relying on AWS SDK v2 to be present in the Lambda environment already, please explicitly configure a NodeJS runtime of Node 16 or lower.");
+        }
+        // Warn users if they are using a runtime that may change and are excluding any dependencies from
+        // bundling.
+        if (externals.length && props.runtime?.isVariable) {
+            // "@aws-cdk/aws-lambda-nodejs:variableRuntimeExternals",
+            cdktf_1.Annotations.of(scope).addWarning("When using NODEJS_LATEST the runtime version may change as new runtimes are released, this may affect the availability of packages shipped with the environment. Ensure that any external dependencies are available through layers or specify a specific runtime version.");
+        }
+        this.externals = [
+            ...externals,
+            ...(props.nodeModules ?? []), // Mark the modules that we are going to install as externals also
+        ];
+        // Docker bundling
+        const shouldBuildImage = props.forceDockerBundling || !Bundling.esbuildInstallation;
+        this.image = shouldBuildImage
+            ? (props.dockerImage ??
+                bundling_1.DockerImage.fromBuild(path.join(__dirname), {
+                    buildArgs: {
+                        ...(props.buildArgs ?? {}),
+                        // If runtime isn't passed use regional default, lowest common denominator is node18
+                        IMAGE: props.runtime.bundlingImage.image,
+                        ESBUILD_VERSION: props.esbuildVersion ?? ESBUILD_DEFAULT_VERSION,
+                    },
+                    platform: props.architecture.dockerPlatform,
+                }))
+            : bundling_1.DockerImage.fromRegistry("dummy"); // Do not build if we don't need to
+        const bundlingCommand = this.createBundlingCommand({
+            inputDir: asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR,
+            outputDir: asset_staging_1.AssetStaging.BUNDLING_OUTPUT_DIR,
+            esbuildRunner: "esbuild", // esbuild is installed globally in the docker image
+            tscRunner: "tsc", // tsc is installed globally in the docker image
+            osPlatform: "linux", // linux docker image
+        });
+        this.command = props.command ?? ["bash", "-c", bundlingCommand];
+        this.environment = props.environment;
+        // Bundling sets the working directory to AssetStaging.BUNDLING_INPUT_DIR
+        // and we want to force npx to use the globally installed esbuild.
+        this.workingDirectory = props.workingDirectory ?? "/";
+        this.entrypoint = props.entrypoint;
+        this.volumes = props.volumes;
+        this.volumesFrom = props.volumesFrom;
+        this.user = props.user;
+        this.securityOpt = props.securityOpt;
+        this.network = props.network;
+        this.bundlingFileAccess = props.bundlingFileAccess;
+        // Local bundling
+        if (!props.forceDockerBundling) {
+            // only if Docker is not forced
+            this.local = this.getLocalBundlingProvider();
+        }
+    }
+    createBundlingCommand(options) {
+        const pathJoin = osPathJoin(options.osPlatform);
+        let relativeEntryPath = pathJoin(options.inputDir, this.relativeEntryPath);
+        let tscCommand = "";
+        if (this.props.preCompilation) {
+            const tsconfig = this.props.tsconfig ??
+                (0, util_1.findUp)("tsconfig.json", path.dirname(this.props.entry));
+            if (!tsconfig) {
+                throw new Error("Cannot find a `tsconfig.json` but `preCompilation` is set to `true`, please specify it via `tsconfig`");
+            }
+            const compilerOptions = (0, util_1.getTsconfigCompilerOptions)(tsconfig);
+            tscCommand = `${options.tscRunner} "${relativeEntryPath}" ${compilerOptions}`;
+            relativeEntryPath = relativeEntryPath.replace(/\.ts(x?)$/, ".js$1");
+        }
+        const loaders = Object.entries(this.props.loader ?? {});
+        const defines = Object.entries(this.props.define ?? {});
+        if (this.props.sourceMap === false && this.props.sourceMapMode) {
+            throw new Error("sourceMapMode cannot be used when sourceMap is false");
+        }
+        const sourceMapEnabled = this.props.sourceMapMode ?? this.props.sourceMap;
+        const sourceMapMode = this.props.sourceMapMode ?? types_1.SourceMapMode.DEFAULT;
+        const sourceMapValue = sourceMapMode === types_1.SourceMapMode.DEFAULT
+            ? ""
+            : `=${this.props.sourceMapMode}`;
+        const sourcesContent = this.props.sourcesContent ?? true;
+        const outFile = this.props.format === types_1.OutputFormat.ESM ? "index.mjs" : "index.js";
+        const esbuildCommand = [
+            options.esbuildRunner,
+            "--bundle",
+            `"${relativeEntryPath}"`,
+            `--target=${this.props.target ?? toTarget(this.props.runtime)}`,
+            "--platform=node",
+            ...(this.props.format ? [`--format=${this.props.format}`] : []),
+            `--outfile="${pathJoin(options.outputDir, outFile)}"`,
+            ...(this.props.minify ? ["--minify"] : []),
+            ...(sourceMapEnabled ? [`--sourcemap${sourceMapValue}`] : []),
+            ...(sourcesContent ? [] : [`--sources-content=${sourcesContent}`]),
+            ...this.externals.map((external) => `--external:${external}`),
+            ...loaders.map(([ext, name]) => `--loader:${ext}=${name}`),
+            ...defines.map(([key, value]) => `--define:${key}=${JSON.stringify(value)}`),
+            ...(this.props.logLevel ? [`--log-level=${this.props.logLevel}`] : []),
+            ...(this.props.keepNames ? ["--keep-names"] : []),
+            ...(this.relativeTsconfigPath
+                ? [
+                    `--tsconfig="${pathJoin(options.inputDir, this.relativeTsconfigPath)}"`,
+                ]
+                : []),
+            ...(this.props.metafile
+                ? [`--metafile="${pathJoin(options.outputDir, "index.meta.json")}"`]
+                : []),
+            ...(this.props.banner
+                ? [`--banner:js=${JSON.stringify(this.props.banner)}`]
+                : []),
+            ...(this.props.footer
+                ? [`--footer:js=${JSON.stringify(this.props.footer)}`]
+                : []),
+            ...(this.props.mainFields
+                ? [`--main-fields=${this.props.mainFields.join(",")}`]
+                : []),
+            ...(this.props.inject
+                ? this.props.inject.map((i) => `--inject:"${i}"`)
+                : []),
+            ...(this.props.esbuildArgs ? [toCliArgs(this.props.esbuildArgs)] : []),
+        ];
+        let depsCommand = "";
+        if (this.props.nodeModules) {
+            // Find 'package.json' closest to entry folder, we are going to extract the
+            // modules versions from it.
+            const pkgPath = (0, util_1.findUp)("package.json", path.dirname(this.props.entry));
+            if (!pkgPath) {
+                throw new Error("Cannot find a `package.json` in this project. Using `nodeModules` requires a `package.json`.");
+            }
+            // Determine dependencies versions, lock file and installer
+            const dependencies = (0, util_1.extractDependencies)(pkgPath, this.props.nodeModules);
+            const osCommand = new OsCommand(options.osPlatform);
+            const lockFilePath = pathJoin(options.inputDir, this.relativeDepsLockFilePath ?? this.packageManager.lockFile);
+            const isPnpm = this.packageManager.lockFile === package_manager_1.LockFile.PNPM;
+            const isBun = this.packageManager.lockFile === package_manager_1.LockFile.BUN;
+            // Create dummy package.json, copy lock file if any and then install
+            depsCommand = chain([
+                isPnpm
+                    ? osCommand.write(pathJoin(options.outputDir, "pnpm-workspace.yaml"), "")
+                    : "", // Ensure node_modules directory is installed locally by creating local 'pnpm-workspace.yaml' file
+                osCommand.writeJson(pathJoin(options.outputDir, "package.json"), {
+                    dependencies,
+                }),
+                osCommand.copy(lockFilePath, pathJoin(options.outputDir, this.packageManager.lockFile)),
+                osCommand.changeDirectory(options.outputDir),
+                this.packageManager.installCommand.join(" "),
+                isPnpm
+                    ? osCommand.remove(pathJoin(options.outputDir, "node_modules", ".modules.yaml"), true)
+                    : "", // Remove '.modules.yaml' file which changes on each deployment
+                isBun
+                    ? osCommand.removeDir(pathJoin(options.outputDir, "node_modules", ".cache"))
+                    : "", // Remove node_modules/.cache folder since you can't disable its creation
+            ]);
+        }
+        return chain([
+            ...(this.props.commandHooks?.beforeBundling(options.inputDir, options.outputDir) ?? []),
+            tscCommand,
+            esbuildCommand.join(" "),
+            ...((this.props.nodeModules &&
+                this.props.commandHooks?.beforeInstall(options.inputDir, options.outputDir)) ??
+                []),
+            depsCommand,
+            ...(this.props.commandHooks?.afterBundling(options.inputDir, options.outputDir) ?? []),
+        ]);
+    }
+    getLocalBundlingProvider() {
+        const osPlatform = os.platform();
+        const createLocalCommand = (outputDir, esbuild, tsc) => this.createBundlingCommand({
+            inputDir: this.projectRoot,
+            outputDir,
+            esbuildRunner: esbuild.isLocal
+                ? this.packageManager.runBinCommand("esbuild")
+                : "esbuild",
+            tscRunner: tsc &&
+                (tsc.isLocal ? this.packageManager.runBinCommand("tsc") : "tsc"),
+            osPlatform,
+        });
+        const environment = this.props.environment ?? {};
+        const cwd = this.projectRoot;
+        return {
+            tryBundle(outputDir) {
+                if (!Bundling.esbuildInstallation) {
+                    process.stderr.write("esbuild cannot run locally. Switching to Docker bundling.\n");
+                    return false;
+                }
+                if (!Bundling.esbuildInstallation.version.startsWith(`${ESBUILD_MAJOR_VERSION}.`)) {
+                    throw new Error(`Expected esbuild version ${ESBUILD_MAJOR_VERSION}.x but got ${Bundling.esbuildInstallation.version}`);
+                }
+                const localCommand = createLocalCommand(outputDir, Bundling.esbuildInstallation, Bundling.tscInstallation);
+                (0, util_1.exec)(osPlatform === "win32" ? "cmd" : "bash", [osPlatform === "win32" ? "/c" : "-c", localCommand], {
+                    env: { ...process.env, ...environment },
+                    stdio: [
+                        // show output
+                        "ignore", // ignore stdio
+                        process.stderr, // redirect stdout to stderr
+                        "inherit", // inherit stderr
+                    ],
+                    cwd,
+                    windowsVerbatimArguments: osPlatform === "win32",
+                });
+                return true;
+            },
+        };
+    }
+}
+exports.Bundling = Bundling;
+/**
+ * OS agnostic command
+ */
+class OsCommand {
+    constructor(osPlatform) {
+        this.osPlatform = osPlatform;
+    }
+    write(filePath, data) {
+        if (this.osPlatform === "win32") {
+            if (!data) {
+                // if `data` is empty, echo a blank line, otherwise the file will contain a `^` character
+                return `echo. > "${filePath}"`;
+            }
+            return `echo ^${data}^ > "${filePath}"`;
+        }
+        return `echo '${data}' > "${filePath}"`;
+    }
+    writeJson(filePath, data) {
+        const stringifiedData = JSON.stringify(data);
+        return this.write(filePath, stringifiedData);
+    }
+    copy(src, dest) {
+        if (this.osPlatform === "win32") {
+            return `copy "${src}" "${dest}"`;
+        }
+        return `cp "${src}" "${dest}"`;
+    }
+    changeDirectory(dir) {
+        return `cd "${dir}"`;
+    }
+    remove(filePath, force = false) {
+        if (this.osPlatform === "win32") {
+            return `del "${filePath}"`;
+        }
+        const opts = force ? ["-f"] : [];
+        return `rm ${opts.join(" ")} "${filePath}"`;
+    }
+    removeDir(dir) {
+        if (this.osPlatform === "win32") {
+            return `rmdir /s /q "${dir}"`;
+        }
+        return `rm -rf "${dir}"`;
+    }
+}
+/**
+ * Chain commands
+ */
+function chain(commands) {
+    return commands.filter((c) => !!c).join(" && ");
+}
+/**
+ * Platform specific path join
+ */
+function osPathJoin(platform) {
+    return function (...paths) {
+        const joined = path.join(...paths);
+        // If we are on win32 but need posix style paths
+        if (os.platform() === "win32" && platform !== "win32") {
+            return joined.replace(/\\/g, "/");
+        }
+        return joined;
+    };
+}
+/**
+ * Converts a runtime to an esbuild node target
+ */
+function toTarget(runtime) {
+    const match = runtime.name.match(/nodejs(\d+)/);
+    if (!match) {
+        throw new Error("Cannot extract version from runtime.");
+    }
+    return `node${match[1]}`;
+}
+function toCliArgs(esbuildArgs) {
+    const args = new Array();
+    const reSpecifiedKeys = [
+        "--alias",
+        "--drop",
+        "--pure",
+        "--log-override",
+        "--out-extension",
+    ];
+    for (const [key, value] of Object.entries(esbuildArgs)) {
+        if (value === true || value === "") {
+            args.push(key);
+        }
+        else if (reSpecifiedKeys.includes(key)) {
+            args.push(`${key}:"${value}"`);
+        }
+        else if (value) {
+            args.push(`${key}="${value}"`);
+        }
+    }
+    return args.join(" ");
+}
+/**
+ * Detect if a given Node.js runtime supports ESM (ECMAScript modules)
+ */
+function isEsmRuntime(runtime) {
+    const unsupportedRuntimes = [
+        __1.Runtime.NODEJS,
+        __1.Runtime.NODEJS_4_3,
+        __1.Runtime.NODEJS_6_10,
+        __1.Runtime.NODEJS_8_10,
+        __1.Runtime.NODEJS_10_X,
+        __1.Runtime.NODEJS_12_X,
+    ];
+    return !unsupportedRuntimes.some((r) => {
+        return r.family === runtime.family && r.name === runtime.name;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundling.js","sourceRoot":"","sources":["../../../../src/aws/compute/function-nodejs/bundling.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-lambda-nodejs/lib/bundling.ts\n\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport { Annotations } from \"cdktf\";\nimport { IConstruct } from \"constructs\";\nimport { Architecture, AssetCode, Code, Runtime } from \"..\";\nimport { PackageInstallation } from \"./package-installation\";\nimport { LockFile, PackageManager } from \"./package-manager\";\nimport { BundlingOptions, OutputFormat, SourceMapMode } from \"./types\";\nimport {\n  exec,\n  extractDependencies,\n  findUp,\n  getTsconfigCompilerOptions,\n  isSdkV2Runtime,\n} from \"./util\";\nimport { AssetStaging } from \"../../../asset-staging\";\nimport { AssetHashType } from \"../../../assets\";\nimport {\n  BundlingFileAccess,\n  BundlingOptions as CoreBundlingOptions,\n  DockerImage,\n  DockerVolume,\n  ILocalBundling,\n} from \"../../../bundling\";\n\nconst ESBUILD_MAJOR_VERSION = \"0\";\nconst ESBUILD_DEFAULT_VERSION = \"0.21\";\n\n/**\n * Bundling properties\n */\nexport interface BundlingProps extends BundlingOptions {\n  /**\n   * Path to lock file\n   */\n  readonly depsLockFilePath: string;\n\n  /**\n   * Entry file\n   */\n  readonly entry: string;\n\n  /**\n   * The runtime of the lambda function\n   */\n  readonly runtime: Runtime;\n\n  /**\n   * The system architecture of the lambda function\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Path to project root\n   */\n  readonly projectRoot: string;\n\n  /**\n   * Run compilation using `tsc` before bundling\n   */\n  readonly preCompilation?: boolean;\n\n  /**\n   * Which option to use to copy the source files to the docker container and output files back\n   * @default - BundlingFileAccess.BIND_MOUNT\n   */\n  readonly bundlingFileAccess?: BundlingFileAccess;\n}\n\n/**\n * Bundling with esbuild\n */\nexport class Bundling implements CoreBundlingOptions {\n  /**\n   * esbuild bundled Lambda asset code\n   */\n  public static bundle(scope: IConstruct, options: BundlingProps): AssetCode {\n    return Code.fromAsset(options.projectRoot, {\n      assetHash: options.assetHash,\n      assetHashType: options.assetHash\n        ? AssetHashType.CUSTOM\n        : AssetHashType.OUTPUT,\n      bundling: new Bundling(scope, options),\n    });\n  }\n\n  public static clearEsbuildInstallationCache(): void {\n    this.esbuildInstallation = undefined;\n  }\n\n  public static clearTscInstallationCache(): void {\n    this.tscInstallation = undefined;\n  }\n\n  private static esbuildInstallation?: PackageInstallation;\n  private static tscInstallation?: PackageInstallation;\n\n  // Core bundling options\n  public readonly image: DockerImage;\n  public readonly entrypoint?: string[];\n  public readonly command: string[];\n  public readonly volumes?: DockerVolume[];\n  public readonly volumesFrom?: string[];\n  public readonly environment?: { [key: string]: string };\n  public readonly workingDirectory: string;\n  public readonly user?: string;\n  public readonly securityOpt?: string;\n  public readonly network?: string;\n  public readonly local?: ILocalBundling;\n  public readonly bundlingFileAccess?: BundlingFileAccess;\n\n  private readonly projectRoot: string;\n  private readonly relativeEntryPath: string;\n  private readonly relativeTsconfigPath?: string;\n  private readonly relativeDepsLockFilePath: string;\n  private readonly externals: string[];\n  private readonly packageManager: PackageManager;\n\n  constructor(\n    scope: IConstruct,\n    private readonly props: BundlingProps,\n  ) {\n    this.packageManager = PackageManager.fromLockFile(\n      props.depsLockFilePath,\n      props.logLevel,\n    );\n\n    Bundling.esbuildInstallation =\n      Bundling.esbuildInstallation ?? PackageInstallation.detect(\"esbuild\");\n    Bundling.tscInstallation =\n      Bundling.tscInstallation ?? PackageInstallation.detect(\"typescript\");\n\n    this.projectRoot = props.projectRoot;\n    this.relativeEntryPath = path.relative(\n      this.projectRoot,\n      path.resolve(props.entry),\n    );\n    this.relativeDepsLockFilePath = path.relative(\n      this.projectRoot,\n      path.resolve(props.depsLockFilePath),\n    );\n\n    if (this.relativeDepsLockFilePath.includes(\"..\")) {\n      throw new Error(\n        `Expected depsLockFilePath: ${props.depsLockFilePath} to be under projectRoot: ${this.projectRoot} (${this.relativeDepsLockFilePath})`,\n      );\n    }\n\n    if (props.tsconfig) {\n      this.relativeTsconfigPath = path.relative(\n        this.projectRoot,\n        path.resolve(props.tsconfig),\n      );\n    }\n\n    if (props.preCompilation && !/\\.tsx?$/.test(props.entry)) {\n      throw new Error(\"preCompilation can only be used with typescript files\");\n    }\n\n    if (props.format === OutputFormat.ESM && !isEsmRuntime(props.runtime)) {\n      throw new Error(\n        `ECMAScript module output format is not supported by the ${props.runtime.name} runtime`,\n      );\n    }\n\n    /**\n     * For Lambda runtime that uses AWS SDK v3, we need to remove both `aws-sdk/*` modules\n     * and `smithy/*` modules to prevent version mismatches.\n     *\n     * Issue reference: https://github.com/aws/aws-cdk/issues/31610#issuecomment-2389983347\n     */\n    const sdkV3Externals = [\"@aws-sdk/*\", \"@smithy/*\"];\n    // Modules to externalize when using a constant known version of the runtime.\n    // Mark aws-sdk as external by default (available in the runtime)\n    const isV2Runtime = isSdkV2Runtime(props.runtime);\n    const versionedExternals = isV2Runtime ? [\"aws-sdk\"] : sdkV3Externals;\n    // Don't automatically externalize any dependencies when using a `latest` runtime which may\n    // update versions in the future.\n    // Don't automatically externalize aws sdk if `bundleAwsSDK` is true so it can be\n    // include in the bundle asset\n    const defaultExternals =\n      props.runtime?.isVariable || props.bundleAwsSDK ? [] : versionedExternals;\n\n    const externals = props.externalModules ?? defaultExternals;\n\n    // warn users if they are using a runtime that does not support sdk v2\n    // and the sdk is not explicitly bundled\n    if (externals.length && isV2Runtime) {\n      // \"aws-cdk-lib/aws-lambda-nodejs:runtimeUpdateSdkV2Breakage\",\n      Annotations.of(scope).addWarning(\n        \"Be aware that the NodeJS runtime of Node 16 will be deprecated by Lambda on June 12, 2024. Lambda runtimes Node 18 and higher include SDKv3 and not SDKv2. Updating your Lambda runtime will require bundling the SDK, or updating all SDK calls in your handler code to use SDKv3 (which is not a trivial update). Please account for this added complexity and update as soon as possible.\",\n      );\n    }\n\n    // Warn users if they are trying to rely on global versions of the SDK that aren't available in\n    // their environment.\n    if (\n      isV2Runtime &&\n      externals.some((pkgName) => pkgName.startsWith(\"@aws-sdk/\"))\n    ) {\n      // \"@aws-cdk/aws-lambda-nodejs:sdkV3NotInRuntime\",\n      Annotations.of(scope).addWarning(\n        \"If you are relying on AWS SDK v3 to be present in the Lambda environment already, please explicitly configure a NodeJS runtime of Node 18 or higher.\",\n      );\n    } else if (!isV2Runtime && externals.includes(\"aws-sdk\")) {\n      // \"@aws-cdk/aws-lambda-nodejs:sdkV2NotInRuntime\",\n      Annotations.of(scope).addWarning(\n        \"If you are relying on AWS SDK v2 to be present in the Lambda environment already, please explicitly configure a NodeJS runtime of Node 16 or lower.\",\n      );\n    }\n\n    // Warn users if they are using a runtime that may change and are excluding any dependencies from\n    // bundling.\n    if (externals.length && props.runtime?.isVariable) {\n      // \"@aws-cdk/aws-lambda-nodejs:variableRuntimeExternals\",\n      Annotations.of(scope).addWarning(\n        \"When using NODEJS_LATEST the runtime version may change as new runtimes are released, this may affect the availability of packages shipped with the environment. Ensure that any external dependencies are available through layers or specify a specific runtime version.\",\n      );\n    }\n\n    this.externals = [\n      ...externals,\n      ...(props.nodeModules ?? []), // Mark the modules that we are going to install as externals also\n    ];\n\n    // Docker bundling\n    const shouldBuildImage =\n      props.forceDockerBundling || !Bundling.esbuildInstallation;\n    this.image = shouldBuildImage\n      ? (props.dockerImage ??\n        DockerImage.fromBuild(path.join(__dirname), {\n          buildArgs: {\n            ...(props.buildArgs ?? {}),\n            // If runtime isn't passed use regional default, lowest common denominator is node18\n            IMAGE: props.runtime.bundlingImage.image,\n            ESBUILD_VERSION: props.esbuildVersion ?? ESBUILD_DEFAULT_VERSION,\n          },\n          platform: props.architecture.dockerPlatform,\n        }))\n      : DockerImage.fromRegistry(\"dummy\"); // Do not build if we don't need to\n\n    const bundlingCommand = this.createBundlingCommand({\n      inputDir: AssetStaging.BUNDLING_INPUT_DIR,\n      outputDir: AssetStaging.BUNDLING_OUTPUT_DIR,\n      esbuildRunner: \"esbuild\", // esbuild is installed globally in the docker image\n      tscRunner: \"tsc\", // tsc is installed globally in the docker image\n      osPlatform: \"linux\", // linux docker image\n    });\n    this.command = props.command ?? [\"bash\", \"-c\", bundlingCommand];\n    this.environment = props.environment;\n    // Bundling sets the working directory to AssetStaging.BUNDLING_INPUT_DIR\n    // and we want to force npx to use the globally installed esbuild.\n    this.workingDirectory = props.workingDirectory ?? \"/\";\n    this.entrypoint = props.entrypoint;\n    this.volumes = props.volumes;\n    this.volumesFrom = props.volumesFrom;\n    this.user = props.user;\n    this.securityOpt = props.securityOpt;\n    this.network = props.network;\n    this.bundlingFileAccess = props.bundlingFileAccess;\n\n    // Local bundling\n    if (!props.forceDockerBundling) {\n      // only if Docker is not forced\n      this.local = this.getLocalBundlingProvider();\n    }\n  }\n\n  private createBundlingCommand(options: BundlingCommandOptions): string {\n    const pathJoin = osPathJoin(options.osPlatform);\n    let relativeEntryPath = pathJoin(options.inputDir, this.relativeEntryPath);\n    let tscCommand = \"\";\n\n    if (this.props.preCompilation) {\n      const tsconfig =\n        this.props.tsconfig ??\n        findUp(\"tsconfig.json\", path.dirname(this.props.entry));\n      if (!tsconfig) {\n        throw new Error(\n          \"Cannot find a `tsconfig.json` but `preCompilation` is set to `true`, please specify it via `tsconfig`\",\n        );\n      }\n      const compilerOptions = getTsconfigCompilerOptions(tsconfig);\n      tscCommand = `${options.tscRunner} \"${relativeEntryPath}\" ${compilerOptions}`;\n      relativeEntryPath = relativeEntryPath.replace(/\\.ts(x?)$/, \".js$1\");\n    }\n\n    const loaders = Object.entries(this.props.loader ?? {});\n    const defines = Object.entries(this.props.define ?? {});\n\n    if (this.props.sourceMap === false && this.props.sourceMapMode) {\n      throw new Error(\"sourceMapMode cannot be used when sourceMap is false\");\n    }\n\n    const sourceMapEnabled = this.props.sourceMapMode ?? this.props.sourceMap;\n    const sourceMapMode = this.props.sourceMapMode ?? SourceMapMode.DEFAULT;\n    const sourceMapValue =\n      sourceMapMode === SourceMapMode.DEFAULT\n        ? \"\"\n        : `=${this.props.sourceMapMode}`;\n    const sourcesContent = this.props.sourcesContent ?? true;\n\n    const outFile =\n      this.props.format === OutputFormat.ESM ? \"index.mjs\" : \"index.js\";\n    const esbuildCommand: string[] = [\n      options.esbuildRunner,\n      \"--bundle\",\n      `\"${relativeEntryPath}\"`,\n      `--target=${this.props.target ?? toTarget(this.props.runtime)}`,\n      \"--platform=node\",\n      ...(this.props.format ? [`--format=${this.props.format}`] : []),\n      `--outfile=\"${pathJoin(options.outputDir, outFile)}\"`,\n      ...(this.props.minify ? [\"--minify\"] : []),\n      ...(sourceMapEnabled ? [`--sourcemap${sourceMapValue}`] : []),\n      ...(sourcesContent ? [] : [`--sources-content=${sourcesContent}`]),\n      ...this.externals.map((external) => `--external:${external}`),\n      ...loaders.map(([ext, name]) => `--loader:${ext}=${name}`),\n      ...defines.map(\n        ([key, value]) => `--define:${key}=${JSON.stringify(value)}`,\n      ),\n      ...(this.props.logLevel ? [`--log-level=${this.props.logLevel}`] : []),\n      ...(this.props.keepNames ? [\"--keep-names\"] : []),\n      ...(this.relativeTsconfigPath\n        ? [\n            `--tsconfig=\"${pathJoin(options.inputDir, this.relativeTsconfigPath)}\"`,\n          ]\n        : []),\n      ...(this.props.metafile\n        ? [`--metafile=\"${pathJoin(options.outputDir, \"index.meta.json\")}\"`]\n        : []),\n      ...(this.props.banner\n        ? [`--banner:js=${JSON.stringify(this.props.banner)}`]\n        : []),\n      ...(this.props.footer\n        ? [`--footer:js=${JSON.stringify(this.props.footer)}`]\n        : []),\n      ...(this.props.mainFields\n        ? [`--main-fields=${this.props.mainFields.join(\",\")}`]\n        : []),\n      ...(this.props.inject\n        ? this.props.inject.map((i) => `--inject:\"${i}\"`)\n        : []),\n      ...(this.props.esbuildArgs ? [toCliArgs(this.props.esbuildArgs)] : []),\n    ];\n\n    let depsCommand = \"\";\n    if (this.props.nodeModules) {\n      // Find 'package.json' closest to entry folder, we are going to extract the\n      // modules versions from it.\n      const pkgPath = findUp(\"package.json\", path.dirname(this.props.entry));\n      if (!pkgPath) {\n        throw new Error(\n          \"Cannot find a `package.json` in this project. Using `nodeModules` requires a `package.json`.\",\n        );\n      }\n\n      // Determine dependencies versions, lock file and installer\n      const dependencies = extractDependencies(pkgPath, this.props.nodeModules);\n      const osCommand = new OsCommand(options.osPlatform);\n\n      const lockFilePath = pathJoin(\n        options.inputDir,\n        this.relativeDepsLockFilePath ?? this.packageManager.lockFile,\n      );\n\n      const isPnpm = this.packageManager.lockFile === LockFile.PNPM;\n      const isBun = this.packageManager.lockFile === LockFile.BUN;\n\n      // Create dummy package.json, copy lock file if any and then install\n      depsCommand = chain([\n        isPnpm\n          ? osCommand.write(\n              pathJoin(options.outputDir, \"pnpm-workspace.yaml\"),\n              \"\",\n            )\n          : \"\", // Ensure node_modules directory is installed locally by creating local 'pnpm-workspace.yaml' file\n        osCommand.writeJson(pathJoin(options.outputDir, \"package.json\"), {\n          dependencies,\n        }),\n        osCommand.copy(\n          lockFilePath,\n          pathJoin(options.outputDir, this.packageManager.lockFile),\n        ),\n        osCommand.changeDirectory(options.outputDir),\n        this.packageManager.installCommand.join(\" \"),\n        isPnpm\n          ? osCommand.remove(\n              pathJoin(options.outputDir, \"node_modules\", \".modules.yaml\"),\n              true,\n            )\n          : \"\", // Remove '.modules.yaml' file which changes on each deployment\n        isBun\n          ? osCommand.removeDir(\n              pathJoin(options.outputDir, \"node_modules\", \".cache\"),\n            )\n          : \"\", // Remove node_modules/.cache folder since you can't disable its creation\n      ]);\n    }\n\n    return chain([\n      ...(this.props.commandHooks?.beforeBundling(\n        options.inputDir,\n        options.outputDir,\n      ) ?? []),\n      tscCommand,\n      esbuildCommand.join(\" \"),\n      ...((this.props.nodeModules &&\n        this.props.commandHooks?.beforeInstall(\n          options.inputDir,\n          options.outputDir,\n        )) ??\n        []),\n      depsCommand,\n      ...(this.props.commandHooks?.afterBundling(\n        options.inputDir,\n        options.outputDir,\n      ) ?? []),\n    ]);\n  }\n\n  private getLocalBundlingProvider(): ILocalBundling {\n    const osPlatform = os.platform();\n    const createLocalCommand = (\n      outputDir: string,\n      esbuild: PackageInstallation,\n      tsc?: PackageInstallation,\n    ) =>\n      this.createBundlingCommand({\n        inputDir: this.projectRoot,\n        outputDir,\n        esbuildRunner: esbuild.isLocal\n          ? this.packageManager.runBinCommand(\"esbuild\")\n          : \"esbuild\",\n        tscRunner:\n          tsc &&\n          (tsc.isLocal ? this.packageManager.runBinCommand(\"tsc\") : \"tsc\"),\n        osPlatform,\n      });\n    const environment = this.props.environment ?? {};\n    const cwd = this.projectRoot;\n\n    return {\n      tryBundle(outputDir: string) {\n        if (!Bundling.esbuildInstallation) {\n          process.stderr.write(\n            \"esbuild cannot run locally. Switching to Docker bundling.\\n\",\n          );\n          return false;\n        }\n\n        if (\n          !Bundling.esbuildInstallation.version.startsWith(\n            `${ESBUILD_MAJOR_VERSION}.`,\n          )\n        ) {\n          throw new Error(\n            `Expected esbuild version ${ESBUILD_MAJOR_VERSION}.x but got ${Bundling.esbuildInstallation.version}`,\n          );\n        }\n\n        const localCommand = createLocalCommand(\n          outputDir,\n          Bundling.esbuildInstallation,\n          Bundling.tscInstallation,\n        );\n\n        exec(\n          osPlatform === \"win32\" ? \"cmd\" : \"bash\",\n          [osPlatform === \"win32\" ? \"/c\" : \"-c\", localCommand],\n          {\n            env: { ...process.env, ...environment },\n            stdio: [\n              // show output\n              \"ignore\", // ignore stdio\n              process.stderr, // redirect stdout to stderr\n              \"inherit\", // inherit stderr\n            ],\n            cwd,\n            windowsVerbatimArguments: osPlatform === \"win32\",\n          },\n        );\n\n        return true;\n      },\n    };\n  }\n}\n\ninterface BundlingCommandOptions {\n  readonly inputDir: string;\n  readonly outputDir: string;\n  readonly esbuildRunner: string;\n  readonly tscRunner?: string;\n  readonly osPlatform: NodeJS.Platform;\n}\n\n/**\n * OS agnostic command\n */\nclass OsCommand {\n  constructor(private readonly osPlatform: NodeJS.Platform) {}\n\n  public write(filePath: string, data: string): string {\n    if (this.osPlatform === \"win32\") {\n      if (!data) {\n        // if `data` is empty, echo a blank line, otherwise the file will contain a `^` character\n        return `echo. > \"${filePath}\"`;\n      }\n      return `echo ^${data}^ > \"${filePath}\"`;\n    }\n\n    return `echo '${data}' > \"${filePath}\"`;\n  }\n\n  public writeJson(filePath: string, data: any): string {\n    const stringifiedData = JSON.stringify(data);\n    return this.write(filePath, stringifiedData);\n  }\n\n  public copy(src: string, dest: string): string {\n    if (this.osPlatform === \"win32\") {\n      return `copy \"${src}\" \"${dest}\"`;\n    }\n\n    return `cp \"${src}\" \"${dest}\"`;\n  }\n\n  public changeDirectory(dir: string): string {\n    return `cd \"${dir}\"`;\n  }\n\n  public remove(filePath: string, force: boolean = false): string {\n    if (this.osPlatform === \"win32\") {\n      return `del \"${filePath}\"`;\n    }\n\n    const opts = force ? [\"-f\"] : [];\n    return `rm ${opts.join(\" \")} \"${filePath}\"`;\n  }\n\n  public removeDir(dir: string): string {\n    if (this.osPlatform === \"win32\") {\n      return `rmdir /s /q \"${dir}\"`;\n    }\n\n    return `rm -rf \"${dir}\"`;\n  }\n}\n\n/**\n * Chain commands\n */\nfunction chain(commands: string[]): string {\n  return commands.filter((c) => !!c).join(\" && \");\n}\n\n/**\n * Platform specific path join\n */\nfunction osPathJoin(platform: NodeJS.Platform) {\n  return function (...paths: string[]): string {\n    const joined = path.join(...paths);\n    // If we are on win32 but need posix style paths\n    if (os.platform() === \"win32\" && platform !== \"win32\") {\n      return joined.replace(/\\\\/g, \"/\");\n    }\n    return joined;\n  };\n}\n\n/**\n * Converts a runtime to an esbuild node target\n */\nfunction toTarget(runtime: Runtime): string {\n  const match = runtime.name.match(/nodejs(\\d+)/);\n\n  if (!match) {\n    throw new Error(\"Cannot extract version from runtime.\");\n  }\n\n  return `node${match[1]}`;\n}\n\nfunction toCliArgs(esbuildArgs: { [key: string]: string | boolean }): string {\n  const args = new Array<string>();\n  const reSpecifiedKeys = [\n    \"--alias\",\n    \"--drop\",\n    \"--pure\",\n    \"--log-override\",\n    \"--out-extension\",\n  ];\n\n  for (const [key, value] of Object.entries(esbuildArgs)) {\n    if (value === true || value === \"\") {\n      args.push(key);\n    } else if (reSpecifiedKeys.includes(key)) {\n      args.push(`${key}:\"${value}\"`);\n    } else if (value) {\n      args.push(`${key}=\"${value}\"`);\n    }\n  }\n\n  return args.join(\" \");\n}\n\n/**\n * Detect if a given Node.js runtime supports ESM (ECMAScript modules)\n */\nfunction isEsmRuntime(runtime: Runtime): boolean {\n  const unsupportedRuntimes = [\n    Runtime.NODEJS,\n    Runtime.NODEJS_4_3,\n    Runtime.NODEJS_6_10,\n    Runtime.NODEJS_8_10,\n    Runtime.NODEJS_10_X,\n    Runtime.NODEJS_12_X,\n  ];\n\n  return !unsupportedRuntimes.some((r) => {\n    return r.family === runtime.family && r.name === runtime.name;\n  });\n}\n"]}