terraconstructs 0.0.24 → 0.1.0

package/lib/fs/options.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Determines how symlinks are followed.
+ */
+export declare enum SymlinkFollowMode {
+    /**
+     * Never follow symlinks.
+     */
+    NEVER = "never",
+    /**
+     * Materialize all symlinks, whether they are internal or external to the source directory.
+     */
+    ALWAYS = "always",
+    /**
+     * Only follows symlinks that are external to the source directory.
+     */
+    EXTERNAL = "external",
+    /**
+     * Forbids source from having any symlinks pointing outside of the source
+     * tree.
+     *
+     * This is the safest mode of operation as it ensures that copy operations
+     * won't materialize files from the user's file system. Internal symlinks are
+     * not followed.
+     *
+     * If the copy operation runs into an external symlink, it will fail.
+     */
+    BLOCK_EXTERNAL = "internal-only"
+}
+/**
+ * Determines the ignore behavior to use.
+ */
+export declare enum IgnoreMode {
+    /**
+     * Ignores file paths based on simple glob patterns.
+     *
+     * This is the default for file assets.
+     *
+     * It is also the default for Docker image assets, unless the '@aws-cdk/aws-ecr-assets:dockerIgnoreSupport'
+     * context flag is set.
+     */
+    GLOB = "glob",
+    /**
+     * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+     */
+    GIT = "git",
+    /**
+     * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+     *
+     * This is the default for Docker image assets if the '@aws-cdk/aws-ecr-assets:dockerIgnoreSupport'
+     * context flag is set.
+     */
+    DOCKER = "docker"
+}
+interface FileOptions {
+    /**
+     * File paths matching the patterns will be excluded. See `ignoreMode` to set the matching behavior.
+     * Has no effect on Assets bundled using the `bundling` property.
+     *
+     * @default - nothing is excluded
+     */
+    readonly exclude?: string[];
+    /**
+     * The ignore behavior to use for `exclude` patterns.
+     *
+     * @default IgnoreMode.GLOB
+     */
+    readonly ignoreMode?: IgnoreMode;
+}
+/**
+ * Options applied when copying directories
+ */
+export interface CopyOptions extends FileOptions {
+    /**
+     * A strategy for how to handle symlinks.
+     *
+     * @default SymlinkFollowMode.NEVER
+     */
+    readonly follow?: SymlinkFollowMode;
+}
+/**
+ * Options applied when copying directories into the staging location.
+ */
+export interface FileCopyOptions extends FileOptions {
+    /**
+     * A strategy for how to handle symlinks.
+     *
+     * @default SymlinkFollowMode.NEVER
+     */
+    readonly followSymlinks?: SymlinkFollowMode;
+}
+interface ExtraHashOptions {
+    /**
+     * Extra information to encode into the fingerprint (e.g. build instructions
+     * and other inputs)
+     *
+     * @default - hash is only based on source content
+     */
+    readonly extraHash?: string;
+}
+/**
+ * Options related to calculating source hash.
+ */
+export interface FingerprintOptions extends CopyOptions, ExtraHashOptions {
+}
+/**
+ * Options related to calculating source hash.
+ */
+export interface FileFingerprintOptions extends FileCopyOptions, ExtraHashOptions {
+}
+export {};

package/lib/fs/options.js

