terraconstructs 0.0.25 → 0.1.1

package/lib/aws/storage/assets/image-asset.js

@@ -0,0 +1,247 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerImageAsset = exports.Platform = exports.NetworkMode = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-ecr-assets/lib/image-asset.ts
+const fs = require("fs");
+const path = require("path");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const ecr = require("..");
+const __1 = require("../../..");
+const aws_stack_1 = require("../../aws-stack");
+/**
+ * networking mode on build time supported by docker
+ */
+class NetworkMode {
+    /**
+     * Reuse another container's network stack
+     *
+     * @param containerId The target container's id or name
+     */
+    static fromContainer(containerId) {
+        return new NetworkMode(`container:${containerId}`);
+    }
+    /**
+     * Used to specify a custom networking mode
+     * Use this if the networking mode name is not yet supported by the CDK.
+     *
+     * @param mode The networking mode to use for docker build
+     */
+    static custom(mode) {
+        return new NetworkMode(mode);
+    }
+    /**
+     * @param mode The networking mode to use for docker build
+     */
+    constructor(mode) {
+        this.mode = mode;
+    }
+}
+exports.NetworkMode = NetworkMode;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkMode[_a] = { fqn: "terraconstructs.aws.storage.assets.NetworkMode", version: "0.1.1" };
+/**
+ * The default networking mode if omitted, create a network stack on the default Docker bridge
+ */
+NetworkMode.DEFAULT = new NetworkMode("default");
+/**
+ * Use the Docker host network stack
+ */
+NetworkMode.HOST = new NetworkMode("host");
+/**
+ * Disable the network stack, only the loopback device will be created
+ */
+NetworkMode.NONE = new NetworkMode("none");
+/**
+ * platform supported by docker
+ */
+class Platform {
+    /**
+     * Used to specify a custom platform
+     * Use this if the platform name is not yet supported by the CDK.
+     *
+     * @param platform The platform to use for docker build
+     */
+    static custom(platform) {
+        return new Platform(platform);
+    }
+    /**
+     * @param platform The platform to use for docker build
+     */
+    constructor(platform) {
+        this.platform = platform;
+    }
+}
+exports.Platform = Platform;
+_b = JSII_RTTI_SYMBOL_1;
+Platform[_b] = { fqn: "terraconstructs.aws.storage.assets.Platform", version: "0.1.1" };
+/**
+ * Build for linux/amd64
+ */
+Platform.LINUX_AMD64 = new Platform("linux/amd64");
+/**
+ * Build for linux/arm64
+ */
+Platform.LINUX_ARM64 = new Platform("linux/arm64");
+/**
+ * An asset that represents a Docker image.
+ *
+ * The image will be created in build time and uploaded to an ECR repository.
+ *
+ * WARNING: `DockerAsset[0-9]*` and `DockerAsset_Image[0-9]*` identifiers are
+ * used internally by the Stack Asset Manager and will cause Id conflicts.
+ */
+class DockerImageAsset extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // none of the properties use tokens
+        validateProps(props);
+        // resolve full path
+        const dir = path.resolve(props.directory);
+        if (!fs.existsSync(dir)) {
+            // throw new ValidationError(`Cannot find image directory at ${dir}`, this);
+            throw new Error(`Cannot find image directory at ${dir}`);
+        }
+        // validate the docker file exists
+        this.dockerfilePath = props.file || "Dockerfile";
+        const file = path.join(dir, this.dockerfilePath);
+        if (!fs.existsSync(file)) {
+            // throw new ValidationError(`Cannot find file at ${file}`, this);
+            throw new Error(`Cannot find file at ${file}`);
+        }
+        let ignoreMode = props.ignoreMode ?? __1.IgnoreMode.DOCKER;
+        let exclude = props.exclude || [];
+        const ignore = path.join(dir, ".dockerignore");
+        if (fs.existsSync(ignore)) {
+            const dockerIgnorePatterns = fs
+                .readFileSync(ignore)
+                .toString()
+                .split("\n")
+                .filter((e) => !!e);
+            exclude = [
+                ...dockerIgnorePatterns,
+                ...exclude,
+                // Ensure .dockerignore is included no matter what.
+                "!.dockerignore",
+            ];
+        }
+        // Ensure the Dockerfile is included no matter what.
+        exclude.push("!" + path.basename(file));
+        // Ensure the cdk.out folder is not included to avoid infinite loops.
+        // const cdkout = Stage.of(this)?.outdir ?? "cdk.out";
+        // exclude.push(cdkout);
+        exclude.push("cdk.out");
+        if (props.repositoryName) {
+            // "@aws-cdk/aws-ecr-assets:repositoryNameDeprecated",
+            cdktf_1.Annotations.of(this).addWarning('DockerImageAsset.repositoryName is deprecated. Override "core.Stack.addDockerImageAsset" to control asset locations');
+        }
+        // include build context in "extra" so it will impact the hash
+        const extraHash = {};
+        if (props.invalidation?.extraHash !== false && props.extraHash) {
+            extraHash.user = props.extraHash;
+        }
+        if (props.invalidation?.buildArgs !== false && props.buildArgs) {
+            extraHash.buildArgs = props.buildArgs;
+        }
+        if (props.invalidation?.buildSecrets !== false && props.buildSecrets) {
+            extraHash.buildSecrets = props.buildSecrets;
+        }
+        if (props.invalidation?.buildSsh !== false && props.buildSsh) {
+            extraHash.buildSsh = props.buildSsh;
+        }
+        if (props.invalidation?.target !== false && props.target) {
+            extraHash.target = props.target;
+        }
+        if (props.invalidation?.file !== false && props.file) {
+            extraHash.file = props.file;
+        }
+        if (props.invalidation?.repositoryName !== false && props.repositoryName) {
+            extraHash.repositoryName = props.repositoryName;
+        }
+        if (props.invalidation?.networkMode !== false && props.networkMode) {
+            extraHash.networkMode = props.networkMode;
+        }
+        if (props.invalidation?.platform !== false && props.platform) {
+            extraHash.platform = props.platform;
+        }
+        if (props.invalidation?.outputs !== false && props.outputs) {
+            extraHash.outputs = props.outputs;
+        }
+        // add "salt" to the hash in order to invalidate the image in the upgrade to
+        // 1.21.0 which removes the AdoptedRepository resource (and will cause the
+        // deletion of the ECR repository the app used).
+        extraHash.version = "1.21.0";
+        const staging = new __1.AssetStaging(this, "Staging", {
+            ...props,
+            follow: props.followSymlinks,
+            exclude,
+            ignoreMode,
+            sourcePath: dir,
+            extraHash: Object.keys(extraHash).length === 0
+                ? undefined
+                : JSON.stringify(extraHash),
+        });
+        this.assetHash = staging.assetHash;
+        this.sourceHash = this.assetHash;
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        this.assetPath = staging.relativeStagedPath(stack);
+        this.assetName = props.assetName;
+        this.dockerBuildArgs = props.buildArgs;
+        this.dockerBuildSecrets = props.buildSecrets;
+        this.dockerBuildSsh = props.buildSsh;
+        this.dockerBuildTarget = props.target;
+        this.dockerOutputs = props.outputs;
+        this.dockerCacheFrom = props.cacheFrom;
+        this.dockerCacheTo = props.cacheTo;
+        this.dockerCacheDisabled = props.cacheDisabled;
+        const location = stack.addDockerImageAsset({
+            directoryName: this.assetPath,
+            assetName: this.assetName,
+            dockerBuildArgs: this.dockerBuildArgs,
+            dockerBuildSecrets: this.dockerBuildSecrets,
+            dockerBuildSsh: this.dockerBuildSsh,
+            dockerBuildTarget: this.dockerBuildTarget,
+            dockerFile: props.file,
+            sourceHash: staging.assetHash,
+            networkMode: props.networkMode?.mode,
+            platform: props.platform?.platform,
+            dockerOutputs: this.dockerOutputs,
+            dockerCacheFrom: this.dockerCacheFrom,
+            dockerCacheTo: this.dockerCacheTo,
+            dockerCacheDisabled: this.dockerCacheDisabled,
+        });
+        this.repository = ecr.Repository.fromRepositoryName(this, "Repository", location.repositoryName);
+        this.imageUri = location.imageUri;
+        this.imageTag = location.imageTag ?? this.assetHash;
+    }
+}
+exports.DockerImageAsset = DockerImageAsset;
+_c = JSII_RTTI_SYMBOL_1;
+DockerImageAsset[_c] = { fqn: "terraconstructs.aws.storage.assets.DockerImageAsset", version: "0.1.1" };
+function validateProps(props) {
+    for (const [key, value] of Object.entries(props)) {
+        if (cdktf_1.Token.isUnresolved(value)) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Cannot use Token as value of '${key}': this value is used before deployment starts`);
+        }
+    }
+    validateBuildArgs(props.buildArgs);
+    validateBuildSecrets(props.buildSecrets);
+}
+function validateBuildProps(buildPropName, buildProps) {
+    for (const [key, value] of Object.entries(buildProps || {})) {
+        if (cdktf_1.Token.isUnresolved(key) || cdktf_1.Token.isUnresolved(value)) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Cannot use tokens in keys or values of "${buildPropName}" since they are needed before deployment`);
+        }
+    }
+}
+function validateBuildArgs(buildArgs) {
+    validateBuildProps("buildArgs", buildArgs);
+}
+function validateBuildSecrets(buildSecrets) {
+    validateBuildProps("buildSecrets", buildSecrets);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-asset.js","sourceRoot":"","sources":["../../../../src/aws/storage/assets/image-asset.ts"],"names":[],"mappings":";;;;;AAAA,sGAAsG;AAEtG,yBAAyB;AACzB,6BAA6B;AAC7B,iCAA2C;AAC3C,2CAAuC;AACvC,0BAA0B;AAC1B,gCAOkB;AAClB,+CAA2C;AAE3C;;GAEG;AACH,MAAa,WAAW;IAgBtB;;;;OAIG;IACI,MAAM,CAAC,aAAa,CAAC,WAAmB;QAC7C,OAAO,IAAI,WAAW,CAAC,aAAa,WAAW,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,MAAM,CAAC,IAAY;QAC/B,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,YAAoC,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;;AAtCtD,kCAuCC;;;AAtCC;;GAEG;AACoB,mBAAO,GAAG,IAAI,WAAW,CAAC,SAAS,CAAC,CAAC;AAE5D;;GAEG;AACoB,gBAAI,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;AAEtD;;GAEG;AACoB,gBAAI,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;AA2BxD;;GAEG;AACH,MAAa,QAAQ;IAWnB;;;;;OAKG;IACI,MAAM,CAAC,MAAM,CAAC,QAAgB;QACnC,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,YAAoC,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;IAAG,CAAC;;AAxB1D,4BAyBC;;;AAxBC;;GAEG;AACoB,oBAAW,GAAG,IAAI,QAAQ,CAAC,aAAa,CAAC,CAAC;AAEjE;;GAEG;AACoB,oBAAW,GAAG,IAAI,QAAQ,CAAC,aAAa,CAAC,CAAC;AA2QnE;;;;;;;GAOG;AACH,MAAa,gBAAiB,SAAQ,sBAAS;IA6F7C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA4B;QACpE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,oCAAoC;QACpC,aAAa,CAAC,KAAK,CAAC,CAAC;QAErB,oBAAoB;QACpB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,4EAA4E;YAC5E,MAAM,IAAI,KAAK,CAAC,kCAAkC,GAAG,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,kCAAkC;QAClC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,IAAI,IAAI,YAAY,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACjD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,kEAAkE;YAClE,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,cAAU,CAAC,MAAM,CAAC;QAEvD,IAAI,OAAO,GAAa,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QAE5C,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;QAE/C,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,oBAAoB,GAAG,EAAE;iBAC5B,YAAY,CAAC,MAAM,CAAC;iBACpB,QAAQ,EAAE;iBACV,KAAK,CAAC,IAAI,CAAC;iBACX,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEtB,OAAO,GAAG;gBACR,GAAG,oBAAoB;gBACvB,GAAG,OAAO;gBAEV,mDAAmD;gBACnD,gBAAgB;aACjB,CAAC;QACJ,CAAC;QAED,oDAAoD;QACpD,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,qEAAqE;QACrE,sDAAsD;QACtD,wBAAwB;QACxB,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAExB,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;YACzB,sDAAsD;YACtD,mBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,qHAAqH,CACtH,CAAC;QACJ,CAAC;QAED,8DAA8D;QAC9D,MAAM,SAAS,GAA6B,EAAE,CAAC;QAC/C,IAAI,KAAK,CAAC,YAAY,EAAE,SAAS,KAAK,KAAK,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAC/D,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC;QACnC,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,SAAS,KAAK,KAAK,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAC/D,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QACxC,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,YAAY,KAAK,KAAK,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACrE,SAAS,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QAC9C,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,QAAQ,KAAK,KAAK,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC7D,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QACtC,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACzD,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAClC,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACrD,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAC9B,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,cAAc,KAAK,KAAK,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;YACzE,SAAS,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QAClD,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,WAAW,KAAK,KAAK,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACnE,SAAS,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QAC5C,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,QAAQ,KAAK,KAAK,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC7D,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QACtC,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,OAAO,KAAK,KAAK,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAC3D,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACpC,CAAC;QAED,4EAA4E;QAC5E,0EAA0E;QAC1E,gDAAgD;QAChD,SAAS,CAAC,OAAO,GAAG,QAAQ,CAAC;QAE7B,MAAM,OAAO,GAAG,IAAI,gBAAY,CAAC,IAAI,EAAE,SAAS,EAAE;YAChD,GAAG,KAAK;YACR,MAAM,EAAE,KAAK,CAAC,cAAc;YAC5B,OAAO;YACP,UAAU;YACV,UAAU,EAAE,GAAG;YACf,SAAS,EACP,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC;gBACjC,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;SAChC,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;QAEjC,MAAM,KAAK,GAAG,oBAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QACjC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,SAAS,CAAC;QACvC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAAC;QAC7C,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,QAAQ,CAAC;QACrC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,MAAM,CAAC;QACtC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,SAAS,CAAC;QACvC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC;QACnC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,aAAa,CAAC;QAE/C,MAAM,QAAQ,GAAG,KAAK,CAAC,mBAAmB,CAAC;YACzC,aAAa,EAAE,IAAI,CAAC,SAAS;YAC7B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,UAAU,EAAE,KAAK,CAAC,IAAI;YACtB,UAAU,EAAE,OAAO,CAAC,SAAS;YAC7B,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,IAAI;YACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ;YAClC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;SAC9C,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,kBAAkB,CACjD,IAAI,EACJ,YAAY,EACZ,QAAQ,CAAC,cAAc,CACxB,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC;IACtD,CAAC;;AA/OH,4CAgPC;;;AAED,SAAS,aAAa,CAAC,KAA4B;IACjD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,IAAI,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,qCAAqC;YACrC,MAAM,IAAI,KAAK,CACb,iCAAiC,GAAG,gDAAgD,CACrF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACnC,oBAAoB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,kBAAkB,CACzB,aAAqB,EACrB,UAAsC;IAEtC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE,CAAC;QAC5D,IAAI,aAAK,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,qCAAqC;YACrC,MAAM,IAAI,KAAK,CACb,2CAA2C,aAAa,2CAA2C,CACpG,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,SAAqC;IAC9D,kBAAkB,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;AAC7C,CAAC;AAED,SAAS,oBAAoB,CAAC,YAAwC;IACpE,kBAAkB,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-ecr-assets/lib/image-asset.ts\n\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { Annotations, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as ecr from \"..\";\nimport {\n  AssetStaging,\n  FileFingerprintOptions,\n  IgnoreMode,\n  // ValidationError,\n  // UnscopedValidationError,\n  IAsset,\n} from \"../../..\";\nimport { AwsStack } from \"../../aws-stack\";\n\n/**\n * networking mode on build time supported by docker\n */\nexport class NetworkMode {\n  /**\n   * The default networking mode if omitted, create a network stack on the default Docker bridge\n   */\n  public static readonly DEFAULT = new NetworkMode(\"default\");\n\n  /**\n   * Use the Docker host network stack\n   */\n  public static readonly HOST = new NetworkMode(\"host\");\n\n  /**\n   * Disable the network stack, only the loopback device will be created\n   */\n  public static readonly NONE = new NetworkMode(\"none\");\n\n  /**\n   * Reuse another container's network stack\n   *\n   * @param containerId The target container's id or name\n   */\n  public static fromContainer(containerId: string) {\n    return new NetworkMode(`container:${containerId}`);\n  }\n\n  /**\n   * Used to specify a custom networking mode\n   * Use this if the networking mode name is not yet supported by the CDK.\n   *\n   * @param mode The networking mode to use for docker build\n   */\n  public static custom(mode: string) {\n    return new NetworkMode(mode);\n  }\n\n  /**\n   * @param mode The networking mode to use for docker build\n   */\n  private constructor(public readonly mode: string) {}\n}\n\n/**\n * platform supported by docker\n */\nexport class Platform {\n  /**\n   * Build for linux/amd64\n   */\n  public static readonly LINUX_AMD64 = new Platform(\"linux/amd64\");\n\n  /**\n   * Build for linux/arm64\n   */\n  public static readonly LINUX_ARM64 = new Platform(\"linux/arm64\");\n\n  /**\n   * Used to specify a custom platform\n   * Use this if the platform name is not yet supported by the CDK.\n   *\n   * @param platform The platform to use for docker build\n   */\n  public static custom(platform: string) {\n    return new Platform(platform);\n  }\n\n  /**\n   * @param platform The platform to use for docker build\n   */\n  private constructor(public readonly platform: string) {}\n}\n\n/**\n * Options to control invalidation of `DockerImageAsset` asset hashes\n */\nexport interface DockerImageAssetInvalidationOptions {\n  /**\n   * Use `extraHash` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly extraHash?: boolean;\n\n  /**\n   * Use `buildArgs` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly buildArgs?: boolean;\n\n  /**\n   * Use `buildSecrets` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly buildSecrets?: boolean;\n\n  /**\n   * Use `buildSsh` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly buildSsh?: boolean;\n\n  /**\n   * Use `target` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly target?: boolean;\n\n  /**\n   * Use `file` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly file?: boolean;\n\n  /**\n   * Use `repositoryName` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly repositoryName?: boolean;\n\n  /**\n   * Use `networkMode` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly networkMode?: boolean;\n\n  /**\n   * Use `platform` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly platform?: boolean;\n\n  /**\n   * Use `outputs` while calculating the asset hash\n   *\n   * @default true\n   */\n  readonly outputs?: boolean;\n}\n\n// TODO: Duplicate from core.DockerCacheOption?\n/**\n * Options for configuring the Docker cache backend\n */\nexport interface DockerCacheOption {\n  /**\n   * The type of cache to use.\n   * Refer to https://docs.docker.com/build/cache/backends/ for full list of backends.\n   * @default - unspecified\n   *\n   * @example 'registry'\n   */\n  readonly type: string;\n  /**\n   * Any parameters to pass into the docker cache backend configuration.\n   * Refer to https://docs.docker.com/build/cache/backends/ for cache backend configuration.\n   * @default {} No options provided\n   *\n   * @example\n   * declare const branch: string;\n   *\n   * const params = {\n   *   ref: `12345678.dkr.ecr.us-west-2.amazonaws.com/cache:${branch}`,\n   *   mode: \"max\",\n   * };\n   */\n  readonly params?: { [key: string]: string };\n}\n\n/**\n * Options for DockerImageAsset\n */\nexport interface DockerImageAssetOptions extends FileFingerprintOptions {\n  /**\n   * ECR repository name\n   *\n   * Specify this property if you need to statically address the image, e.g.\n   * from a Kubernetes Pod. Note, this is only the repository name, without the\n   * registry and the tag parts.\n   *\n   * @default - the default ECR repository for CDK assets\n   * @deprecated to control the location of docker image assets, please override\n   * `Stack.addDockerImageAsset`. this feature will be removed in future\n   * releases.\n   */\n  readonly repositoryName?: string;\n\n  /**\n   * Build args to pass to the `docker build` command.\n   *\n   * Since Docker build arguments are resolved before deployment, keys and\n   * values cannot refer to unresolved tokens (such as `lambda.functionArn` or\n   * `queue.queueUrl`).\n   *\n   * @default - no build args are passed\n   */\n  readonly buildArgs?: { [key: string]: string };\n\n  /**\n   * Build secrets.\n   *\n   * Docker BuildKit must be enabled to use build secrets.\n   *\n   * @see https://docs.docker.com/build/buildkit/\n   *\n   * @default - no build secrets\n   *\n   * @example\n   * import { DockerBuildSecret } from 'aws-cdk-lib';\n   *\n   * const buildSecrets = {\n   *   'MY_SECRET': DockerBuildSecret.fromSrc('file.txt')\n   * };\n   */\n  readonly buildSecrets?: { [key: string]: string };\n\n  /**\n   * SSH agent socket or keys to pass to the `docker build` command.\n   *\n   * Docker BuildKit must be enabled to use the ssh flag\n   *\n   * @see https://docs.docker.com/build/buildkit/\n   *\n   * @default - no --ssh flag\n   */\n  readonly buildSsh?: string;\n\n  /**\n   * Docker target to build to\n   *\n   * @default - no target\n   */\n  readonly target?: string;\n\n  /**\n   * Path to the Dockerfile (relative to the directory).\n   *\n   * @default 'Dockerfile'\n   */\n  readonly file?: string;\n\n  /**\n   * Networking mode for the RUN commands during build. Support docker API 1.25+.\n   *\n   * @default - no networking mode specified (the default networking mode `NetworkMode.DEFAULT` will be used)\n   */\n  readonly networkMode?: NetworkMode;\n\n  /**\n   * Platform to build for. _Requires Docker Buildx_.\n   *\n   * @default - no platform specified (the current machine architecture will be used)\n   */\n  readonly platform?: Platform;\n\n  /**\n   * Options to control which parameters are used to invalidate the asset hash.\n   *\n   * @default - hash all parameters\n   */\n  readonly invalidation?: DockerImageAssetInvalidationOptions;\n\n  /**\n   * Outputs to pass to the `docker build` command.\n   *\n   * @default - no outputs are passed to the build command (default outputs are used)\n   * @see https://docs.docker.com/engine/reference/commandline/build/#custom-build-outputs\n   */\n  readonly outputs?: string[];\n\n  /**\n   * Unique identifier of the docker image asset and its potential revisions.\n   * Required if using AppScopedStagingSynthesizer.\n   *\n   * @default - no asset name\n   */\n  readonly assetName?: string;\n\n  /**\n   * Cache from options to pass to the `docker build` command.\n   *\n   * @default - no cache from options are passed to the build command\n   * @see https://docs.docker.com/build/cache/backends/\n   */\n  readonly cacheFrom?: DockerCacheOption[];\n\n  /**\n   * Cache to options to pass to the `docker build` command.\n   *\n   * @default - no cache to options are passed to the build command\n   * @see https://docs.docker.com/build/cache/backends/\n   */\n  readonly cacheTo?: DockerCacheOption;\n\n  /**\n   * Disable the cache and pass `--no-cache` to the `docker build` command.\n   *\n   * @default - cache is used\n   */\n  readonly cacheDisabled?: boolean;\n}\n\n/**\n * Props for DockerImageAssets\n */\nexport interface DockerImageAssetProps extends DockerImageAssetOptions {\n  /**\n   * The directory where the Dockerfile is stored\n   *\n   * Any directory inside with a name that matches the CDK output folder (cdk.out by default) will be excluded from the asset\n   */\n  readonly directory: string;\n}\n\n/**\n * An asset that represents a Docker image.\n *\n * The image will be created in build time and uploaded to an ECR repository.\n *\n * WARNING: `DockerAsset[0-9]*` and `DockerAsset_Image[0-9]*` identifiers are\n * used internally by the Stack Asset Manager and will cause Id conflicts.\n */\nexport class DockerImageAsset extends Construct implements IAsset {\n  /**\n   * The full URI of the image (including a tag). Use this reference to pull\n   * the asset.\n   */\n  public imageUri: string;\n\n  /**\n   * Repository where the image is stored\n   */\n  public repository: ecr.IRepository;\n\n  /**\n   * A hash of the source of this asset, which is available at construction time. As this is a plain\n   * string, it can be used in construct IDs in order to enforce creation of a new resource when\n   * the content hash has changed.\n   * @deprecated use assetHash\n   */\n  public readonly sourceHash: string;\n\n  /**\n   * A hash of this asset, which is available at construction time. As this is a plain string, it\n   * can be used in construct IDs in order to enforce creation of a new resource when the content\n   * hash has changed.\n   */\n  public readonly assetHash: string;\n\n  /**\n   * The tag of this asset when it is uploaded to ECR. The tag may differ from the assetHash if a stack synthesizer adds a dockerTagPrefix.\n   */\n  public readonly imageTag: string;\n\n  /**\n   * The path to the asset, relative to the current Cloud Assembly\n   *\n   * If asset staging is disabled, this will just be the original path.\n   *\n   * If asset staging is enabled it will be the staged path.\n   */\n  private readonly assetPath: string;\n\n  /**\n   * The path to the Dockerfile, relative to the assetPath\n   */\n  private readonly dockerfilePath?: string;\n\n  /**\n   * Build args to pass to the `docker build` command.\n   */\n  private readonly dockerBuildArgs?: { [key: string]: string };\n\n  /**\n   * Build secrets to pass to the `docker build` command.\n   */\n  private readonly dockerBuildSecrets?: { [key: string]: string };\n\n  /**\n   * SSH agent socket or keys to pass to the `docker build` command.\n   */\n  private readonly dockerBuildSsh?: string;\n  /**\n   * Outputs to pass to the `docker build` command.\n   */\n  private readonly dockerOutputs?: string[];\n\n  /**\n   * Unique identifier of the docker image asset and its potential revisions.\n   * Required if using AppScopedStagingSynthesizer.\n   *\n   * @default - no asset name\n   */\n  private readonly assetName?: string;\n\n  /**\n   * Cache from options to pass to the `docker build` command.\n   */\n  private readonly dockerCacheFrom?: DockerCacheOption[];\n\n  /**\n   * Cache to options to pass to the `docker build` command.\n   */\n  private readonly dockerCacheTo?: DockerCacheOption;\n\n  /**\n   * Disable the cache and pass `--no-cache` to the `docker build` command.\n   */\n  private readonly dockerCacheDisabled?: boolean;\n\n  /**\n   * Docker target to build to\n   */\n  private readonly dockerBuildTarget?: string;\n\n  constructor(scope: Construct, id: string, props: DockerImageAssetProps) {\n    super(scope, id);\n\n    // none of the properties use tokens\n    validateProps(props);\n\n    // resolve full path\n    const dir = path.resolve(props.directory);\n    if (!fs.existsSync(dir)) {\n      // throw new ValidationError(`Cannot find image directory at ${dir}`, this);\n      throw new Error(`Cannot find image directory at ${dir}`);\n    }\n\n    // validate the docker file exists\n    this.dockerfilePath = props.file || \"Dockerfile\";\n    const file = path.join(dir, this.dockerfilePath);\n    if (!fs.existsSync(file)) {\n      // throw new ValidationError(`Cannot find file at ${file}`, this);\n      throw new Error(`Cannot find file at ${file}`);\n    }\n\n    let ignoreMode = props.ignoreMode ?? IgnoreMode.DOCKER;\n\n    let exclude: string[] = props.exclude || [];\n\n    const ignore = path.join(dir, \".dockerignore\");\n\n    if (fs.existsSync(ignore)) {\n      const dockerIgnorePatterns = fs\n        .readFileSync(ignore)\n        .toString()\n        .split(\"\\n\")\n        .filter((e) => !!e);\n\n      exclude = [\n        ...dockerIgnorePatterns,\n        ...exclude,\n\n        // Ensure .dockerignore is included no matter what.\n        \"!.dockerignore\",\n      ];\n    }\n\n    // Ensure the Dockerfile is included no matter what.\n    exclude.push(\"!\" + path.basename(file));\n    // Ensure the cdk.out folder is not included to avoid infinite loops.\n    // const cdkout = Stage.of(this)?.outdir ?? \"cdk.out\";\n    // exclude.push(cdkout);\n    exclude.push(\"cdk.out\");\n\n    if (props.repositoryName) {\n      // \"@aws-cdk/aws-ecr-assets:repositoryNameDeprecated\",\n      Annotations.of(this).addWarning(\n        'DockerImageAsset.repositoryName is deprecated. Override \"core.Stack.addDockerImageAsset\" to control asset locations',\n      );\n    }\n\n    // include build context in \"extra\" so it will impact the hash\n    const extraHash: { [field: string]: any } = {};\n    if (props.invalidation?.extraHash !== false && props.extraHash) {\n      extraHash.user = props.extraHash;\n    }\n    if (props.invalidation?.buildArgs !== false && props.buildArgs) {\n      extraHash.buildArgs = props.buildArgs;\n    }\n    if (props.invalidation?.buildSecrets !== false && props.buildSecrets) {\n      extraHash.buildSecrets = props.buildSecrets;\n    }\n    if (props.invalidation?.buildSsh !== false && props.buildSsh) {\n      extraHash.buildSsh = props.buildSsh;\n    }\n    if (props.invalidation?.target !== false && props.target) {\n      extraHash.target = props.target;\n    }\n    if (props.invalidation?.file !== false && props.file) {\n      extraHash.file = props.file;\n    }\n    if (props.invalidation?.repositoryName !== false && props.repositoryName) {\n      extraHash.repositoryName = props.repositoryName;\n    }\n    if (props.invalidation?.networkMode !== false && props.networkMode) {\n      extraHash.networkMode = props.networkMode;\n    }\n    if (props.invalidation?.platform !== false && props.platform) {\n      extraHash.platform = props.platform;\n    }\n    if (props.invalidation?.outputs !== false && props.outputs) {\n      extraHash.outputs = props.outputs;\n    }\n\n    // add \"salt\" to the hash in order to invalidate the image in the upgrade to\n    // 1.21.0 which removes the AdoptedRepository resource (and will cause the\n    // deletion of the ECR repository the app used).\n    extraHash.version = \"1.21.0\";\n\n    const staging = new AssetStaging(this, \"Staging\", {\n      ...props,\n      follow: props.followSymlinks,\n      exclude,\n      ignoreMode,\n      sourcePath: dir,\n      extraHash:\n        Object.keys(extraHash).length === 0\n          ? undefined\n          : JSON.stringify(extraHash),\n    });\n\n    this.assetHash = staging.assetHash;\n    this.sourceHash = this.assetHash;\n\n    const stack = AwsStack.ofAwsConstruct(this);\n    this.assetPath = staging.relativeStagedPath(stack);\n    this.assetName = props.assetName;\n    this.dockerBuildArgs = props.buildArgs;\n    this.dockerBuildSecrets = props.buildSecrets;\n    this.dockerBuildSsh = props.buildSsh;\n    this.dockerBuildTarget = props.target;\n    this.dockerOutputs = props.outputs;\n    this.dockerCacheFrom = props.cacheFrom;\n    this.dockerCacheTo = props.cacheTo;\n    this.dockerCacheDisabled = props.cacheDisabled;\n\n    const location = stack.addDockerImageAsset({\n      directoryName: this.assetPath,\n      assetName: this.assetName,\n      dockerBuildArgs: this.dockerBuildArgs,\n      dockerBuildSecrets: this.dockerBuildSecrets,\n      dockerBuildSsh: this.dockerBuildSsh,\n      dockerBuildTarget: this.dockerBuildTarget,\n      dockerFile: props.file,\n      sourceHash: staging.assetHash,\n      networkMode: props.networkMode?.mode,\n      platform: props.platform?.platform,\n      dockerOutputs: this.dockerOutputs,\n      dockerCacheFrom: this.dockerCacheFrom,\n      dockerCacheTo: this.dockerCacheTo,\n      dockerCacheDisabled: this.dockerCacheDisabled,\n    });\n\n    this.repository = ecr.Repository.fromRepositoryName(\n      this,\n      \"Repository\",\n      location.repositoryName,\n    );\n    this.imageUri = location.imageUri;\n    this.imageTag = location.imageTag ?? this.assetHash;\n  }\n}\n\nfunction validateProps(props: DockerImageAssetProps) {\n  for (const [key, value] of Object.entries(props)) {\n    if (Token.isUnresolved(value)) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `Cannot use Token as value of '${key}': this value is used before deployment starts`,\n      );\n    }\n  }\n\n  validateBuildArgs(props.buildArgs);\n  validateBuildSecrets(props.buildSecrets);\n}\n\nfunction validateBuildProps(\n  buildPropName: string,\n  buildProps?: { [key: string]: string },\n) {\n  for (const [key, value] of Object.entries(buildProps || {})) {\n    if (Token.isUnresolved(key) || Token.isUnresolved(value)) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `Cannot use tokens in keys or values of \"${buildPropName}\" since they are needed before deployment`,\n      );\n    }\n  }\n}\n\nfunction validateBuildArgs(buildArgs?: { [key: string]: string }) {\n  validateBuildProps(\"buildArgs\", buildArgs);\n}\n\nfunction validateBuildSecrets(buildSecrets?: { [key: string]: string }) {\n  validateBuildProps(\"buildSecrets\", buildSecrets);\n}\n"]}

