terraconstructs 0.0.25 → 0.1.0

package/lib/asset-staging.js

@@ -0,0 +1,589 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetStaging = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const constructs_1 = require("constructs");
+const assets_1 = require("./assets");
+const bundling_1 = require("./bundling");
+const fs_1 = require("./fs");
+const fingerprint_1 = require("./fs/fingerprint");
+const asset_staging_1 = require("./private/asset-staging");
+const cache_1 = require("./private/cache");
+const stack_base_1 = require("./stack-base");
+// import { TerraformAsset } from "cdktf";
+// import { Stage } from "./stage";
+const ARCHIVE_EXTENSIONS = [".tar.gz", ".zip", ".jar", ".tar", ".tgz"];
+const ASSET_SALT_CONTEXT_KEY = "terraconstructs/core:assetHashSalt";
+const TERRACONSTRUCTS_STAGING_DIRECTORY = "tcons-staging";
+/**
+ * Stages a file or directory from a location on the file system into a staging
+ * directory.
+ *
+ * This is controlled by the context key 'aws:cdk:asset-staging' and enabled
+ * by the CLI by default in order to ensure that when the CDK app exists, all
+ * assets are available for deployment. Otherwise, if an app references assets
+ * in temporary locations, those will not be available when it exists (see
+ * https://github.com/aws/aws-cdk/issues/1716).
+ *
+ * The `stagedPath` property is a stringified token that represents the location
+ * of the file or directory after staging. It will be resolved only during the
+ * "prepare" stage and may be either the original path or the staged path
+ * depending on the context setting.
+ *
+ * The file/directory are staged based on their content hash (fingerprint). This
+ * means that only if content was changed, copy will happen.
+ */
+class AssetStaging extends constructs_1.Construct {
+    /**
+     * Clears the asset hash cache
+     */
+    static clearAssetHashCache() {
+        this.assetCache.clear();
+        (0, fingerprint_1.clearLargeFileFingerprintCache)();
+    }
+    // /**
+    //  * The staged asset as a TerraformAsset.
+    //  */
+    // public get asset(): TerraformAsset {
+    //   if (!this._asset) {
+    //     throw new Error("Asset has not been staged yet.");
+    //   }
+    //   return this._asset;
+    // }
+    // private _asset: TerraformAsset;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const salt = this.node.tryGetContext(ASSET_SALT_CONTEXT_KEY);
+        this.sourcePath = path.resolve(props.sourcePath);
+        this.fingerprintOptions = {
+            ...props,
+            exclude: [".is_custom_resource", ...(props.exclude ?? [])],
+            extraHash: props.extraHash || salt
+                ? `${props.extraHash ?? ""}${salt ?? ""}`
+                : undefined,
+        };
+        if (!fs.existsSync(this.sourcePath)) {
+            throw new Error(`Cannot find asset at ${this.sourcePath}`);
+        }
+        this.sourceStats = fs.statSync(this.sourcePath);
+        // AWS CDK uses Stage, TerraConstructs stages files to path scoped to cdktfJsonPath
+        // const outdir = Stage.of(this)?.assetOutdir;
+        // ...
+        // this.assetOutdir = outdir
+        // this is the directory where we will write the staged asset
+        const cdktfJsonPath = scope.node.tryGetContext("cdktfJsonPath") ??
+            findFileAboveCwd("cdktf.json");
+        if (cdktfJsonPath) {
+            // Relative paths are always considered to be relative to cdktf.json, but operations are performed relative to process.cwd
+            const absolutePath = path.resolve(path.dirname(cdktfJsonPath), TERRACONSTRUCTS_STAGING_DIRECTORY);
+            this.assetOutdir = path.relative(process.cwd(), absolutePath);
+        }
+        else {
+            throw new Error("Unable to determine cdktf.json path. Please ensure you are running this construct within a valid cdktf application scope.");
+        }
+        // Determine the hash type based on the props as props.assetHashType is
+        // optional from a caller perspective.
+        this.customSourceFingerprint = props.assetHash;
+        this.hashType = determineHashType(props.assetHashType, this.customSourceFingerprint);
+        // Decide what we're going to do, without actually doing it yet
+        let stageThisAsset;
+        const skip = false;
+        if (props.bundling) {
+            // TODO: Check if we actually have to bundle for this stack
+            // skip = !StackBase.ofTerraConstruct(this).bundlingRequired;
+            const bundling = props.bundling;
+            stageThisAsset = () => this.stageByBundling(bundling, skip);
+        }
+        else {
+            stageThisAsset = () => this.stageByCopying();
+        }
+        // Calculate a cache key from the props. This way we can check if we already
+        // staged this asset and reuse the result (e.g. the same asset with the same
+        // configuration is used in multiple stacks). In this case we can completely
+        // skip file system and bundling operations.
+        //
+        // The output directory and whether this asset is skipped or not should also be
+        // part of the cache key to make sure we don't accidentally return the wrong
+        // staged asset from the cache.
+        this.cacheKey = calculateCacheKey({
+            outdir: this.assetOutdir,
+            sourcePath: path.resolve(props.sourcePath),
+            bundling: props.bundling,
+            assetHashType: this.hashType,
+            customFingerprint: this.customSourceFingerprint,
+            extraHash: props.extraHash,
+            exclude: props.exclude,
+            ignoreMode: props.ignoreMode,
+            skip,
+        });
+        const staged = AssetStaging.assetCache.obtain(this.cacheKey, stageThisAsset);
+        this.stagedPath = staged.stagedPath;
+        this.absoluteStagedPath = staged.stagedPath;
+        this.assetHash = staged.assetHash;
+        this.packaging = staged.packaging;
+        this.isArchive = staged.isArchive;
+    }
+    /**
+     * A cryptographic hash of the asset.
+     *
+     * @deprecated see `assetHash`.
+     */
+    get sourceHash() {
+        return this.assetHash;
+    }
+    /**
+     * Return the path to the staged asset, relative to the Manifest workingDirectory of the given stack
+     *
+     * Only returns a relative path if the asset was staged, returns an absolute path if
+     * it was not staged.
+     *
+     * A bundled asset might end up in the outDir and still not count as
+     * "staged"; if asset staging is disabled we're technically expected to
+     * reference source directories, but we don't have a source directory for the
+     * bundled outputs (as the bundle output is written to a temporary
+     * directory). Nevertheless, we will still return an absolute path.
+     *
+     * A non-obvious directory layout may look like this:
+     *
+     * ```
+     *   MANIFEST ROOT
+     *     +-- asset.12345abcdef/
+     *     +-- assembly-Stage
+     *           +-- MyStack.template.json
+     *           +-- MyStack.assets.json <- will contain { "path": "../asset.12345abcdef" }
+     * ```
+     */
+    relativeStagedPath(_stack) {
+        // const manifest = App.of(this).manifest;
+        // const asmManifestDir = manifest.forStack(stack).workingDirectory;
+        // const isOutsideAssetDir = path
+        //   .relative(this.assetOutdir, this.stagedPath)
+        //   .startsWith("..");
+        // if (isOutsideAssetDir || this.stagingDisabled) {
+        //   return this.stagedPath;
+        // }
+        // return path.relative(asmManifestDir, this.stagedPath);
+        return this.stagedPath;
+    }
+    /**
+     * Stage the source to the target by copying
+     *
+     * Optionally skip if staging is disabled, in which case we pretend we did something but we don't really.
+     */
+    stageByCopying() {
+        const assetHash = this.calculateHash(this.hashType);
+        const targetPath = this.stagingDisabled
+            ? this.sourcePath
+            : path.resolve(this.assetOutdir, renderAssetFilename(assetHash, getExtension(this.sourcePath)));
+        const stagedPath = this.renderStagedPath(this.sourcePath, targetPath);
+        if (!this.sourceStats.isDirectory() && !this.sourceStats.isFile()) {
+            throw new Error(`Asset ${this.sourcePath} is expected to be either a directory or a regular file`);
+        }
+        this.stageAsset(this.sourcePath, stagedPath, "copy");
+        // // Capture staged asset as TerraformAsset before returning
+        // this._asset = new TerraformAsset(this, "asset", {
+        //   path: stagedPath,
+        // });
+        return {
+            assetHash,
+            stagedPath,
+            packaging: this.sourceStats.isDirectory()
+                ? assets_1.FileAssetPackaging.ZIP_DIRECTORY
+                : assets_1.FileAssetPackaging.FILE,
+            isArchive: this.sourceStats.isDirectory() ||
+                ARCHIVE_EXTENSIONS.includes(getExtension(this.sourcePath).toLowerCase()),
+        };
+    }
+    /**
+     * Stage the source to the target by bundling
+     *
+     * Optionally skip, in which case we pretend we did something but we don't really.
+     */
+    stageByBundling(bundling, skip) {
+        if (!this.sourceStats.isDirectory()) {
+            throw new Error(`Asset ${this.sourcePath} is expected to be a directory when bundling`);
+        }
+        if (skip) {
+            // We should have bundled, but didn't to save time. Still pretend to have a hash.
+            // If the asset uses OUTPUT or BUNDLE, we use a CUSTOM hash to avoid fingerprinting
+            // a potentially very large source directory. Other hash types are kept the same.
+            let hashType = this.hashType;
+            if (hashType === assets_1.AssetHashType.OUTPUT ||
+                hashType === assets_1.AssetHashType.BUNDLE) {
+                this.customSourceFingerprint = stack_base_1.StackBase.uniqueId(this);
+                hashType = assets_1.AssetHashType.CUSTOM;
+            }
+            // // Capture staged asset as TerraformAsset before returning
+            // this._asset = new TerraformAsset(this, "asset", {
+            //   path: this.sourcePath,
+            // });
+            return {
+                assetHash: this.calculateHash(hashType, bundling),
+                stagedPath: this.sourcePath,
+                packaging: assets_1.FileAssetPackaging.ZIP_DIRECTORY,
+                isArchive: true,
+            };
+        }
+        // Try to calculate assetHash beforehand (if we can)
+        let assetHash = this.hashType === assets_1.AssetHashType.SOURCE ||
+            this.hashType === assets_1.AssetHashType.CUSTOM
+            ? this.calculateHash(this.hashType, bundling)
+            : undefined;
+        const bundleDir = this.determineBundleDir(this.assetOutdir, assetHash);
+        this.bundle(bundling, bundleDir);
+        // Check bundling output content and determine if we will need to archive
+        const bundlingOutputType = bundling.outputType ?? bundling_1.BundlingOutput.AUTO_DISCOVER;
+        const bundledAsset = determineBundledAsset(bundleDir, bundlingOutputType);
+        // Calculate assetHash afterwards if we still must
+        assetHash =
+            assetHash ??
+                this.calculateHash(this.hashType, bundling, bundledAsset.path);
+        const stagedPath = this.renderStagedPath(bundledAsset.path, path.resolve(this.assetOutdir, renderAssetFilename(assetHash, bundledAsset.extension)));
+        this.stageAsset(bundledAsset.path, stagedPath, "move");
+        // If bundling produced a single archive file we "touch" this file in the bundling
+        // directory after it has been moved to the staging directory if the hash is known before bundling. This way if bundling
+        // is skipped because the bundling directory already exists we can still determine
+        // the correct packaging type.
+        // If the hash is calculated after bundling we remove the temporary directory now.
+        if (bundledAsset.packaging === assets_1.FileAssetPackaging.FILE) {
+            if (this.hashType === assets_1.AssetHashType.OUTPUT ||
+                this.hashType === assets_1.AssetHashType.BUNDLE) {
+                fs.rmSync(path.dirname(bundledAsset.path), {
+                    recursive: true,
+                    force: true,
+                });
+            }
+            else {
+                fs.closeSync(fs.openSync(bundledAsset.path, "w"));
+            }
+        }
+        // // Capture staged asset as TerraformAsset before returning
+        // this._asset = new TerraformAsset(this, "asset", {
+        //   path: stagedPath,
+        // });
+        return {
+            assetHash,
+            stagedPath,
+            packaging: bundledAsset.packaging,
+            isArchive: bundlingOutputType !== bundling_1.BundlingOutput.SINGLE_FILE,
+        };
+    }
+    /**
+     * Whether staging has been disabled
+     */
+    get stagingDisabled() {
+        return false;
+    }
+    /**
+     * Copies or moves the files from sourcePath to targetPath.
+     *
+     * Moving implies the source directory is temporary and can be trashed.
+     *
+     * Will not do anything if source and target are the same.
+     */
+    stageAsset(sourcePath, targetPath, style) {
+        // Is the work already done?
+        const isAlreadyStaged = fs.existsSync(targetPath);
+        if (isAlreadyStaged) {
+            if (style === "move" && sourcePath !== targetPath) {
+                fs.rmSync(sourcePath, { recursive: true, force: true });
+            }
+            return;
+        }
+        ensureDirSync(path.dirname(targetPath));
+        // Moving can be done quickly
+        if (style === "move") {
+            fs.renameSync(sourcePath, targetPath);
+            return;
+        }
+        // Copy file/directory to staging directory
+        if (this.sourceStats.isFile()) {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+        else if (this.sourceStats.isDirectory()) {
+            fs_1.FileSystem.copyDirectory(sourcePath, targetPath, this.fingerprintOptions);
+        }
+        else {
+            throw new Error(`Unknown file type: ${sourcePath}`);
+        }
+    }
+    /**
+     * Determine the directory where we're going to write the bundling output
+     *
+     * This is the target directory where we're going to write the staged output
+     * files if we can (if the hash is fully known), or a temporary directory
+     * otherwise.
+     */
+    determineBundleDir(outdir, sourceHash) {
+        if (sourceHash) {
+            return path.resolve(outdir, renderAssetFilename(sourceHash));
+        }
+        // When the asset hash isn't known in advance, bundler outputs to an
+        // intermediate directory named after the asset's cache key
+        return path.resolve(outdir, `bundling-temp-${this.cacheKey}`);
+    }
+    /**
+     * Bundles an asset to the given directory
+     *
+     * If the given directory already exists, assume that everything's already
+     * in order and don't do anything.
+     *
+     * @param options Bundling options
+     * @param bundleDir Where to create the bundle directory
+     * @returns The fully resolved bundle output directory.
+     */
+    bundle(options, bundleDir) {
+        if (fs.existsSync(bundleDir)) {
+            return;
+        }
+        const tempDir = `${bundleDir}-building`;
+        // Remove the tempDir if it exists, then recreate it
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        ensureDirSync(tempDir);
+        // Chmod the bundleDir to full access.
+        fs.chmodSync(tempDir, 0o777);
+        let localBundling;
+        try {
+            process.stderr.write(`Bundling asset ${this.node.path}...\n`);
+            localBundling = options.local?.tryBundle(tempDir, options);
+            if (!localBundling) {
+                const assetStagingOptions = {
+                    sourcePath: this.sourcePath,
+                    bundleDir: tempDir,
+                    ...options,
+                };
+                switch (options.bundlingFileAccess) {
+                    case bundling_1.BundlingFileAccess.VOLUME_COPY:
+                        new asset_staging_1.AssetBundlingVolumeCopy(assetStagingOptions).run();
+                        break;
+                    case bundling_1.BundlingFileAccess.BIND_MOUNT:
+                    default:
+                        new asset_staging_1.AssetBundlingBindMount(assetStagingOptions).run();
+                        break;
+                }
+            }
+            // Success, rename the tempDir into place
+            fs.renameSync(tempDir, bundleDir);
+        }
+        catch (err) {
+            throw new Error(`Failed to bundle asset ${this.node.path}, bundle output is located at ${tempDir}: ${err}`);
+        }
+        if (fs_1.FileSystem.isEmpty(bundleDir)) {
+            const outputDir = localBundling
+                ? bundleDir
+                : AssetStaging.BUNDLING_OUTPUT_DIR;
+            throw new Error(`Bundling did not produce any output. Check that content is written to ${outputDir}.`);
+        }
+    }
+    calculateHash(hashType, bundling, outputDir) {
+        // When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include
+        // the bundling configuration. We handle CUSTOM and bundled SOURCE hash types
+        // as a special case to preserve existing user asset hashes in all other cases.
+        if (hashType == assets_1.AssetHashType.CUSTOM ||
+            (hashType == assets_1.AssetHashType.SOURCE && bundling)) {
+            const hash = crypto.createHash("sha256");
+            // if asset hash is provided by user, use it, otherwise fingerprint the source.
+            hash.update(this.customSourceFingerprint ??
+                fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions));
+            // If we're bundling an asset, include the bundling configuration in the hash
+            if (bundling) {
+                hash.update(JSON.stringify(bundling, sanitizeHashValue));
+            }
+            return hash.digest("hex");
+        }
+        switch (hashType) {
+            case assets_1.AssetHashType.SOURCE:
+                return fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);
+            case assets_1.AssetHashType.BUNDLE:
+            case assets_1.AssetHashType.OUTPUT:
+                if (!outputDir) {
+                    throw new Error(`Cannot use \`${hashType}\` hash type when \`bundling\` is not specified.`);
+                }
+                return fs_1.FileSystem.fingerprint(outputDir, this.fingerprintOptions);
+            default:
+                throw new Error("Unknown asset hash type.");
+        }
+    }
+    renderStagedPath(sourcePath, targetPath) {
+        // Add a suffix to the asset file name
+        // because when a file without extension is specified, the source directory name is the same as the staged asset file name.
+        // But when the hashType is `AssetHashType.OUTPUT`, the source directory name begins with `bundling-temp-` and the staged asset file name is different.
+        // We only need to add a suffix when the hashType is not `AssetHashType.OUTPUT`.
+        if (this.hashType !== assets_1.AssetHashType.OUTPUT &&
+            path.dirname(sourcePath) === targetPath) {
+            targetPath = targetPath + "_noext";
+        }
+        return targetPath;
+    }
+}
+exports.AssetStaging = AssetStaging;
+_a = JSII_RTTI_SYMBOL_1;
+AssetStaging[_a] = { fqn: "terraconstructs.AssetStaging", version: "0.1.0" };
+/**
+ * The directory inside the bundling container into which the asset sources will be mounted.
+ */
+AssetStaging.BUNDLING_INPUT_DIR = "/asset-input";
+/**
+ * The directory inside the bundling container into which the bundled output should be written.
+ */
+AssetStaging.BUNDLING_OUTPUT_DIR = "/asset-output";
+/**
+ * Cache of asset hashes based on asset configuration to avoid repeated file
+ * system and bundling operations.
+ */
+AssetStaging.assetCache = new cache_1.Cache();
+function renderAssetFilename(assetHash, extension = "") {
+    return `asset.${assetHash}${extension}`;
+}
+/**
+ * Determines the hash type from user-given prop values.
+ *
+ * @param assetHashType Asset hash type construct prop
+ * @param customSourceFingerprint Asset hash seed given in the construct props
+ */
+function determineHashType(assetHashType, customSourceFingerprint) {
+    const hashType = customSourceFingerprint
+        ? (assetHashType ?? assets_1.AssetHashType.CUSTOM)
+        : (assetHashType ?? assets_1.AssetHashType.SOURCE);
+    if (customSourceFingerprint && hashType !== assets_1.AssetHashType.CUSTOM) {
+        throw new Error(`Cannot specify \`${assetHashType}\` for \`assetHashType\` when \`assetHash\` is specified. Use \`CUSTOM\` or leave \`undefined\`.`);
+    }
+    if (hashType === assets_1.AssetHashType.CUSTOM && !customSourceFingerprint) {
+        throw new Error("`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.");
+    }
+    return hashType;
+}
+/**
+ * Calculates a cache key from the props. Normalize by sorting keys.
+ */
+function calculateCacheKey(props) {
+    return crypto
+        .createHash("sha256")
+        .update(JSON.stringify(sortObject(props), sanitizeHashValue))
+        .digest("hex");
+}
+/**
+ * Recursively sort object keys
+ */
+function sortObject(object) {
+    if (typeof object !== "object" || object instanceof Array) {
+        return object;
+    }
+    const ret = {};
+    for (const key of Object.keys(object).sort()) {
+        ret[key] = sortObject(object[key]);
+    }
+    return ret;
+}
+/**
+ * Removes the auth token from pip URLs if present to prevent an unnecessary
+ * rebuild.
+ *
+ * @see https://github.com/aws/aws-cdk/issues/27331
+ */
+function sanitizeHashValue(key, value) {
+    if (key === "PIP_INDEX_URL" || key === "PIP_EXTRA_INDEX_URL") {
+        try {
+            let url = new URL(value);
+            if (url.password) {
+                url.password = "";
+                return url.toString();
+            }
+        }
+        catch (e) {
+            if (e.name === "TypeError") {
+                throw new Error(`${key} must be a valid URL, got ${value}.`);
+            }
+            throw e;
+        }
+    }
+    return value;
+}
+/**
+ * Returns the single archive file of a directory or undefined
+ */
+function findSingleFile(directory, archiveOnly) {
+    if (!fs.existsSync(directory)) {
+        throw new Error(`Directory ${directory} does not exist.`);
+    }
+    if (!fs.statSync(directory).isDirectory()) {
+        throw new Error(`${directory} is not a directory.`);
+    }
+    const content = fs.readdirSync(directory);
+    if (content.length === 1) {
+        const file = path.join(directory, content[0]);
+        const extension = getExtension(content[0]).toLowerCase();
+        if (fs.statSync(file).isFile() &&
+            (!archiveOnly || ARCHIVE_EXTENSIONS.includes(extension))) {
+            return file;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the bundled asset to use based on the content of the bundle directory
+ * and the type of output.
+ */
+function determineBundledAsset(bundleDir, outputType) {
+    const archiveFile = findSingleFile(bundleDir, outputType !== bundling_1.BundlingOutput.SINGLE_FILE);
+    // auto-discover means that if there is an archive file, we take it as the
+    // bundle, otherwise, we will archive here.
+    if (outputType === bundling_1.BundlingOutput.AUTO_DISCOVER) {
+        outputType = archiveFile
+            ? bundling_1.BundlingOutput.ARCHIVED
+            : bundling_1.BundlingOutput.NOT_ARCHIVED;
+    }
+    switch (outputType) {
+        case bundling_1.BundlingOutput.NOT_ARCHIVED:
+            return { path: bundleDir, packaging: assets_1.FileAssetPackaging.ZIP_DIRECTORY };
+        case bundling_1.BundlingOutput.ARCHIVED:
+        case bundling_1.BundlingOutput.SINGLE_FILE:
+            if (!archiveFile) {
+                throw new Error("Bundling output directory is expected to include only a single file when `output` is set to `ARCHIVED` or `SINGLE_FILE`");
+            }
+            return {
+                path: archiveFile,
+                packaging: assets_1.FileAssetPackaging.FILE,
+                extension: getExtension(archiveFile),
+            };
+    }
+}
+/**
+ * Return the extension name of a source path
+ *
+ * Loop through ARCHIVE_EXTENSIONS for valid archive extensions.
+ */
+function getExtension(source) {
+    for (const ext of ARCHIVE_EXTENSIONS) {
+        if (source.toLowerCase().endsWith(ext)) {
+            return ext;
+        }
+    }
+    return path.extname(source);
+}
+function findFileAboveCwd(file, rootPath = process.cwd()) {
+    const fullPath = path.resolve(rootPath, file);
+    if (fs.existsSync(fullPath)) {
+        return fullPath;
+    }
+    const parentDir = path.resolve(rootPath, "..");
+    if (fs.existsSync(parentDir) && parentDir !== rootPath) {
+        return findFileAboveCwd(file, parentDir);
+    }
+    return null;
+}
+function ensureDirSync(dir) {
+    if (fs.existsSync(dir)) {
+        if (!fs.statSync(dir).isDirectory()) {
+            throw new Error(`${dir} must be a directory`);
+        }
+    }
+    else {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-staging.js","sourceRoot":"","sources":["../src/asset-staging.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from \"crypto\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { Construct } from \"constructs\";\nimport { AssetHashType, AssetOptions, FileAssetPackaging } from \"./assets\";\nimport {\n  BundlingFileAccess,\n  BundlingOptions,\n  BundlingOutput,\n} from \"./bundling\";\nimport { FileSystem, FingerprintOptions } from \"./fs\";\nimport { clearLargeFileFingerprintCache } from \"./fs/fingerprint\";\nimport {\n  AssetBundlingVolumeCopy,\n  AssetBundlingBindMount,\n} from \"./private/asset-staging\";\nimport { Cache } from \"./private/cache\";\nimport { StackBase } from \"./stack-base\";\n// import { TerraformAsset } from \"cdktf\";\n// import { Stage } from \"./stage\";\n\nconst ARCHIVE_EXTENSIONS = [\".tar.gz\", \".zip\", \".jar\", \".tar\", \".tgz\"];\n\nconst ASSET_SALT_CONTEXT_KEY = \"terraconstructs/core:assetHashSalt\";\n\nconst TERRACONSTRUCTS_STAGING_DIRECTORY = \"tcons-staging\";\n\n/**\n * A previously staged asset\n */\ninterface StagedAsset {\n  /**\n   * The path where we wrote this asset previously\n   */\n  readonly stagedPath: string;\n\n  /**\n   * The hash we used previously\n   */\n  readonly assetHash: string;\n\n  /**\n   * The packaging of the asset\n   */\n  readonly packaging: FileAssetPackaging;\n\n  /**\n   * Whether this asset is an archive\n   */\n  readonly isArchive: boolean;\n}\n\n/**\n * Initialization properties for `AssetStaging`.\n */\nexport interface AssetStagingProps extends FingerprintOptions, AssetOptions {\n  /**\n   * The source file or directory to copy from.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Stages a file or directory from a location on the file system into a staging\n * directory.\n *\n * This is controlled by the context key 'aws:cdk:asset-staging' and enabled\n * by the CLI by default in order to ensure that when the CDK app exists, all\n * assets are available for deployment. Otherwise, if an app references assets\n * in temporary locations, those will not be available when it exists (see\n * https://github.com/aws/aws-cdk/issues/1716).\n *\n * The `stagedPath` property is a stringified token that represents the location\n * of the file or directory after staging. It will be resolved only during the\n * \"prepare\" stage and may be either the original path or the staged path\n * depending on the context setting.\n *\n * The file/directory are staged based on their content hash (fingerprint). This\n * means that only if content was changed, copy will happen.\n */\nexport class AssetStaging extends Construct {\n  /**\n   * The directory inside the bundling container into which the asset sources will be mounted.\n   */\n  public static readonly BUNDLING_INPUT_DIR = \"/asset-input\";\n\n  /**\n   * The directory inside the bundling container into which the bundled output should be written.\n   */\n  public static readonly BUNDLING_OUTPUT_DIR = \"/asset-output\";\n\n  /**\n   * Clears the asset hash cache\n   */\n  public static clearAssetHashCache() {\n    this.assetCache.clear();\n    clearLargeFileFingerprintCache();\n  }\n\n  /**\n   * Cache of asset hashes based on asset configuration to avoid repeated file\n   * system and bundling operations.\n   */\n  private static assetCache = new Cache<StagedAsset>();\n\n  /**\n   * Absolute path to the asset data.\n   *\n   * If asset staging is disabled, this will just be the source path or\n   * a temporary directory used for bundling.\n   *\n   * If asset staging is enabled it will be the staged path.\n   *\n   * IMPORTANT: If you are going to call `addFileAsset()`, use\n   * `relativeStagedPath()` instead.\n   *\n   * @deprecated - Use `absoluteStagedPath` instead.\n   */\n  public readonly stagedPath: string;\n\n  /**\n   * Absolute path to the asset data.\n   *\n   * If asset staging is disabled, this will just be the source path or\n   * a temporary directory used for bundling.\n   *\n   * If asset staging is enabled it will be the staged path.\n   *\n   * IMPORTANT: If you are going to call `addFileAsset()`, use\n   * `relativeStagedPath()` instead.\n   */\n  public readonly absoluteStagedPath: string;\n\n  /**\n   * The absolute path of the asset as it was referenced by the user.\n   */\n  public readonly sourcePath: string;\n\n  /**\n   * A cryptographic hash of the asset.\n   */\n  public readonly assetHash: string;\n\n  /**\n   * How this asset should be packaged.\n   */\n  public readonly packaging: FileAssetPackaging;\n\n  /**\n   * Whether this asset is an archive (zip or jar).\n   */\n  public readonly isArchive: boolean;\n\n  private readonly fingerprintOptions: FingerprintOptions;\n\n  private readonly hashType: AssetHashType;\n  // staging directory relative to the cdktf.json file to stage assets to\n  private readonly assetOutdir: string;\n\n  /**\n   * A custom source fingerprint given by the user\n   *\n   * Will not be used literally, always hashed later on.\n   */\n  private customSourceFingerprint?: string;\n\n  private readonly cacheKey: string;\n\n  private readonly sourceStats: fs.Stats;\n\n  // /**\n  //  * The staged asset as a TerraformAsset.\n  //  */\n  // public get asset(): TerraformAsset {\n  //   if (!this._asset) {\n  //     throw new Error(\"Asset has not been staged yet.\");\n  //   }\n  //   return this._asset;\n  // }\n\n  // private _asset: TerraformAsset;\n\n  constructor(scope: Construct, id: string, props: AssetStagingProps) {\n    super(scope, id);\n\n    const salt = this.node.tryGetContext(ASSET_SALT_CONTEXT_KEY);\n\n    this.sourcePath = path.resolve(props.sourcePath);\n    this.fingerprintOptions = {\n      ...props,\n      exclude: [\".is_custom_resource\", ...(props.exclude ?? [])],\n      extraHash:\n        props.extraHash || salt\n          ? `${props.extraHash ?? \"\"}${salt ?? \"\"}`\n          : undefined,\n    };\n\n    if (!fs.existsSync(this.sourcePath)) {\n      throw new Error(`Cannot find asset at ${this.sourcePath}`);\n    }\n\n    this.sourceStats = fs.statSync(this.sourcePath);\n\n    // AWS CDK uses Stage, TerraConstructs stages files to path scoped to cdktfJsonPath\n    // const outdir = Stage.of(this)?.assetOutdir;\n    // ...\n    // this.assetOutdir = outdir\n\n    // this is the directory where we will write the staged asset\n    const cdktfJsonPath =\n      scope.node.tryGetContext(\"cdktfJsonPath\") ??\n      findFileAboveCwd(\"cdktf.json\");\n    if (cdktfJsonPath) {\n      // Relative paths are always considered to be relative to cdktf.json, but operations are performed relative to process.cwd\n      const absolutePath = path.resolve(\n        path.dirname(cdktfJsonPath),\n        TERRACONSTRUCTS_STAGING_DIRECTORY,\n      );\n      this.assetOutdir = path.relative(process.cwd(), absolutePath);\n    } else {\n      throw new Error(\n        \"Unable to determine cdktf.json path. Please ensure you are running this construct within a valid cdktf application scope.\",\n      );\n    }\n\n    // Determine the hash type based on the props as props.assetHashType is\n    // optional from a caller perspective.\n    this.customSourceFingerprint = props.assetHash;\n    this.hashType = determineHashType(\n      props.assetHashType,\n      this.customSourceFingerprint,\n    );\n\n    // Decide what we're going to do, without actually doing it yet\n    let stageThisAsset: () => StagedAsset;\n    const skip = false;\n    if (props.bundling) {\n      // TODO: Check if we actually have to bundle for this stack\n      // skip = !StackBase.ofTerraConstruct(this).bundlingRequired;\n      const bundling = props.bundling;\n      stageThisAsset = () => this.stageByBundling(bundling, skip);\n    } else {\n      stageThisAsset = () => this.stageByCopying();\n    }\n\n    // Calculate a cache key from the props. This way we can check if we already\n    // staged this asset and reuse the result (e.g. the same asset with the same\n    // configuration is used in multiple stacks). In this case we can completely\n    // skip file system and bundling operations.\n    //\n    // The output directory and whether this asset is skipped or not should also be\n    // part of the cache key to make sure we don't accidentally return the wrong\n    // staged asset from the cache.\n    this.cacheKey = calculateCacheKey({\n      outdir: this.assetOutdir,\n      sourcePath: path.resolve(props.sourcePath),\n      bundling: props.bundling,\n      assetHashType: this.hashType,\n      customFingerprint: this.customSourceFingerprint,\n      extraHash: props.extraHash,\n      exclude: props.exclude,\n      ignoreMode: props.ignoreMode,\n      skip,\n    });\n\n    const staged = AssetStaging.assetCache.obtain(\n      this.cacheKey,\n      stageThisAsset,\n    );\n    this.stagedPath = staged.stagedPath;\n    this.absoluteStagedPath = staged.stagedPath;\n    this.assetHash = staged.assetHash;\n    this.packaging = staged.packaging;\n    this.isArchive = staged.isArchive;\n  }\n\n  /**\n   * A cryptographic hash of the asset.\n   *\n   * @deprecated see `assetHash`.\n   */\n  public get sourceHash(): string {\n    return this.assetHash;\n  }\n\n  /**\n   * Return the path to the staged asset, relative to the Manifest workingDirectory of the given stack\n   *\n   * Only returns a relative path if the asset was staged, returns an absolute path if\n   * it was not staged.\n   *\n   * A bundled asset might end up in the outDir and still not count as\n   * \"staged\"; if asset staging is disabled we're technically expected to\n   * reference source directories, but we don't have a source directory for the\n   * bundled outputs (as the bundle output is written to a temporary\n   * directory). Nevertheless, we will still return an absolute path.\n   *\n   * A non-obvious directory layout may look like this:\n   *\n   * ```\n   *   MANIFEST ROOT\n   *     +-- asset.12345abcdef/\n   *     +-- assembly-Stage\n   *           +-- MyStack.template.json\n   *           +-- MyStack.assets.json <- will contain { \"path\": \"../asset.12345abcdef\" }\n   * ```\n   */\n  public relativeStagedPath(_stack: StackBase) {\n    // const manifest = App.of(this).manifest;\n    // const asmManifestDir = manifest.forStack(stack).workingDirectory;\n\n    // const isOutsideAssetDir = path\n    //   .relative(this.assetOutdir, this.stagedPath)\n    //   .startsWith(\"..\");\n    // if (isOutsideAssetDir || this.stagingDisabled) {\n    //   return this.stagedPath;\n    // }\n\n    // return path.relative(asmManifestDir, this.stagedPath);\n    return this.stagedPath;\n  }\n\n  /**\n   * Stage the source to the target by copying\n   *\n   * Optionally skip if staging is disabled, in which case we pretend we did something but we don't really.\n   */\n  private stageByCopying(): StagedAsset {\n    const assetHash = this.calculateHash(this.hashType);\n    const targetPath = this.stagingDisabled\n      ? this.sourcePath\n      : path.resolve(\n          this.assetOutdir,\n          renderAssetFilename(assetHash, getExtension(this.sourcePath)),\n        );\n    const stagedPath = this.renderStagedPath(this.sourcePath, targetPath);\n\n    if (!this.sourceStats.isDirectory() && !this.sourceStats.isFile()) {\n      throw new Error(\n        `Asset ${this.sourcePath} is expected to be either a directory or a regular file`,\n      );\n    }\n\n    this.stageAsset(this.sourcePath, stagedPath, \"copy\");\n\n    // // Capture staged asset as TerraformAsset before returning\n    // this._asset = new TerraformAsset(this, \"asset\", {\n    //   path: stagedPath,\n    // });\n    return {\n      assetHash,\n      stagedPath,\n      packaging: this.sourceStats.isDirectory()\n        ? FileAssetPackaging.ZIP_DIRECTORY\n        : FileAssetPackaging.FILE,\n      isArchive:\n        this.sourceStats.isDirectory() ||\n        ARCHIVE_EXTENSIONS.includes(\n          getExtension(this.sourcePath).toLowerCase(),\n        ),\n    };\n  }\n\n  /**\n   * Stage the source to the target by bundling\n   *\n   * Optionally skip, in which case we pretend we did something but we don't really.\n   */\n  private stageByBundling(\n    bundling: BundlingOptions,\n    skip: boolean,\n  ): StagedAsset {\n    if (!this.sourceStats.isDirectory()) {\n      throw new Error(\n        `Asset ${this.sourcePath} is expected to be a directory when bundling`,\n      );\n    }\n\n    if (skip) {\n      // We should have bundled, but didn't to save time. Still pretend to have a hash.\n      // If the asset uses OUTPUT or BUNDLE, we use a CUSTOM hash to avoid fingerprinting\n      // a potentially very large source directory. Other hash types are kept the same.\n      let hashType = this.hashType;\n      if (\n        hashType === AssetHashType.OUTPUT ||\n        hashType === AssetHashType.BUNDLE\n      ) {\n        this.customSourceFingerprint = StackBase.uniqueId(this);\n        hashType = AssetHashType.CUSTOM;\n      }\n      // // Capture staged asset as TerraformAsset before returning\n      // this._asset = new TerraformAsset(this, \"asset\", {\n      //   path: this.sourcePath,\n      // });\n      return {\n        assetHash: this.calculateHash(hashType, bundling),\n        stagedPath: this.sourcePath,\n        packaging: FileAssetPackaging.ZIP_DIRECTORY,\n        isArchive: true,\n      };\n    }\n\n    // Try to calculate assetHash beforehand (if we can)\n    let assetHash =\n      this.hashType === AssetHashType.SOURCE ||\n      this.hashType === AssetHashType.CUSTOM\n        ? this.calculateHash(this.hashType, bundling)\n        : undefined;\n\n    const bundleDir = this.determineBundleDir(this.assetOutdir, assetHash);\n    this.bundle(bundling, bundleDir);\n\n    // Check bundling output content and determine if we will need to archive\n    const bundlingOutputType =\n      bundling.outputType ?? BundlingOutput.AUTO_DISCOVER;\n    const bundledAsset = determineBundledAsset(bundleDir, bundlingOutputType);\n\n    // Calculate assetHash afterwards if we still must\n    assetHash =\n      assetHash ??\n      this.calculateHash(this.hashType, bundling, bundledAsset.path);\n\n    const stagedPath = this.renderStagedPath(\n      bundledAsset.path,\n      path.resolve(\n        this.assetOutdir,\n        renderAssetFilename(assetHash, bundledAsset.extension),\n      ),\n    );\n\n    this.stageAsset(bundledAsset.path, stagedPath, \"move\");\n\n    // If bundling produced a single archive file we \"touch\" this file in the bundling\n    // directory after it has been moved to the staging directory if the hash is known before bundling. This way if bundling\n    // is skipped because the bundling directory already exists we can still determine\n    // the correct packaging type.\n    // If the hash is calculated after bundling we remove the temporary directory now.\n    if (bundledAsset.packaging === FileAssetPackaging.FILE) {\n      if (\n        this.hashType === AssetHashType.OUTPUT ||\n        this.hashType === AssetHashType.BUNDLE\n      ) {\n        fs.rmSync(path.dirname(bundledAsset.path), {\n          recursive: true,\n          force: true,\n        });\n      } else {\n        fs.closeSync(fs.openSync(bundledAsset.path, \"w\"));\n      }\n    }\n\n    // // Capture staged asset as TerraformAsset before returning\n    // this._asset = new TerraformAsset(this, \"asset\", {\n    //   path: stagedPath,\n    // });\n    return {\n      assetHash,\n      stagedPath,\n      packaging: bundledAsset.packaging,\n      isArchive: bundlingOutputType !== BundlingOutput.SINGLE_FILE,\n    };\n  }\n\n  /**\n   * Whether staging has been disabled\n   */\n  private get stagingDisabled() {\n    return false;\n  }\n\n  /**\n   * Copies or moves the files from sourcePath to targetPath.\n   *\n   * Moving implies the source directory is temporary and can be trashed.\n   *\n   * Will not do anything if source and target are the same.\n   */\n  private stageAsset(\n    sourcePath: string,\n    targetPath: string,\n    style: \"move\" | \"copy\",\n  ) {\n    // Is the work already done?\n    const isAlreadyStaged = fs.existsSync(targetPath);\n    if (isAlreadyStaged) {\n      if (style === \"move\" && sourcePath !== targetPath) {\n        fs.rmSync(sourcePath, { recursive: true, force: true });\n      }\n      return;\n    }\n\n    ensureDirSync(path.dirname(targetPath));\n\n    // Moving can be done quickly\n    if (style === \"move\") {\n      fs.renameSync(sourcePath, targetPath);\n      return;\n    }\n\n    // Copy file/directory to staging directory\n    if (this.sourceStats.isFile()) {\n      fs.copyFileSync(sourcePath, targetPath);\n    } else if (this.sourceStats.isDirectory()) {\n      FileSystem.copyDirectory(sourcePath, targetPath, this.fingerprintOptions);\n    } else {\n      throw new Error(`Unknown file type: ${sourcePath}`);\n    }\n  }\n\n  /**\n   * Determine the directory where we're going to write the bundling output\n   *\n   * This is the target directory where we're going to write the staged output\n   * files if we can (if the hash is fully known), or a temporary directory\n   * otherwise.\n   */\n  private determineBundleDir(outdir: string, sourceHash?: string) {\n    if (sourceHash) {\n      return path.resolve(outdir, renderAssetFilename(sourceHash));\n    }\n\n    // When the asset hash isn't known in advance, bundler outputs to an\n    // intermediate directory named after the asset's cache key\n    return path.resolve(outdir, `bundling-temp-${this.cacheKey}`);\n  }\n\n  /**\n   * Bundles an asset to the given directory\n   *\n   * If the given directory already exists, assume that everything's already\n   * in order and don't do anything.\n   *\n   * @param options Bundling options\n   * @param bundleDir Where to create the bundle directory\n   * @returns The fully resolved bundle output directory.\n   */\n  private bundle(options: BundlingOptions, bundleDir: string) {\n    if (fs.existsSync(bundleDir)) {\n      return;\n    }\n\n    const tempDir = `${bundleDir}-building`;\n    // Remove the tempDir if it exists, then recreate it\n    fs.rmSync(tempDir, { recursive: true, force: true });\n\n    ensureDirSync(tempDir);\n    // Chmod the bundleDir to full access.\n    fs.chmodSync(tempDir, 0o777);\n\n    let localBundling: boolean | undefined;\n    try {\n      process.stderr.write(`Bundling asset ${this.node.path}...\\n`);\n\n      localBundling = options.local?.tryBundle(tempDir, options);\n      if (!localBundling) {\n        const assetStagingOptions = {\n          sourcePath: this.sourcePath,\n          bundleDir: tempDir,\n          ...options,\n        };\n\n        switch (options.bundlingFileAccess) {\n          case BundlingFileAccess.VOLUME_COPY:\n            new AssetBundlingVolumeCopy(assetStagingOptions).run();\n            break;\n          case BundlingFileAccess.BIND_MOUNT:\n          default:\n            new AssetBundlingBindMount(assetStagingOptions).run();\n            break;\n        }\n      }\n\n      // Success, rename the tempDir into place\n      fs.renameSync(tempDir, bundleDir);\n    } catch (err) {\n      throw new Error(\n        `Failed to bundle asset ${this.node.path}, bundle output is located at ${tempDir}: ${err}`,\n      );\n    }\n\n    if (FileSystem.isEmpty(bundleDir)) {\n      const outputDir = localBundling\n        ? bundleDir\n        : AssetStaging.BUNDLING_OUTPUT_DIR;\n      throw new Error(\n        `Bundling did not produce any output. Check that content is written to ${outputDir}.`,\n      );\n    }\n  }\n\n  private calculateHash(\n    hashType: AssetHashType,\n    bundling?: BundlingOptions,\n    outputDir?: string,\n  ): string {\n    // When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include\n    // the bundling configuration. We handle CUSTOM and bundled SOURCE hash types\n    // as a special case to preserve existing user asset hashes in all other cases.\n    if (\n      hashType == AssetHashType.CUSTOM ||\n      (hashType == AssetHashType.SOURCE && bundling)\n    ) {\n      const hash = crypto.createHash(\"sha256\");\n\n      // if asset hash is provided by user, use it, otherwise fingerprint the source.\n      hash.update(\n        this.customSourceFingerprint ??\n          FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions),\n      );\n\n      // If we're bundling an asset, include the bundling configuration in the hash\n      if (bundling) {\n        hash.update(JSON.stringify(bundling, sanitizeHashValue));\n      }\n\n      return hash.digest(\"hex\");\n    }\n\n    switch (hashType) {\n      case AssetHashType.SOURCE:\n        return FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);\n      case AssetHashType.BUNDLE:\n      case AssetHashType.OUTPUT:\n        if (!outputDir) {\n          throw new Error(\n            `Cannot use \\`${hashType}\\` hash type when \\`bundling\\` is not specified.`,\n          );\n        }\n        return FileSystem.fingerprint(outputDir, this.fingerprintOptions);\n      default:\n        throw new Error(\"Unknown asset hash type.\");\n    }\n  }\n\n  private renderStagedPath(sourcePath: string, targetPath: string): string {\n    // Add a suffix to the asset file name\n    // because when a file without extension is specified, the source directory name is the same as the staged asset file name.\n    // But when the hashType is `AssetHashType.OUTPUT`, the source directory name begins with `bundling-temp-` and the staged asset file name is different.\n    // We only need to add a suffix when the hashType is not `AssetHashType.OUTPUT`.\n    if (\n      this.hashType !== AssetHashType.OUTPUT &&\n      path.dirname(sourcePath) === targetPath\n    ) {\n      targetPath = targetPath + \"_noext\";\n    }\n    return targetPath;\n  }\n}\n\nfunction renderAssetFilename(assetHash: string, extension = \"\") {\n  return `asset.${assetHash}${extension}`;\n}\n\n/**\n * Determines the hash type from user-given prop values.\n *\n * @param assetHashType Asset hash type construct prop\n * @param customSourceFingerprint Asset hash seed given in the construct props\n */\nfunction determineHashType(\n  assetHashType?: AssetHashType,\n  customSourceFingerprint?: string,\n) {\n  const hashType = customSourceFingerprint\n    ? (assetHashType ?? AssetHashType.CUSTOM)\n    : (assetHashType ?? AssetHashType.SOURCE);\n\n  if (customSourceFingerprint && hashType !== AssetHashType.CUSTOM) {\n    throw new Error(\n      `Cannot specify \\`${assetHashType}\\` for \\`assetHashType\\` when \\`assetHash\\` is specified. Use \\`CUSTOM\\` or leave \\`undefined\\`.`,\n    );\n  }\n  if (hashType === AssetHashType.CUSTOM && !customSourceFingerprint) {\n    throw new Error(\n      \"`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.\",\n    );\n  }\n\n  return hashType;\n}\n\n/**\n * Calculates a cache key from the props. Normalize by sorting keys.\n */\nfunction calculateCacheKey<A extends object>(props: A): string {\n  return crypto\n    .createHash(\"sha256\")\n    .update(JSON.stringify(sortObject(props), sanitizeHashValue))\n    .digest(\"hex\");\n}\n\n/**\n * Recursively sort object keys\n */\nfunction sortObject(object: { [key: string]: any }): { [key: string]: any } {\n  if (typeof object !== \"object\" || object instanceof Array) {\n    return object;\n  }\n  const ret: { [key: string]: any } = {};\n  for (const key of Object.keys(object).sort()) {\n    ret[key] = sortObject(object[key]);\n  }\n  return ret;\n}\n\n/**\n * Removes the auth token from pip URLs if present to prevent an unnecessary\n * rebuild.\n *\n * @see https://github.com/aws/aws-cdk/issues/27331\n */\nfunction sanitizeHashValue(key: string, value: any): any {\n  if (key === \"PIP_INDEX_URL\" || key === \"PIP_EXTRA_INDEX_URL\") {\n    try {\n      let url = new URL(value);\n      if (url.password) {\n        url.password = \"\";\n        return url.toString();\n      }\n    } catch (e: any) {\n      if (e.name === \"TypeError\") {\n        throw new Error(`${key} must be a valid URL, got ${value}.`);\n      }\n      throw e;\n    }\n  }\n  return value;\n}\n\n/**\n * Returns the single archive file of a directory or undefined\n */\nfunction findSingleFile(\n  directory: string,\n  archiveOnly: boolean,\n): string | undefined {\n  if (!fs.existsSync(directory)) {\n    throw new Error(`Directory ${directory} does not exist.`);\n  }\n\n  if (!fs.statSync(directory).isDirectory()) {\n    throw new Error(`${directory} is not a directory.`);\n  }\n\n  const content = fs.readdirSync(directory);\n  if (content.length === 1) {\n    const file = path.join(directory, content[0]);\n    const extension = getExtension(content[0]).toLowerCase();\n    if (\n      fs.statSync(file).isFile() &&\n      (!archiveOnly || ARCHIVE_EXTENSIONS.includes(extension))\n    ) {\n      return file;\n    }\n  }\n\n  return undefined;\n}\n\ninterface BundledAsset {\n  path: string;\n  packaging: FileAssetPackaging;\n  extension?: string;\n}\n\n/**\n * Returns the bundled asset to use based on the content of the bundle directory\n * and the type of output.\n */\nfunction determineBundledAsset(\n  bundleDir: string,\n  outputType: BundlingOutput,\n): BundledAsset {\n  const archiveFile = findSingleFile(\n    bundleDir,\n    outputType !== BundlingOutput.SINGLE_FILE,\n  );\n\n  // auto-discover means that if there is an archive file, we take it as the\n  // bundle, otherwise, we will archive here.\n  if (outputType === BundlingOutput.AUTO_DISCOVER) {\n    outputType = archiveFile\n      ? BundlingOutput.ARCHIVED\n      : BundlingOutput.NOT_ARCHIVED;\n  }\n\n  switch (outputType) {\n    case BundlingOutput.NOT_ARCHIVED:\n      return { path: bundleDir, packaging: FileAssetPackaging.ZIP_DIRECTORY };\n    case BundlingOutput.ARCHIVED:\n    case BundlingOutput.SINGLE_FILE:\n      if (!archiveFile) {\n        throw new Error(\n          \"Bundling output directory is expected to include only a single file when `output` is set to `ARCHIVED` or `SINGLE_FILE`\",\n        );\n      }\n      return {\n        path: archiveFile,\n        packaging: FileAssetPackaging.FILE,\n        extension: getExtension(archiveFile),\n      };\n  }\n}\n\n/**\n * Return the extension name of a source path\n *\n * Loop through ARCHIVE_EXTENSIONS for valid archive extensions.\n */\nfunction getExtension(source: string): string {\n  for (const ext of ARCHIVE_EXTENSIONS) {\n    if (source.toLowerCase().endsWith(ext)) {\n      return ext;\n    }\n  }\n\n  return path.extname(source);\n}\nfunction findFileAboveCwd(\n  file: string,\n  rootPath = process.cwd(),\n): string | null {\n  const fullPath = path.resolve(rootPath, file);\n  if (fs.existsSync(fullPath)) {\n    return fullPath;\n  }\n  const parentDir = path.resolve(rootPath, \"..\");\n  if (fs.existsSync(parentDir) && parentDir !== rootPath) {\n    return findFileAboveCwd(file, parentDir);\n  }\n  return null;\n}\n\nfunction ensureDirSync(dir: string) {\n  if (fs.existsSync(dir)) {\n    if (!fs.statSync(dir).isDirectory()) {\n      throw new Error(`${dir} must be a directory`);\n    }\n  } else {\n    fs.mkdirSync(dir, { recursive: true });\n  }\n}\n"]}