@@ -0,0 +1,60 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/fs/options.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgnoreMode = exports.SymlinkFollowMode = void 0;
+/**
+ * Determines how symlinks are followed.
+ */
+var SymlinkFollowMode;
+(function (SymlinkFollowMode) {
+    /**
+     * Never follow symlinks.
+     */
+    SymlinkFollowMode["NEVER"] = "never";
+    /**
+     * Materialize all symlinks, whether they are internal or external to the source directory.
+     */
+    SymlinkFollowMode["ALWAYS"] = "always";
+    /**
+     * Only follows symlinks that are external to the source directory.
+     */
+    SymlinkFollowMode["EXTERNAL"] = "external";
+    /**
+     * Forbids source from having any symlinks pointing outside of the source
+     * tree.
+     *
+     * This is the safest mode of operation as it ensures that copy operations
+     * won't materialize files from the user's file system. Internal symlinks are
+     * not followed.
+     *
+     * If the copy operation runs into an external symlink, it will fail.
+     */
+    SymlinkFollowMode["BLOCK_EXTERNAL"] = "internal-only";
+})(SymlinkFollowMode || (exports.SymlinkFollowMode = SymlinkFollowMode = {}));
+/**
+ * Determines the ignore behavior to use.
+ */
+var IgnoreMode;
+(function (IgnoreMode) {
+    /**
+     * Ignores file paths based on simple glob patterns.
+     *
+     * This is the default for file assets.
+     *
+     * It is also the default for Docker image assets, unless the '@aws-cdk/aws-ecr-assets:dockerIgnoreSupport'
+     * context flag is set.
+     */
+    IgnoreMode["GLOB"] = "glob";
+    /**
+     * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+     */
+    IgnoreMode["GIT"] = "git";
+    /**
+     * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+     *
+     * This is the default for Docker image assets if the '@aws-cdk/aws-ecr-assets:dockerIgnoreSupport'
+     * context flag is set.
+     */
+    IgnoreMode["DOCKER"] = "docker";
+})(IgnoreMode || (exports.IgnoreMode = IgnoreMode = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/fs/utils.d.ts

@@ -0,0 +1,11 @@
+import { SymlinkFollowMode } from "./options";
+/**
+ * Determines whether a symlink should be followed or not, based on a FollowMode.
+ *
+ * @param mode       the FollowMode.
+ * @param sourceRoot the root of the source tree.
+ * @param realPath   the real path of the target of the symlink.
+ *
+ * @returns true if the link should be followed.
+ */
+export declare function shouldFollow(mode: SymlinkFollowMode, sourceRoot: string, realPath: string): boolean;

package/lib/fs/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/fs/utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldFollow = shouldFollow;
+const fs = require("fs");
+const path = require("path");
+const options_1 = require("./options");
+/**
+ * Determines whether a symlink should be followed or not, based on a FollowMode.
+ *
+ * @param mode       the FollowMode.
+ * @param sourceRoot the root of the source tree.
+ * @param realPath   the real path of the target of the symlink.
+ *
+ * @returns true if the link should be followed.
+ */
+function shouldFollow(mode, sourceRoot, realPath) {
+    switch (mode) {
+        case options_1.SymlinkFollowMode.ALWAYS:
+            return fs.existsSync(realPath);
+        case options_1.SymlinkFollowMode.EXTERNAL:
+            return !_isInternal() && fs.existsSync(realPath);
+        case options_1.SymlinkFollowMode.BLOCK_EXTERNAL:
+            return _isInternal() && fs.existsSync(realPath);
+        case options_1.SymlinkFollowMode.NEVER:
+            return false;
+        default:
+            throw new Error(`Unsupported FollowMode: ${mode}`);
+    }
+    function _isInternal() {
+        return path.resolve(realPath).startsWith(path.resolve(sourceRoot));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -5,4 +5,9 @@ export * from "./time-zone";
 export * from "./expiration";
 export * from "./size";
 export * from "./terra-func";
+export * from "./assets";
+export * from "./asset-staging";
+export * from "./asset-manager";
+export * from "./bundling";
+export * from "./fs";
 export * as aws from "./aws";

package/lib/index.js

@@ -22,6 +22,12 @@ __exportStar(require("./time-zone"), exports);
 __exportStar(require("./expiration"), exports);
 __exportStar(require("./size"), exports);
 __exportStar(require("./terra-func"), exports);
+// AWS CDK Bundling
+__exportStar(require("./assets"), exports);
+__exportStar(require("./asset-staging"), exports);
+__exportStar(require("./asset-manager"), exports);
+__exportStar(require("./bundling"), exports);
+__exportStar(require("./fs"), exports);
 // cloud specific exports
 exports.aws = require("./aws");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtREFBaUM7QUFDakMsK0NBQTZCO0FBQzdCLDZDQUEyQjtBQUMzQiw4Q0FBNEI7QUFDNUIsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QiwrQ0FBNkI7QUFFN0IseUJBQXlCO0FBQ3pCLCtCQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0cnVjdC1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdGFjay1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kdXJhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGltZS16b25lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9leHBpcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zaXplXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXJyYS1mdW5jXCI7XG5cbi8vIGNsb3VkIHNwZWNpZmljIGV4cG9ydHNcbmV4cG9ydCAqIGFzIGF3cyBmcm9tIFwiLi9hd3NcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtREFBaUM7QUFDakMsK0NBQTZCO0FBQzdCLDZDQUEyQjtBQUMzQiw4Q0FBNEI7QUFDNUIsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QiwrQ0FBNkI7QUFFN0IsbUJBQW1CO0FBQ25CLDJDQUF5QjtBQUN6QixrREFBZ0M7QUFDaEMsa0RBQWdDO0FBQ2hDLDZDQUEyQjtBQUMzQix1Q0FBcUI7QUFFckIseUJBQXlCO0FBQ3pCLCtCQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0cnVjdC1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdGFjay1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kdXJhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGltZS16b25lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9leHBpcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zaXplXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZXJyYS1mdW5jXCI7XG5cbi8vIEFXUyBDREsgQnVuZGxpbmdcbmV4cG9ydCAqIGZyb20gXCIuL2Fzc2V0c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXNzZXQtc3RhZ2luZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXNzZXQtbWFuYWdlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYnVuZGxpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZzXCI7XG5cbi8vIGNsb3VkIHNwZWNpZmljIGV4cG9ydHNcbmV4cG9ydCAqIGFzIGF3cyBmcm9tIFwiLi9hd3NcIjtcbiJdfQ==

package/lib/private/asset-staging.d.ts

@@ -0,0 +1,83 @@
+import { SpawnSyncOptions } from "child_process";
+import { BundlingOptions } from "../bundling";
+/**
+ * Options for Docker based bundling of assets
+ */
+interface AssetBundlingOptions extends BundlingOptions {
+    /**
+     * Path where the source files are located
+     */
+    readonly sourcePath: string;
+    /**
+     * Path where the output files should be stored
+     */
+    readonly bundleDir: string;
+}
+declare abstract class AssetBundlingBase {
+    protected options: AssetBundlingOptions;
+    constructor(options: AssetBundlingOptions);
+    /**
+     * Determines a useful default user if not given otherwise
+     */
+    protected determineUser(): string;
+}
+/**
+ * Bundles files with bind mount as copy method
+ */
+export declare class AssetBundlingBindMount extends AssetBundlingBase {
+    /**
+     * Bundle files with bind mount as copy method
+     */
+    run(): void;
+}
+/**
+ * Provides a helper container for copying bundling related files to specific input and output volumes
+ */
+export declare class AssetBundlingVolumeCopy extends AssetBundlingBase {
+    /**
+     * Name of the Docker volume that is used for the asset input
+     */
+    private inputVolumeName;
+    /**
+     * Name of the Docker volume that is used for the asset output
+     */
+    private outputVolumeName;
+    /**
+     * Name of the Docker helper container to copy files into the volume
+     */
+    copyContainerName: string;
+    constructor(options: AssetBundlingOptions);
+    /**
+     * Creates volumes for asset input and output
+     */
+    private prepareVolumes;
+    /**
+     * Removes volumes for asset input and output
+     */
+    private cleanVolumes;
+    /**
+     * runs a helper container that holds volumes and does some preparation tasks
+     * @param user The user that will later access these files and needs permissions to do so
+     */
+    private startHelperContainer;
+    /**
+     * removes the Docker helper container
+     */
+    private cleanHelperContainer;
+    /**
+     * copy files from the host where this is executed into the input volume
+     * @param sourcePath - path to folder where files should be copied from - without trailing slash
+     */
+    private copyInputFrom;
+    /**
+     * copy files from the the output volume to the host where this is executed
+     * @param outputPath - path to folder where files should be copied to - without trailing slash
+     */
+    private copyOutputTo;
+    /**
+     * Bundle files with VOLUME_COPY method
+     */
+    run(): void;
+}
+export declare function dockerExec(args: string[], options?: SpawnSyncOptions): import("child_process").SpawnSyncReturns<string | Buffer<ArrayBufferLike>>;
+export {};

package/lib/private/asset-staging.js

@@ -0,0 +1,205 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/private/asset-staging.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetBundlingVolumeCopy = exports.AssetBundlingBindMount = void 0;
+exports.dockerExec = dockerExec;
+const child_process_1 = require("child_process");
+const crypto = require("crypto");
+const os = require("os");
+// import { AssetStaging } from "../asset-staging";
+const asset_staging_1 = require("../asset-staging");
+class AssetBundlingBase {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Determines a useful default user if not given otherwise
+     */
+    determineUser() {
+        let user;
+        if (this.options.user) {
+            user = this.options.user;
+        }
+        else {
+            // Default to current user
+            const userInfo = os.userInfo();
+            user =
+                userInfo.uid !== -1 // uid is -1 on Windows
+                    ? `${userInfo.uid}:${userInfo.gid}`
+                    : "1000:1000";
+        }
+        return user;
+    }
+}
+/**
+ * Bundles files with bind mount as copy method
+ */
+class AssetBundlingBindMount extends AssetBundlingBase {
+    /**
+     * Bundle files with bind mount as copy method
+     */
+    run() {
+        this.options.image.run({
+            command: this.options.command,
+            user: this.determineUser(),
+            environment: this.options.environment,
+            entrypoint: this.options.entrypoint,
+            workingDirectory: this.options.workingDirectory ?? asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR,
+            securityOpt: this.options.securityOpt ?? "",
+            volumesFrom: this.options.volumesFrom,
+            volumes: [
+                {
+                    hostPath: this.options.sourcePath,
+                    containerPath: asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR,
+                },
+                {
+                    hostPath: this.options.bundleDir,
+                    containerPath: asset_staging_1.AssetStaging.BUNDLING_OUTPUT_DIR,
+                },
+                ...(this.options.volumes ?? []),
+            ],
+            network: this.options.network,
+        });
+    }
+}
+exports.AssetBundlingBindMount = AssetBundlingBindMount;
+/**
+ * Provides a helper container for copying bundling related files to specific input and output volumes
+ */
+class AssetBundlingVolumeCopy extends AssetBundlingBase {
+    constructor(options) {
+        super(options);
+        const copySuffix = crypto.randomBytes(12).toString("hex");
+        this.inputVolumeName = `assetInput${copySuffix}`;
+        this.outputVolumeName = `assetOutput${copySuffix}`;
+        this.copyContainerName = `copyContainer${copySuffix}`;
+    }
+    /**
+     * Creates volumes for asset input and output
+     */
+    prepareVolumes() {
+        dockerExec(["volume", "create", this.inputVolumeName]);
+        dockerExec(["volume", "create", this.outputVolumeName]);
+    }
+    /**
+     * Removes volumes for asset input and output
+     */
+    cleanVolumes() {
+        dockerExec(["volume", "rm", this.inputVolumeName]);
+        dockerExec(["volume", "rm", this.outputVolumeName]);
+    }
+    /**
+     * runs a helper container that holds volumes and does some preparation tasks
+     * @param user The user that will later access these files and needs permissions to do so
+     */
+    startHelperContainer(user) {
+        dockerExec([
+            "run",
+            "--name",
+            this.copyContainerName,
+            "-v",
+            `${this.inputVolumeName}:${asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR}`,
+            "-v",
+            `${this.outputVolumeName}:${asset_staging_1.AssetStaging.BUNDLING_OUTPUT_DIR}`,
+            "public.ecr.aws/docker/library/alpine",
+            "sh",
+            "-c",
+            `mkdir -p ${asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR} && chown -R ${user} ${asset_staging_1.AssetStaging.BUNDLING_OUTPUT_DIR} && chown -R ${user} ${asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR}`,
+        ]);
+    }
+    /**
+     * removes the Docker helper container
+     */
+    cleanHelperContainer() {
+        dockerExec(["rm", this.copyContainerName]);
+    }
+    /**
+     * copy files from the host where this is executed into the input volume
+     * @param sourcePath - path to folder where files should be copied from - without trailing slash
+     */
+    copyInputFrom(sourcePath) {
+        dockerExec([
+            "cp",
+            `${sourcePath}/.`,
+            `${this.copyContainerName}:${asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR}`,
+        ]);
+    }
+    /**
+     * copy files from the the output volume to the host where this is executed
+     * @param outputPath - path to folder where files should be copied to - without trailing slash
+     */
+    copyOutputTo(outputPath) {
+        dockerExec([
+            "cp",
+            `${this.copyContainerName}:${asset_staging_1.AssetStaging.BUNDLING_OUTPUT_DIR}/.`,
+            outputPath,
+        ]);
+    }
+    /**
+     * Bundle files with VOLUME_COPY method
+     */
+    run() {
+        const user = this.determineUser();
+        this.prepareVolumes();
+        this.startHelperContainer(user); // TODO handle user properly
+        this.copyInputFrom(this.options.sourcePath);
+        this.options.image.run({
+            command: this.options.command,
+            user: user,
+            environment: this.options.environment,
+            entrypoint: this.options.entrypoint,
+            workingDirectory: this.options.workingDirectory ?? asset_staging_1.AssetStaging.BUNDLING_INPUT_DIR,
+            securityOpt: this.options.securityOpt ?? "",
+            volumes: this.options.volumes,
+            volumesFrom: [
+                this.copyContainerName,
+                ...(this.options.volumesFrom ?? []),
+            ],
+        });
+        this.copyOutputTo(this.options.bundleDir);
+        this.cleanHelperContainer();
+        this.cleanVolumes();
+    }
+}
+exports.AssetBundlingVolumeCopy = AssetBundlingVolumeCopy;
+function dockerExec(args, options) {
+    const prog = process.env.CDK_DOCKER ?? "docker";
+    const proc = (0, child_process_1.spawnSync)(prog, args, options ?? {
+        encoding: "utf-8",
+        stdio: [
+            // show Docker output
+            "ignore", // ignore stdio
+            // AWSCDK: process.stderr, // redirect stdout to stderr (causes radix error in bun?)
+            "inherit",
+            "inherit", // inherit stderr
+        ],
+    });
+    if (proc.error) {
+        throw proc.error;
+    }
+    if (proc.status !== 0) {
+        const reason = proc.signal != null ? `signal ${proc.signal}` : `status ${proc.status}`;
+        const command = [
+            prog,
+            ...args.map((arg) => /[^a-z0-9_-]/i.test(arg) ? JSON.stringify(arg) : arg),
+        ].join(" ");
+        function prependLines(firstLine, text) {
+            if (!text || text.length === 0) {
+                return [];
+            }
+            const padding = " ".repeat(firstLine.length);
+            return text
+                .toString("utf-8")
+                .split("\n")
+                .map((line, idx) => `${idx === 0 ? firstLine : padding}${line}`);
+        }
+        throw new Error([
+            `${prog} exited with ${reason}`,
+            ...(prependLines("--> STDOUT:  ", proc.stdout) ?? []),
+            ...(prependLines("--> STDERR:  ", proc.stderr) ?? []),
+            `--> Command: ${command}`,
+        ].join("\n"));
+    }
+    return proc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-staging.js","sourceRoot":"","sources":["../../src/private/asset-staging.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/private/asset-staging.ts\n\nimport { spawnSync, SpawnSyncOptions } from \"child_process\";\nimport * as crypto from \"crypto\";\nimport * as os from \"os\";\n// import { AssetStaging } from \"../asset-staging\";\nimport { AssetStaging } from \"../asset-staging\";\nimport { BundlingOptions } from \"../bundling\";\n\n/**\n * Options for Docker based bundling of assets\n */\ninterface AssetBundlingOptions extends BundlingOptions {\n  /**\n   * Path where the source files are located\n   */\n  readonly sourcePath: string;\n  /**\n   * Path where the output files should be stored\n   */\n  readonly bundleDir: string;\n}\n\nabstract class AssetBundlingBase {\n  protected options: AssetBundlingOptions;\n  constructor(options: AssetBundlingOptions) {\n    this.options = options;\n  }\n  /**\n   * Determines a useful default user if not given otherwise\n   */\n  protected determineUser() {\n    let user: string;\n    if (this.options.user) {\n      user = this.options.user;\n    } else {\n      // Default to current user\n      const userInfo = os.userInfo();\n      user =\n        userInfo.uid !== -1 // uid is -1 on Windows\n          ? `${userInfo.uid}:${userInfo.gid}`\n          : \"1000:1000\";\n    }\n    return user;\n  }\n}\n\n/**\n * Bundles files with bind mount as copy method\n */\nexport class AssetBundlingBindMount extends AssetBundlingBase {\n  /**\n   * Bundle files with bind mount as copy method\n   */\n  public run() {\n    this.options.image.run({\n      command: this.options.command,\n      user: this.determineUser(),\n      environment: this.options.environment,\n      entrypoint: this.options.entrypoint,\n      workingDirectory:\n        this.options.workingDirectory ?? AssetStaging.BUNDLING_INPUT_DIR,\n      securityOpt: this.options.securityOpt ?? \"\",\n      volumesFrom: this.options.volumesFrom,\n      volumes: [\n        {\n          hostPath: this.options.sourcePath,\n          containerPath: AssetStaging.BUNDLING_INPUT_DIR,\n        },\n        {\n          hostPath: this.options.bundleDir,\n          containerPath: AssetStaging.BUNDLING_OUTPUT_DIR,\n        },\n        ...(this.options.volumes ?? []),\n      ],\n      network: this.options.network,\n    });\n  }\n}\n\n/**\n * Provides a helper container for copying bundling related files to specific input and output volumes\n */\nexport class AssetBundlingVolumeCopy extends AssetBundlingBase {\n  /**\n   * Name of the Docker volume that is used for the asset input\n   */\n  private inputVolumeName: string;\n  /**\n   * Name of the Docker volume that is used for the asset output\n   */\n  private outputVolumeName: string;\n  /**\n   * Name of the Docker helper container to copy files into the volume\n   */\n  public copyContainerName: string;\n\n  constructor(options: AssetBundlingOptions) {\n    super(options);\n    const copySuffix = crypto.randomBytes(12).toString(\"hex\");\n    this.inputVolumeName = `assetInput${copySuffix}`;\n    this.outputVolumeName = `assetOutput${copySuffix}`;\n    this.copyContainerName = `copyContainer${copySuffix}`;\n  }\n\n  /**\n   * Creates volumes for asset input and output\n   */\n  private prepareVolumes() {\n    dockerExec([\"volume\", \"create\", this.inputVolumeName]);\n    dockerExec([\"volume\", \"create\", this.outputVolumeName]);\n  }\n\n  /**\n   * Removes volumes for asset input and output\n   */\n  private cleanVolumes() {\n    dockerExec([\"volume\", \"rm\", this.inputVolumeName]);\n    dockerExec([\"volume\", \"rm\", this.outputVolumeName]);\n  }\n\n  /**\n   * runs a helper container that holds volumes and does some preparation tasks\n   * @param user The user that will later access these files and needs permissions to do so\n   */\n  private startHelperContainer(user: string) {\n    dockerExec([\n      \"run\",\n      \"--name\",\n      this.copyContainerName,\n      \"-v\",\n      `${this.inputVolumeName}:${AssetStaging.BUNDLING_INPUT_DIR}`,\n      \"-v\",\n      `${this.outputVolumeName}:${AssetStaging.BUNDLING_OUTPUT_DIR}`,\n      \"public.ecr.aws/docker/library/alpine\",\n      \"sh\",\n      \"-c\",\n      `mkdir -p ${AssetStaging.BUNDLING_INPUT_DIR} && chown -R ${user} ${AssetStaging.BUNDLING_OUTPUT_DIR} && chown -R ${user} ${AssetStaging.BUNDLING_INPUT_DIR}`,\n    ]);\n  }\n\n  /**\n   * removes the Docker helper container\n   */\n  private cleanHelperContainer() {\n    dockerExec([\"rm\", this.copyContainerName]);\n  }\n\n  /**\n   * copy files from the host where this is executed into the input volume\n   * @param sourcePath - path to folder where files should be copied from - without trailing slash\n   */\n  private copyInputFrom(sourcePath: string) {\n    dockerExec([\n      \"cp\",\n      `${sourcePath}/.`,\n      `${this.copyContainerName}:${AssetStaging.BUNDLING_INPUT_DIR}`,\n    ]);\n  }\n\n  /**\n   * copy files from the the output volume to the host where this is executed\n   * @param outputPath - path to folder where files should be copied to - without trailing slash\n   */\n  private copyOutputTo(outputPath: string) {\n    dockerExec([\n      \"cp\",\n      `${this.copyContainerName}:${AssetStaging.BUNDLING_OUTPUT_DIR}/.`,\n      outputPath,\n    ]);\n  }\n\n  /**\n   * Bundle files with VOLUME_COPY method\n   */\n  public run() {\n    const user = this.determineUser();\n    this.prepareVolumes();\n    this.startHelperContainer(user); // TODO handle user properly\n    this.copyInputFrom(this.options.sourcePath);\n\n    this.options.image.run({\n      command: this.options.command,\n      user: user,\n      environment: this.options.environment,\n      entrypoint: this.options.entrypoint,\n      workingDirectory:\n        this.options.workingDirectory ?? AssetStaging.BUNDLING_INPUT_DIR,\n      securityOpt: this.options.securityOpt ?? \"\",\n      volumes: this.options.volumes,\n      volumesFrom: [\n        this.copyContainerName,\n        ...(this.options.volumesFrom ?? []),\n      ],\n    });\n\n    this.copyOutputTo(this.options.bundleDir);\n    this.cleanHelperContainer();\n    this.cleanVolumes();\n  }\n}\n\nexport function dockerExec(args: string[], options?: SpawnSyncOptions) {\n  const prog = process.env.CDK_DOCKER ?? \"docker\";\n  const proc = spawnSync(\n    prog,\n    args,\n    options ?? {\n      encoding: \"utf-8\",\n      stdio: [\n        // show Docker output\n        \"ignore\", // ignore stdio\n        // AWSCDK: process.stderr, // redirect stdout to stderr (causes radix error in bun?)\n        \"inherit\",\n        \"inherit\", // inherit stderr\n      ],\n    },\n  );\n\n  if (proc.error) {\n    throw proc.error;\n  }\n\n  if (proc.status !== 0) {\n    const reason =\n      proc.signal != null ? `signal ${proc.signal}` : `status ${proc.status}`;\n    const command = [\n      prog,\n      ...args.map((arg) =>\n        /[^a-z0-9_-]/i.test(arg) ? JSON.stringify(arg) : arg,\n      ),\n    ].join(\" \");\n\n    function prependLines(\n      firstLine: string,\n      text: Buffer | string | undefined,\n    ): string[] {\n      if (!text || text.length === 0) {\n        return [];\n      }\n      const padding = \" \".repeat(firstLine.length);\n      return text\n        .toString(\"utf-8\")\n        .split(\"\\n\")\n        .map((line, idx) => `${idx === 0 ? firstLine : padding}${line}`);\n    }\n\n    throw new Error(\n      [\n        `${prog} exited with ${reason}`,\n        ...(prependLines(\"--> STDOUT:  \", proc.stdout) ?? []),\n        ...(prependLines(\"--> STDERR:  \", proc.stderr) ?? []),\n        `--> Command: ${command}`,\n      ].join(\"\\n\"),\n    );\n  }\n\n  return proc;\n}\n"]}

package/lib/private/cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A simple cache class.
+ *
+ * Must be declared at the top of the file because we're going to use it statically in the
+ * AssetStaging class.
+ */
+export declare class Cache<A> {
+    private cache;
+    /**
+     * Clears the cache
+     */
+    clear(): void;
+    /**
+     * Get a value from the cache or calculate it
+     */
+    obtain(cacheKey: string, calcFn: () => A): A;
+}

package/lib/private/cache.js

@@ -0,0 +1,35 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/private/cache.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+/**
+ * A simple cache class.
+ *
+ * Must be declared at the top of the file because we're going to use it statically in the
+ * AssetStaging class.
+ */
+class Cache {
+    constructor() {
+        this.cache = new Map();
+    }
+    /**
+     * Clears the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get a value from the cache or calculate it
+     */
+    obtain(cacheKey, calcFn) {
+        let value = this.cache.get(cacheKey);
+        if (value) {
+            return value;
+        }
+        value = calcFn();
+        this.cache.set(cacheKey, value);
+        return value;
+    }
+}
+exports.Cache = Cache;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsOEZBQThGOzs7QUFFOUY7Ozs7O0dBS0c7QUFDSCxNQUFhLEtBQUs7SUFBbEI7UUFDVSxVQUFLLEdBQUcsSUFBSSxHQUFHLEVBQWEsQ0FBQztJQXNCdkMsQ0FBQztJQXBCQzs7T0FFRztJQUNJLEtBQUs7UUFDVixJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFFRDs7T0FFRztJQUNJLE1BQU0sQ0FBQyxRQUFnQixFQUFFLE1BQWU7UUFDN0MsSUFBSSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDckMsSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUNWLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUVELEtBQUssR0FBRyxNQUFNLEVBQUUsQ0FBQztRQUNqQixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDaEMsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0Y7QUF2QkQsc0JBdUJDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cHM6Ly9naXRodWIuY29tL2F3cy9hd3MtY2RrL2Jsb2IvdjIuMTg2LjAvcGFja2FnZXMvYXdzLWNkay1saWIvY29yZS9saWIvcHJpdmF0ZS9jYWNoZS50c1xuXG4vKipcbiAqIEEgc2ltcGxlIGNhY2hlIGNsYXNzLlxuICpcbiAqIE11c3QgYmUgZGVjbGFyZWQgYXQgdGhlIHRvcCBvZiB0aGUgZmlsZSBiZWNhdXNlIHdlJ3JlIGdvaW5nIHRvIHVzZSBpdCBzdGF0aWNhbGx5IGluIHRoZVxuICogQXNzZXRTdGFnaW5nIGNsYXNzLlxuICovXG5leHBvcnQgY2xhc3MgQ2FjaGU8QT4ge1xuICBwcml2YXRlIGNhY2hlID0gbmV3IE1hcDxzdHJpbmcsIEE+KCk7XG5cbiAgLyoqXG4gICAqIENsZWFycyB0aGUgY2FjaGVcbiAgICovXG4gIHB1YmxpYyBjbGVhcigpIHtcbiAgICB0aGlzLmNhY2hlLmNsZWFyKCk7XG4gIH1cblxuICAvKipcbiAgICogR2V0IGEgdmFsdWUgZnJvbSB0aGUgY2FjaGUgb3IgY2FsY3VsYXRlIGl0XG4gICAqL1xuICBwdWJsaWMgb2J0YWluKGNhY2hlS2V5OiBzdHJpbmcsIGNhbGNGbjogKCkgPT4gQSk6IEEge1xuICAgIGxldCB2YWx1ZSA9IHRoaXMuY2FjaGUuZ2V0KGNhY2hlS2V5KTtcbiAgICBpZiAodmFsdWUpIHtcbiAgICAgIHJldHVybiB2YWx1ZTtcbiAgICB9XG5cbiAgICB2YWx1ZSA9IGNhbGNGbigpO1xuICAgIHRoaXMuY2FjaGUuc2V0KGNhY2hlS2V5LCB2YWx1ZSk7XG4gICAgcmV0dXJuIHZhbHVlO1xuICB9XG59XG4iXX0=

package/lib/private/jsii-deprecated.d.ts

@@ -0,0 +1,2 @@
+export declare function quiet(): string | undefined;
+export declare function reset(deprecated: string | undefined): void;

package/lib/private/jsii-deprecated.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/private/jsii-deprecated.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quiet = quiet;
+exports.reset = reset;
+function quiet() {
+    const deprecated = process.env.JSII_DEPRECATED;
+    process.env.JSII_DEPRECATED = "quiet";
+    return deprecated;
+}
+function reset(deprecated) {
+    if (deprecated === undefined) {
+        delete process.env.JSII_DEPRECATED;
+    }
+    else {
+        process.env.JSII_DEPRECATED = deprecated;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNpaS1kZXByZWNhdGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ByaXZhdGUvanNpaS1kZXByZWNhdGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSx3R0FBd0c7O0FBRXhHLHNCQUlDO0FBRUQsc0JBTUM7QUFaRCxTQUFnQixLQUFLO0lBQ25CLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDO0lBQy9DLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxHQUFHLE9BQU8sQ0FBQztJQUN0QyxPQUFPLFVBQVUsQ0FBQztBQUNwQixDQUFDO0FBRUQsU0FBZ0IsS0FBSyxDQUFDLFVBQThCO0lBQ2xELElBQUksVUFBVSxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzdCLE9BQU8sT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUM7SUFDckMsQ0FBQztTQUFNLENBQUM7UUFDTixPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsR0FBRyxVQUFVLENBQUM7SUFDM0MsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi92Mi4xODYuMC9wYWNrYWdlcy9hd3MtY2RrLWxpYi9jb3JlL2xpYi9wcml2YXRlL2pzaWktZGVwcmVjYXRlZC50c1xuXG5leHBvcnQgZnVuY3Rpb24gcXVpZXQoKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgY29uc3QgZGVwcmVjYXRlZCA9IHByb2Nlc3MuZW52LkpTSUlfREVQUkVDQVRFRDtcbiAgcHJvY2Vzcy5lbnYuSlNJSV9ERVBSRUNBVEVEID0gXCJxdWlldFwiO1xuICByZXR1cm4gZGVwcmVjYXRlZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHJlc2V0KGRlcHJlY2F0ZWQ6IHN0cmluZyB8IHVuZGVmaW5lZCkge1xuICBpZiAoZGVwcmVjYXRlZCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgZGVsZXRlIHByb2Nlc3MuZW52LkpTSUlfREVQUkVDQVRFRDtcbiAgfSBlbHNlIHtcbiAgICBwcm9jZXNzLmVudi5KU0lJX0RFUFJFQ0FURUQgPSBkZXByZWNhdGVkO1xuICB9XG59XG4iXX0=