package/lib/aws/storage/assets/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./s3";
+export * from "./image-asset";

package/lib/aws/storage/assets/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./s3"), exports);
+__exportStar(require("./image-asset"), exports);
+// TODO: Requires support for executable assets in the core library
+// export * from "./tarball-asset";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL3N0b3JhZ2UvYXNzZXRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1Q0FBcUI7QUFDckIsZ0RBQThCO0FBQzlCLG1FQUFtRTtBQUNuRSxtQ0FBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9zM1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW1hZ2UtYXNzZXRcIjtcbi8vIFRPRE86IFJlcXVpcmVzIHN1cHBvcnQgZm9yIGV4ZWN1dGFibGUgYXNzZXRzIGluIHRoZSBjb3JlIGxpYnJhcnlcbi8vIGV4cG9ydCAqIGZyb20gXCIuL3RhcmJhbGwtYXNzZXRcIjtcbiJdfQ==

package/lib/aws/storage/assets/s3.d.ts

@@ -0,0 +1,125 @@
+import { Construct } from "constructs";
+import * as s3 from "..";
+import * as cdk from "../../..";
+import * as kms from "../../encryption";
+import * as iam from "../../iam";
+export interface AssetOptions extends cdk.FileCopyOptions, cdk.AssetOptions {
+    /**
+     * A list of principals that should be able to read this asset from S3.
+     * You can use `asset.grantRead(principal)` to grant read permissions later.
+     *
+     * @default - No principals that can read file asset.
+     */
+    readonly readers?: iam.IGrantable[];
+    /**
+     * Custom hash to use when identifying the specific version of the asset. For consistency,
+     * this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be
+     * the asset hash.
+     *
+     * NOTE: the source hash is used in order to identify a specific revision of the asset,
+     * and used for optimizing and caching deployment activities related to this asset such as
+     * packaging, uploading to Amazon S3, etc. If you chose to customize the source hash,
+     * you will need to make sure it is updated every time the source changes, or otherwise
+     * it is possible that some deployments will not be invalidated.
+     *
+     * @default - automatically calculate source hash based on the contents
+     * of the source file or directory.
+     *
+     * @deprecated see `assetHash` and `assetHashType`
+     */
+    readonly sourceHash?: string;
+    /**
+     * Whether or not the asset needs to exist beyond deployment time; i.e.
+     * are copied over to a different location and not needed afterwards.
+     * Setting this property to true has an impact on the lifecycle of the asset,
+     * because we will assume that it is safe to delete after the CloudFormation
+     * deployment succeeds.
+     *
+     * For example, Lambda Function assets are copied over to Lambda during
+     * deployment. Therefore, it is not necessary to store the asset in S3, so
+     * we consider those deployTime assets.
+     *
+     * @default false
+     */
+    readonly deployTime?: boolean;
+    /**
+     * The ARN of the KMS key used to encrypt the handler code.
+     * @default - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.
+     */
+    readonly sourceKMSKey?: kms.IKey;
+}
+export interface AssetProps extends AssetOptions {
+    /**
+     * The disk location of the asset.
+     *
+     * The path should refer to one of the following:
+     * - A regular file or a .zip file, in which case the file will be uploaded as-is to S3.
+     * - A directory, in which case it will be archived into a .zip file and uploaded to S3.
+     */
+    readonly path: string;
+}
+/**
+ * An asset represents a local file or directory, which is automatically uploaded to S3
+ * and then can be referenced within a CDK application.
+ *
+ * WARNING: `FileAsset[0-9]*` and `FileAsset_S3[0-9]*` identifiers are used internally
+ * by the Stack Asset Manager and will cause Id conflicts.
+ */
+export declare class Asset extends Construct implements cdk.IAsset {
+    /**
+     * Attribute that represents the name of the bucket this asset exists in.
+     */
+    readonly s3BucketName: string;
+    /**
+     * Attribute which represents the S3 object key of this asset.
+     */
+    readonly s3ObjectKey: string;
+    /**
+     * Attribute which represents the S3 URL of this asset.
+     * @deprecated use `httpUrl`
+     */
+    readonly s3Url: string;
+    /**
+     * Attribute which represents the S3 HTTP URL of this asset.
+     * For example, `https://s3.us-west-1.amazonaws.com/bucket/key`
+     */
+    readonly httpUrl: string;
+    /**
+     * Attribute which represents the S3 URL of this asset.
+     * For example, `s3://bucket/key`
+     */
+    readonly s3ObjectUrl: string;
+    /**
+     * The path to the asset, relative to the current Cloud Assembly
+     *
+     * If asset staging is disabled, this will just be the original path.
+     * If asset staging is enabled it will be the staged path.
+     */
+    readonly assetPath: string;
+    /**
+     * The S3 bucket in which this asset resides.
+     */
+    readonly bucket: s3.IBucket;
+    /**
+     * Indicates if this asset is a single file. Allows constructs to ensure that the
+     * correct file type was used.
+     */
+    readonly isFile: boolean;
+    /**
+     * Indicates if this asset is a zip archive. Allows constructs to ensure that the
+     * correct file type was used.
+     */
+    readonly isZipArchive: boolean;
+    /**
+     * A cryptographic hash of the asset.
+     *
+     * @deprecated see `assetHash`
+     */
+    readonly sourceHash: string;
+    readonly assetHash: string;
+    constructor(scope: Construct, id: string, props: AssetProps);
+    /**
+     * Grants read permissions to the principal on the assets bucket.
+     */
+    grantRead(grantee: iam.IGrantable): void;
+}

package/lib/aws/storage/assets/s3.js

@@ -0,0 +1,80 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asset = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-s3-assets/lib/asset.ts
+const path = require("path");
+const constructs_1 = require("constructs");
+const s3 = require("..");
+const cdk = require("../../..");
+const aws_stack_1 = require("../../aws-stack");
+const kms = require("../../encryption");
+/**
+ * An asset represents a local file or directory, which is automatically uploaded to S3
+ * and then can be referenced within a CDK application.
+ *
+ * WARNING: `FileAsset[0-9]*` and `FileAsset_S3[0-9]*` identifiers are used internally
+ * by the Stack Asset Manager and will cause Id conflicts.
+ */
+class Asset extends constructs_1.Construct {
+    // /**
+    //  * Indicates if this asset got bundled before staged, or not.
+    //  */
+    // private readonly isBundled: boolean; // TODO: only needed for AWS CDK's addResourceMetadata()
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (!props.path) {
+            // throw new ValidationError("Asset path cannot be empty", this);
+            throw new Error("Asset path cannot be empty");
+        }
+        // this.isBundled = props.bundling != null;
+        // stage the asset source (conditionally).
+        const staging = new cdk.AssetStaging(this, "Stage", {
+            ...props,
+            sourcePath: path.resolve(props.path),
+            follow: props.followSymlinks,
+            assetHash: props.assetHash ?? props.sourceHash,
+        });
+        this.assetHash = staging.assetHash;
+        this.sourceHash = this.assetHash;
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        this.assetPath = staging.relativeStagedPath(stack);
+        this.isFile = staging.packaging === cdk.FileAssetPackaging.FILE;
+        this.isZipArchive = staging.isArchive;
+        const location = stack.addFileAsset({
+            packaging: staging.packaging,
+            sourceHash: staging.assetHash,
+            fileName: this.assetPath,
+            deployTime: props.deployTime,
+        });
+        this.s3BucketName = location.bucketName;
+        this.s3ObjectKey = location.objectKey;
+        this.s3ObjectUrl = location.s3ObjectUrl;
+        this.httpUrl = location.httpUrl;
+        this.s3Url = location.httpUrl; // for backwards compatibility
+        const kmsKey = location.kmsKeyArn
+            ? kms.Key.fromKeyArn(this, "Key", location.kmsKeyArn)
+            : undefined;
+        this.bucket = s3.Bucket.fromBucketAttributes(this, "AssetBucket", {
+            bucketName: this.s3BucketName,
+            encryptionKey: kmsKey,
+        });
+        for (const reader of props.readers ?? []) {
+            this.grantRead(reader);
+        }
+    }
+    /**
+     * Grants read permissions to the principal on the assets bucket.
+     */
+    grantRead(grantee) {
+        // we give permissions on all files in the bucket since we don't want to
+        // accidentally revoke permission on old versions when deploying a new
+        // version (for example, when using Lambda traffic shifting).
+        this.bucket.grantRead(grantee);
+    }
+}
+exports.Asset = Asset;
+_a = JSII_RTTI_SYMBOL_1;
+Asset[_a] = { fqn: "terraconstructs.aws.storage.assets.Asset", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3.js","sourceRoot":"","sources":["../../../../src/aws/storage/assets/s3.ts"],"names":[],"mappings":";;;;;AAAA,+FAA+F;AAE/F,6BAA6B;AAC7B,2CAAuC;AACvC,yBAAyB;AACzB,gCAAgC;AAChC,+CAA2C;AAC3C,wCAAwC;AAgExC;;;;;;GAMG;AACH,MAAa,KAAM,SAAQ,sBAAS;IA+DlC,MAAM;IACN,gEAAgE;IAChE,MAAM;IACN,gGAAgG;IAEhG,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiB;QACzD,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAChB,iEAAiE;YACjE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,2CAA2C;QAE3C,0CAA0C;QAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE;YAClD,GAAG,KAAK;YACR,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;YACpC,MAAM,EAAE,KAAK,CAAC,cAAc;YAC5B,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,UAAU;SAC/C,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;QAEjC,MAAM,KAAK,GAAG,oBAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAE5C,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAEnD,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,KAAK,GAAG,CAAC,kBAAkB,CAAC,IAAI,CAAC;QAEhE,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC;QAEtC,MAAM,QAAQ,GAAG,KAAK,CAAC,YAAY,CAAC;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,UAAU,EAAE,OAAO,CAAC,SAAS;YAC7B,QAAQ,EAAE,IAAI,CAAC,SAAS;YACxB,UAAU,EAAE,KAAK,CAAC,UAAU;SAC7B,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,8BAA8B;QAE7D,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS;YAC/B,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;YACrD,CAAC,CAAC,SAAS,CAAC;QAEd,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE;YAChE,UAAU,EAAE,IAAI,CAAC,YAAY;YAC7B,aAAa,EAAE,MAAM;SACtB,CAAC,CAAC;QAEH,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;YACzC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,OAAuB;QACtC,wEAAwE;QACxE,sEAAsE;QACtE,6DAA6D;QAC7D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;;AAnIH,sBAoIC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-s3-assets/lib/asset.ts\n\nimport * as path from \"path\";\nimport { Construct } from \"constructs\";\nimport * as s3 from \"..\";\nimport * as cdk from \"../../..\";\nimport { AwsStack } from \"../../aws-stack\";\nimport * as kms from \"../../encryption\";\nimport * as iam from \"../../iam\";\n\n// import { ValidationError } from \"../../core/lib/errors\";\n\nexport interface AssetOptions extends cdk.FileCopyOptions, cdk.AssetOptions {\n  /**\n   * A list of principals that should be able to read this asset from S3.\n   * You can use `asset.grantRead(principal)` to grant read permissions later.\n   *\n   * @default - No principals that can read file asset.\n   */\n  readonly readers?: iam.IGrantable[];\n\n  /**\n   * Custom hash to use when identifying the specific version of the asset. For consistency,\n   * this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be\n   * the asset hash.\n   *\n   * NOTE: the source hash is used in order to identify a specific revision of the asset,\n   * and used for optimizing and caching deployment activities related to this asset such as\n   * packaging, uploading to Amazon S3, etc. If you chose to customize the source hash,\n   * you will need to make sure it is updated every time the source changes, or otherwise\n   * it is possible that some deployments will not be invalidated.\n   *\n   * @default - automatically calculate source hash based on the contents\n   * of the source file or directory.\n   *\n   * @deprecated see `assetHash` and `assetHashType`\n   */\n  readonly sourceHash?: string;\n\n  /**\n   * Whether or not the asset needs to exist beyond deployment time; i.e.\n   * are copied over to a different location and not needed afterwards.\n   * Setting this property to true has an impact on the lifecycle of the asset,\n   * because we will assume that it is safe to delete after the CloudFormation\n   * deployment succeeds.\n   *\n   * For example, Lambda Function assets are copied over to Lambda during\n   * deployment. Therefore, it is not necessary to store the asset in S3, so\n   * we consider those deployTime assets.\n   *\n   * @default false\n   */\n  readonly deployTime?: boolean;\n  /**\n   * The ARN of the KMS key used to encrypt the handler code.\n   * @default - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.\n   */\n  readonly sourceKMSKey?: kms.IKey;\n}\n\nexport interface AssetProps extends AssetOptions {\n  /**\n   * The disk location of the asset.\n   *\n   * The path should refer to one of the following:\n   * - A regular file or a .zip file, in which case the file will be uploaded as-is to S3.\n   * - A directory, in which case it will be archived into a .zip file and uploaded to S3.\n   */\n  readonly path: string;\n}\n\n/**\n * An asset represents a local file or directory, which is automatically uploaded to S3\n * and then can be referenced within a CDK application.\n *\n * WARNING: `FileAsset[0-9]*` and `FileAsset_S3[0-9]*` identifiers are used internally\n * by the Stack Asset Manager and will cause Id conflicts.\n */\nexport class Asset extends Construct implements cdk.IAsset {\n  /**\n   * Attribute that represents the name of the bucket this asset exists in.\n   */\n  public readonly s3BucketName: string;\n\n  /**\n   * Attribute which represents the S3 object key of this asset.\n   */\n  public readonly s3ObjectKey: string;\n\n  /**\n   * Attribute which represents the S3 URL of this asset.\n   * @deprecated use `httpUrl`\n   */\n  public readonly s3Url: string;\n\n  /**\n   * Attribute which represents the S3 HTTP URL of this asset.\n   * For example, `https://s3.us-west-1.amazonaws.com/bucket/key`\n   */\n  public readonly httpUrl: string;\n\n  /**\n   * Attribute which represents the S3 URL of this asset.\n   * For example, `s3://bucket/key`\n   */\n  public readonly s3ObjectUrl: string;\n\n  /**\n   * The path to the asset, relative to the current Cloud Assembly\n   *\n   * If asset staging is disabled, this will just be the original path.\n   * If asset staging is enabled it will be the staged path.\n   */\n  public readonly assetPath: string;\n\n  /**\n   * The S3 bucket in which this asset resides.\n   */\n  public readonly bucket: s3.IBucket;\n\n  /**\n   * Indicates if this asset is a single file. Allows constructs to ensure that the\n   * correct file type was used.\n   */\n  public readonly isFile: boolean;\n\n  /**\n   * Indicates if this asset is a zip archive. Allows constructs to ensure that the\n   * correct file type was used.\n   */\n  public readonly isZipArchive: boolean;\n\n  /**\n   * A cryptographic hash of the asset.\n   *\n   * @deprecated see `assetHash`\n   */\n  public readonly sourceHash: string;\n\n  public readonly assetHash: string;\n\n  // /**\n  //  * Indicates if this asset got bundled before staged, or not.\n  //  */\n  // private readonly isBundled: boolean; // TODO: only needed for AWS CDK's addResourceMetadata()\n\n  constructor(scope: Construct, id: string, props: AssetProps) {\n    super(scope, id);\n\n    if (!props.path) {\n      // throw new ValidationError(\"Asset path cannot be empty\", this);\n      throw new Error(\"Asset path cannot be empty\");\n    }\n\n    // this.isBundled = props.bundling != null;\n\n    // stage the asset source (conditionally).\n    const staging = new cdk.AssetStaging(this, \"Stage\", {\n      ...props,\n      sourcePath: path.resolve(props.path),\n      follow: props.followSymlinks,\n      assetHash: props.assetHash ?? props.sourceHash,\n    });\n\n    this.assetHash = staging.assetHash;\n    this.sourceHash = this.assetHash;\n\n    const stack = AwsStack.ofAwsConstruct(this);\n\n    this.assetPath = staging.relativeStagedPath(stack);\n\n    this.isFile = staging.packaging === cdk.FileAssetPackaging.FILE;\n\n    this.isZipArchive = staging.isArchive;\n\n    const location = stack.addFileAsset({\n      packaging: staging.packaging,\n      sourceHash: staging.assetHash,\n      fileName: this.assetPath,\n      deployTime: props.deployTime,\n    });\n    this.s3BucketName = location.bucketName;\n    this.s3ObjectKey = location.objectKey;\n    this.s3ObjectUrl = location.s3ObjectUrl;\n    this.httpUrl = location.httpUrl;\n    this.s3Url = location.httpUrl; // for backwards compatibility\n\n    const kmsKey = location.kmsKeyArn\n      ? kms.Key.fromKeyArn(this, \"Key\", location.kmsKeyArn)\n      : undefined;\n\n    this.bucket = s3.Bucket.fromBucketAttributes(this, \"AssetBucket\", {\n      bucketName: this.s3BucketName,\n      encryptionKey: kmsKey,\n    });\n\n    for (const reader of props.readers ?? []) {\n      this.grantRead(reader);\n    }\n  }\n\n  /**\n   * Grants read permissions to the principal on the assets bucket.\n   */\n  public grantRead(grantee: iam.IGrantable) {\n    // we give permissions on all files in the bucket since we don't want to\n    // accidentally revoke permission on old versions when deploying a new\n    // version (for example, when using Lambda traffic shifting).\n    this.bucket.grantRead(grantee);\n  }\n}\n"]}

package/lib/aws/storage/auth-token.d.ts

@@ -0,0 +1,25 @@
+import * as iam from "../iam";
+/**
+ * Authorization token to access private ECR repositories in the current environment via Docker CLI.
+ *
+ * @see https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry_auth.html
+ */
+export declare class AuthorizationToken {
+    /**
+     * Grant access to retrieve an authorization token.
+     */
+    static grantRead(grantee: iam.IGrantable): void;
+    private constructor();
+}
+/**
+ * Authorization token to access the global public ECR Gallery via Docker CLI.
+ *
+ * @see https://docs.aws.amazon.com/AmazonECR/latest/public/public-registries.html#public-registry-auth
+ */
+export declare class PublicGalleryAuthorizationToken {
+    /**
+     * Grant access to retrieve an authorization token.
+     */
+    static grantRead(grantee: iam.IGrantable): void;
+    private constructor();
+}