terraconstructs 0.0.24 → 0.1.0

package/lib/bundling.js

@@ -0,0 +1,368 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerVolumeConsistency = exports.DockerImage = exports.BundlingDockerImage = exports.BundlingFileAccess = exports.BundlingOutput = exports.DockerBuildSecret = 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/core/lib/bundling.ts
+const child_process_1 = require("child_process");
+const crypto = require("crypto");
+const path_1 = require("path");
+const fs_1 = require("./fs");
+// TODO: Replace with @cdktf/provider-docker?
+const asset_staging_1 = require("./private/asset-staging");
+const jsii_deprecated_1 = require("./private/jsii-deprecated");
+/**
+ * Methods to build Docker CLI arguments for builds using secrets.
+ *
+ * Docker BuildKit must be enabled to use build secrets.
+ *
+ * @see https://docs.docker.com/build/buildkit/
+ */
+class DockerBuildSecret {
+    /**
+     * A Docker build secret from a file source
+     * @param src The path to the source file, relative to the build directory.
+     * @returns The latter half required for `--secret`
+     */
+    static fromSrc(src) {
+        return `src=${src}`;
+    }
+}
+exports.DockerBuildSecret = DockerBuildSecret;
+_a = JSII_RTTI_SYMBOL_1;
+DockerBuildSecret[_a] = { fqn: "terraconstructs.DockerBuildSecret", version: "0.1.0" };
+/**
+ * The type of output that a bundling operation is producing.
+ *
+ */
+var BundlingOutput;
+(function (BundlingOutput) {
+    /**
+     * The bundling output directory includes a single .zip or .jar file which
+     * will be used as the final bundle. If the output directory does not
+     * include exactly a single archive, bundling will fail.
+     */
+    BundlingOutput["ARCHIVED"] = "archived";
+    /**
+     * The bundling output directory contains one or more files which will be
+     * archived and uploaded as a .zip file to S3.
+     */
+    BundlingOutput["NOT_ARCHIVED"] = "not-archived";
+    /**
+     * If the bundling output directory contains a single archive file (zip or jar)
+     * it will be used as the bundle output as-is. Otherwise, all the files in the bundling output directory will be zipped.
+     */
+    BundlingOutput["AUTO_DISCOVER"] = "auto-discover";
+    /**
+     * The bundling output directory includes a single file which
+     * will be used as the final bundle. If the output directory does not
+     * include exactly a single file, bundling will fail.
+     *
+     * Similar to ARCHIVED but for non-archive files
+     */
+    BundlingOutput["SINGLE_FILE"] = "single-file";
+})(BundlingOutput || (exports.BundlingOutput = BundlingOutput = {}));
+/**
+ * The access mechanism used to make source files available to the bundling container and to return the bundling output back to the host
+ */
+var BundlingFileAccess;
+(function (BundlingFileAccess) {
+    /**
+     * Creates temporary volumes and containers to copy files from the host to the bundling container and back.
+     * This is slower, but works also in more complex situations with remote or shared docker sockets.
+     */
+    BundlingFileAccess["VOLUME_COPY"] = "VOLUME_COPY";
+    /**
+     * The source and output folders will be mounted as bind mount from the host system
+     * This is faster and simpler, but less portable than `VOLUME_COPY`.
+     */
+    BundlingFileAccess["BIND_MOUNT"] = "BIND_MOUNT";
+})(BundlingFileAccess || (exports.BundlingFileAccess = BundlingFileAccess = {}));
+/**
+ * A Docker image used for asset bundling
+ *
+ * @deprecated use DockerImage
+ */
+class BundlingDockerImage {
+    /**
+     * Reference an image on DockerHub or another online registry.
+     *
+     * @param image the image name
+     */
+    static fromRegistry(image) {
+        return new DockerImage(image);
+    }
+    /**
+     * Reference an image that's built directly from sources on disk.
+     *
+     * @param path The path to the directory containing the Docker file
+     * @param options Docker build options
+     *
+     * @deprecated use DockerImage.fromBuild()
+     */
+    static fromAsset(path, options = {}) {
+        return DockerImage.fromBuild(path, options);
+    }
+    /** @param image The Docker image */
+    constructor(image, _imageHash) {
+        this.image = image;
+        this._imageHash = _imageHash;
+    }
+    /**
+     * Provides a stable representation of this image for JSON serialization.
+     *
+     * @return The overridden image name if set or image hash name in that order
+     */
+    toJSON() {
+        return this._imageHash ?? this.image;
+    }
+    /**
+     * Runs a Docker image
+     */
+    run(options = {}) {
+        const volumes = options.volumes || [];
+        const environment = options.environment || {};
+        const entrypoint = options.entrypoint?.[0] || null;
+        const command = [
+            ...(options.entrypoint?.[1] ? [...options.entrypoint.slice(1)] : []),
+            ...(options.command ? [...options.command] : []),
+        ];
+        const dockerArgs = [
+            "run",
+            "--rm",
+            ...(options.securityOpt ? ["--security-opt", options.securityOpt] : []),
+            ...(options.network ? ["--network", options.network] : []),
+            ...(options.platform ? ["--platform", options.platform] : []),
+            ...(options.user ? ["-u", options.user] : []),
+            ...(options.volumesFrom
+                ? flatten(options.volumesFrom.map((v) => ["--volumes-from", v]))
+                : []),
+            ...flatten(volumes.map((v) => [
+                "-v",
+                `${v.hostPath}:${v.containerPath}:${isSeLinux() ? "z," : ""}${v.consistency ?? DockerVolumeConsistency.DELEGATED}`,
+            ])),
+            ...flatten(Object.entries(environment).map(([k, v]) => ["--env", `${k}=${v}`])),
+            ...(options.workingDirectory ? ["-w", options.workingDirectory] : []),
+            ...(entrypoint ? ["--entrypoint", entrypoint] : []),
+            this.image,
+            ...command,
+        ];
+        (0, asset_staging_1.dockerExec)(dockerArgs);
+    }
+    /**
+     * Copies a file or directory out of the Docker image to the local filesystem.
+     *
+     * If `outputPath` is omitted the destination path is a temporary directory.
+     *
+     * @param imagePath the path in the Docker image
+     * @param outputPath the destination path for the copy operation
+     * @returns the destination path
+     */
+    cp(imagePath, outputPath) {
+        const { stdout } = (0, asset_staging_1.dockerExec)(["create", this.image], {}); // Empty options to avoid stdout redirect here
+        const match = stdout.toString().match(/([0-9a-f]{16,})/);
+        if (!match) {
+            throw new Error("Failed to extract container ID from Docker create output");
+        }
+        const containerId = match[1];
+        const containerPath = `${containerId}:${imagePath}`;
+        const destPath = outputPath ?? fs_1.FileSystem.mkdtemp("tcons-docker-cp-");
+        try {
+            (0, asset_staging_1.dockerExec)(["cp", containerPath, destPath]);
+            return destPath;
+        }
+        catch (err) {
+            throw new Error(`Failed to copy files from ${containerPath} to ${destPath}: ${err}`);
+        }
+        finally {
+            (0, asset_staging_1.dockerExec)(["rm", "-v", containerId]);
+        }
+    }
+}
+exports.BundlingDockerImage = BundlingDockerImage;
+_b = JSII_RTTI_SYMBOL_1;
+BundlingDockerImage[_b] = { fqn: "terraconstructs.BundlingDockerImage", version: "0.1.0" };
+/**
+ * A Docker image
+ */
+class DockerImage extends BundlingDockerImage {
+    /**
+     * Builds a Docker image
+     *
+     * @param path The path to the directory containing the Docker file
+     * @param options Docker build options
+     */
+    static fromBuild(path, options = {}) {
+        const buildArgs = options.buildArgs || {};
+        if (options.file && (0, path_1.isAbsolute)(options.file)) {
+            throw new Error(`"file" must be relative to the docker build directory. Got ${options.file}`);
+        }
+        // Image tag derived from path and build options
+        const input = JSON.stringify({ path, ...options });
+        const tagHash = crypto.createHash("sha256").update(input).digest("hex");
+        const tag = `tcons-${tagHash}`;
+        const dockerArgs = [
+            "build",
+            "-t",
+            tag,
+            ...(options.file ? ["-f", (0, path_1.join)(path, options.file)] : []),
+            ...(options.platform ? ["--platform", options.platform] : []),
+            ...(options.targetStage ? ["--target", options.targetStage] : []),
+            ...(options.cacheFrom
+                ? [
+                    ...options.cacheFrom
+                        .map((cacheFrom) => [
+                        "--cache-from",
+                        this.cacheOptionToFlag(cacheFrom),
+                    ])
+                        .flat(),
+                ]
+                : []),
+            ...(options.cacheTo
+                ? ["--cache-to", this.cacheOptionToFlag(options.cacheTo)]
+                : []),
+            ...(options.cacheDisabled ? ["--no-cache"] : []),
+            ...flatten(Object.entries(buildArgs).map(([k, v]) => ["--build-arg", `${k}=${v}`])),
+            path,
+        ];
+        (0, asset_staging_1.dockerExec)(dockerArgs);
+        // Fingerprints the directory containing the Dockerfile we're building and
+        // differentiates the fingerprint based on build arguments. We do this so
+        // we can provide a stable image hash. Otherwise, the image ID will be
+        // different every time the Docker layer cache is cleared, due primarily to
+        // timestamps.
+        const hash = fs_1.FileSystem.fingerprint(path, {
+            extraHash: JSON.stringify(options),
+        });
+        return new DockerImage(tag, hash);
+    }
+    /**
+     * Reference an image on DockerHub or another online registry.
+     *
+     * @param image the image name
+     */
+    static fromRegistry(image) {
+        return new DockerImage(image);
+    }
+    static cacheOptionToFlag(option) {
+        let flag = `type=${option.type}`;
+        if (option.params) {
+            flag +=
+                "," +
+                    Object.entries(option.params)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(",");
+        }
+        return flag;
+    }
+    constructor(image, _imageHash) {
+        // It is preferable for the deprecated class to inherit a non-deprecated class.
+        // However, in this case, the opposite has occurred which is incompatible with
+        // a deprecation feature. See https://github.com/aws/jsii/issues/3102.
+        const deprecated = (0, jsii_deprecated_1.quiet)();
+        super(image, _imageHash);
+        (0, jsii_deprecated_1.reset)(deprecated);
+        this.image = image;
+    }
+    /**
+     * Provides a stable representation of this image for JSON serialization.
+     *
+     * @return The overridden image name if set or image hash name in that order
+     */
+    toJSON() {
+        // It is preferable for the deprecated class to inherit a non-deprecated class.
+        // However, in this case, the opposite has occurred which is incompatible with
+        // a deprecation feature. See https://github.com/aws/jsii/issues/3102.
+        const deprecated = (0, jsii_deprecated_1.quiet)();
+        const json = super.toJSON();
+        (0, jsii_deprecated_1.reset)(deprecated);
+        return json;
+    }
+    /**
+     * Runs a Docker image
+     */
+    run(options = {}) {
+        // It is preferable for the deprecated class to inherit a non-deprecated class.
+        // However, in this case, the opposite has occurred which is incompatible with
+        // a deprecation feature. See https://github.com/aws/jsii/issues/3102.
+        const deprecated = (0, jsii_deprecated_1.quiet)();
+        const result = super.run(options);
+        (0, jsii_deprecated_1.reset)(deprecated);
+        return result;
+    }
+    /**
+     * Copies a file or directory out of the Docker image to the local filesystem.
+     *
+     * If `outputPath` is omitted the destination path is a temporary directory.
+     *
+     * @param imagePath the path in the Docker image
+     * @param outputPath the destination path for the copy operation
+     * @returns the destination path
+     */
+    cp(imagePath, outputPath) {
+        // It is preferable for the deprecated class to inherit a non-deprecated class.
+        // However, in this case, the opposite has occurred which is incompatible with
+        // a deprecation feature. See https://github.com/aws/jsii/issues/3102.
+        const deprecated = (0, jsii_deprecated_1.quiet)();
+        const result = super.cp(imagePath, outputPath);
+        (0, jsii_deprecated_1.reset)(deprecated);
+        return result;
+    }
+}
+exports.DockerImage = DockerImage;
+_c = JSII_RTTI_SYMBOL_1;
+DockerImage[_c] = { fqn: "terraconstructs.DockerImage", version: "0.1.0" };
+/**
+ * Supported Docker volume consistency types. Only valid on macOS due to the way file storage works on Mac
+ */
+var DockerVolumeConsistency;
+(function (DockerVolumeConsistency) {
+    /**
+     * Read/write operations inside the Docker container are applied immediately on the mounted host machine volumes
+     */
+    DockerVolumeConsistency["CONSISTENT"] = "consistent";
+    /**
+     * Read/write operations on mounted Docker volumes are first written inside the container and then synchronized to the host machine
+     */
+    DockerVolumeConsistency["DELEGATED"] = "delegated";
+    /**
+     * Read/write operations on mounted Docker volumes are first applied on the host machine and then synchronized to the container
+     */
+    DockerVolumeConsistency["CACHED"] = "cached";
+})(DockerVolumeConsistency || (exports.DockerVolumeConsistency = DockerVolumeConsistency = {}));
+function flatten(x) {
+    return Array.prototype.concat([], ...x);
+}
+function isSeLinux() {
+    if (process.platform != "linux") {
+        return false;
+    }
+    try {
+        const prog = "selinuxenabled";
+        const proc = (0, child_process_1.spawnSync)(prog, [], {
+            stdio: [
+                // show selinux status output
+                "pipe", // get value of stdio
+                process.stderr, // redirect stdout to stderr
+                "inherit", // inherit stderr
+            ],
+        });
+        if (proc.error) {
+            // selinuxenabled not a valid command, therefore not enabled
+            return false;
+        }
+        if (proc.status == 0) {
+            // selinux enabled
+            return true;
+        }
+        else {
+            // selinux not enabled
+            return false;
+        }
+    }
+    catch (e) {
+        // If anything goes wrong, assume SELinux is not enabled
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundling.js","sourceRoot":"","sources":["../src/bundling.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/bundling.ts\n\nimport { spawnSync } from \"child_process\";\nimport * as crypto from \"crypto\";\nimport { isAbsolute, join } from \"path\";\nimport { DockerCacheOption } from \"./assets\";\nimport { FileSystem } from \"./fs\";\n// TODO: Replace with @cdktf/provider-docker?\nimport { dockerExec } from \"./private/asset-staging\";\nimport { quiet, reset } from \"./private/jsii-deprecated\";\n\n/**\n * Methods to build Docker CLI arguments for builds using secrets.\n *\n * Docker BuildKit must be enabled to use build secrets.\n *\n * @see https://docs.docker.com/build/buildkit/\n */\nexport class DockerBuildSecret {\n  /**\n   * A Docker build secret from a file source\n   * @param src The path to the source file, relative to the build directory.\n   * @returns The latter half required for `--secret`\n   */\n  public static fromSrc(src: string): string {\n    return `src=${src}`;\n  }\n}\n\n/**\n * Bundling options\n *\n */\nexport interface BundlingOptions {\n  /**\n   * The Docker image where the command will run.\n   */\n  readonly image: DockerImage;\n\n  /**\n   * The entrypoint to run in the Docker container.\n   *\n   * Example value: `['/bin/sh', '-c']`\n   *\n   * @see https://docs.docker.com/engine/reference/builder/#entrypoint\n   *\n   * @default - run the entrypoint defined in the image\n   */\n  readonly entrypoint?: string[];\n\n  /**\n   * The command to run in the Docker container.\n   *\n   * Example value: `['npm', 'install']`\n   *\n   * @see https://docs.docker.com/engine/reference/run/\n   *\n   * @default - run the command defined in the image\n   */\n  readonly command?: string[];\n\n  /**\n   * Additional Docker volumes to mount.\n   *\n   * @default - no additional volumes are mounted\n   */\n  readonly volumes?: DockerVolume[];\n\n  /**\n   * Where to mount the specified volumes from\n   * @see https://docs.docker.com/engine/reference/commandline/run/#mount-volumes-from-container---volumes-from\n   * @default - no containers are specified to mount volumes from\n   */\n  readonly volumesFrom?: string[];\n\n  /**\n   * The environment variables to pass to the Docker container.\n   *\n   * @default - no environment variables.\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * Working directory inside the Docker container.\n   *\n   * @default /asset-input\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * The user to use when running the Docker container.\n   *\n   *   user | user:group | uid | uid:gid | user:gid | uid:group\n   *\n   * @see https://docs.docker.com/engine/reference/run/#user\n   *\n   * @default - uid:gid of the current user or 1000:1000 on Windows\n   */\n  readonly user?: string;\n\n  /**\n   * Local bundling provider.\n   *\n   * The provider implements a method `tryBundle()` which should return `true`\n   * if local bundling was performed. If `false` is returned, docker bundling\n   * will be done.\n   *\n   * @default - bundling will only be performed in a Docker container\n   *\n   */\n  readonly local?: ILocalBundling;\n\n  /**\n   * The type of output that this bundling operation is producing.\n   *\n   * @default BundlingOutput.AUTO_DISCOVER\n   *\n   */\n  readonly outputType?: BundlingOutput;\n\n  /**\n   * [Security configuration](https://docs.docker.com/engine/reference/run/#security-configuration)\n   * when running the docker container.\n   *\n   * @default - no security options\n   */\n  readonly securityOpt?: string;\n  /**\n   * Docker [Networking options](https://docs.docker.com/engine/reference/commandline/run/#connect-a-container-to-a-network---network)\n   *\n   * @default - no networking options\n   */\n  readonly network?: string;\n\n  /**\n   * The access mechanism used to make source files available to the bundling container and to return the bundling output back to the host.\n   * @default - BundlingFileAccess.BIND_MOUNT\n   */\n  readonly bundlingFileAccess?: BundlingFileAccess;\n\n  /**\n   * Platform to build for. _Requires Docker Buildx_.\n   *\n   * Specify this property to build images on a specific platform.\n   *\n   * @default - no platform specified (the current machine architecture will be used)\n   */\n  readonly platform?: string;\n}\n\n/**\n * The type of output that a bundling operation is producing.\n *\n */\nexport enum BundlingOutput {\n  /**\n   * The bundling output directory includes a single .zip or .jar file which\n   * will be used as the final bundle. If the output directory does not\n   * include exactly a single archive, bundling will fail.\n   */\n  ARCHIVED = \"archived\",\n\n  /**\n   * The bundling output directory contains one or more files which will be\n   * archived and uploaded as a .zip file to S3.\n   */\n  NOT_ARCHIVED = \"not-archived\",\n\n  /**\n   * If the bundling output directory contains a single archive file (zip or jar)\n   * it will be used as the bundle output as-is. Otherwise, all the files in the bundling output directory will be zipped.\n   */\n  AUTO_DISCOVER = \"auto-discover\",\n\n  /**\n   * The bundling output directory includes a single file which\n   * will be used as the final bundle. If the output directory does not\n   * include exactly a single file, bundling will fail.\n   *\n   * Similar to ARCHIVED but for non-archive files\n   */\n  SINGLE_FILE = \"single-file\",\n}\n\n/**\n * Local bundling\n *\n */\nexport interface ILocalBundling {\n  /**\n   * This method is called before attempting docker bundling to allow the\n   * bundler to be executed locally. If the local bundler exists, and bundling\n   * was performed locally, return `true`. Otherwise, return `false`.\n   *\n   * @param outputDir the directory where the bundled asset should be output\n   * @param options bundling options for this asset\n   */\n  tryBundle(outputDir: string, options: BundlingOptions): boolean;\n}\n\n/**\n * The access mechanism used to make source files available to the bundling container and to return the bundling output back to the host\n */\nexport enum BundlingFileAccess {\n  /**\n   * Creates temporary volumes and containers to copy files from the host to the bundling container and back.\n   * This is slower, but works also in more complex situations with remote or shared docker sockets.\n   */\n  VOLUME_COPY = \"VOLUME_COPY\",\n\n  /**\n   * The source and output folders will be mounted as bind mount from the host system\n   * This is faster and simpler, but less portable than `VOLUME_COPY`.\n   */\n  BIND_MOUNT = \"BIND_MOUNT\",\n}\n\n/**\n * A Docker image used for asset bundling\n *\n * @deprecated use DockerImage\n */\nexport class BundlingDockerImage {\n  /**\n   * Reference an image on DockerHub or another online registry.\n   *\n   * @param image the image name\n   */\n  public static fromRegistry(image: string) {\n    return new DockerImage(image);\n  }\n\n  /**\n   * Reference an image that's built directly from sources on disk.\n   *\n   * @param path The path to the directory containing the Docker file\n   * @param options Docker build options\n   *\n   * @deprecated use DockerImage.fromBuild()\n   */\n  public static fromAsset(\n    path: string,\n    options: DockerBuildOptions = {},\n  ): BundlingDockerImage {\n    return DockerImage.fromBuild(path, options);\n  }\n\n  /** @param image The Docker image */\n  protected constructor(\n    public readonly image: string,\n    private readonly _imageHash?: string,\n  ) {}\n\n  /**\n   * Provides a stable representation of this image for JSON serialization.\n   *\n   * @return The overridden image name if set or image hash name in that order\n   */\n  public toJSON() {\n    return this._imageHash ?? this.image;\n  }\n\n  /**\n   * Runs a Docker image\n   */\n  public run(options: DockerRunOptions = {}) {\n    const volumes = options.volumes || [];\n    const environment = options.environment || {};\n    const entrypoint = options.entrypoint?.[0] || null;\n    const command = [\n      ...(options.entrypoint?.[1] ? [...options.entrypoint.slice(1)] : []),\n      ...(options.command ? [...options.command] : []),\n    ];\n\n    const dockerArgs: string[] = [\n      \"run\",\n      \"--rm\",\n      ...(options.securityOpt ? [\"--security-opt\", options.securityOpt] : []),\n      ...(options.network ? [\"--network\", options.network] : []),\n      ...(options.platform ? [\"--platform\", options.platform] : []),\n      ...(options.user ? [\"-u\", options.user] : []),\n      ...(options.volumesFrom\n        ? flatten(options.volumesFrom.map((v) => [\"--volumes-from\", v]))\n        : []),\n      ...flatten(\n        volumes.map((v) => [\n          \"-v\",\n          `${v.hostPath}:${v.containerPath}:${isSeLinux() ? \"z,\" : \"\"}${v.consistency ?? DockerVolumeConsistency.DELEGATED}`,\n        ]),\n      ),\n      ...flatten(\n        Object.entries(environment).map(([k, v]) => [\"--env\", `${k}=${v}`]),\n      ),\n      ...(options.workingDirectory ? [\"-w\", options.workingDirectory] : []),\n      ...(entrypoint ? [\"--entrypoint\", entrypoint] : []),\n      this.image,\n      ...command,\n    ];\n\n    dockerExec(dockerArgs);\n  }\n\n  /**\n   * Copies a file or directory out of the Docker image to the local filesystem.\n   *\n   * If `outputPath` is omitted the destination path is a temporary directory.\n   *\n   * @param imagePath the path in the Docker image\n   * @param outputPath the destination path for the copy operation\n   * @returns the destination path\n   */\n  public cp(imagePath: string, outputPath?: string): string {\n    const { stdout } = dockerExec([\"create\", this.image], {}); // Empty options to avoid stdout redirect here\n    const match = stdout.toString().match(/([0-9a-f]{16,})/);\n    if (!match) {\n      throw new Error(\n        \"Failed to extract container ID from Docker create output\",\n      );\n    }\n\n    const containerId = match[1];\n    const containerPath = `${containerId}:${imagePath}`;\n    const destPath = outputPath ?? FileSystem.mkdtemp(\"tcons-docker-cp-\");\n    try {\n      dockerExec([\"cp\", containerPath, destPath]);\n      return destPath;\n    } catch (err) {\n      throw new Error(\n        `Failed to copy files from ${containerPath} to ${destPath}: ${err}`,\n      );\n    } finally {\n      dockerExec([\"rm\", \"-v\", containerId]);\n    }\n  }\n}\n\n/**\n * A Docker image\n */\nexport class DockerImage extends BundlingDockerImage {\n  /**\n   * Builds a Docker image\n   *\n   * @param path The path to the directory containing the Docker file\n   * @param options Docker build options\n   */\n  public static fromBuild(path: string, options: DockerBuildOptions = {}) {\n    const buildArgs = options.buildArgs || {};\n\n    if (options.file && isAbsolute(options.file)) {\n      throw new Error(\n        `\"file\" must be relative to the docker build directory. Got ${options.file}`,\n      );\n    }\n\n    // Image tag derived from path and build options\n    const input = JSON.stringify({ path, ...options });\n    const tagHash = crypto.createHash(\"sha256\").update(input).digest(\"hex\");\n    const tag = `tcons-${tagHash}`;\n\n    const dockerArgs: string[] = [\n      \"build\",\n      \"-t\",\n      tag,\n      ...(options.file ? [\"-f\", join(path, options.file)] : []),\n      ...(options.platform ? [\"--platform\", options.platform] : []),\n      ...(options.targetStage ? [\"--target\", options.targetStage] : []),\n      ...(options.cacheFrom\n        ? [\n            ...options.cacheFrom\n              .map((cacheFrom) => [\n                \"--cache-from\",\n                this.cacheOptionToFlag(cacheFrom),\n              ])\n              .flat(),\n          ]\n        : []),\n      ...(options.cacheTo\n        ? [\"--cache-to\", this.cacheOptionToFlag(options.cacheTo)]\n        : []),\n      ...(options.cacheDisabled ? [\"--no-cache\"] : []),\n      ...flatten(\n        Object.entries(buildArgs).map(([k, v]) => [\"--build-arg\", `${k}=${v}`]),\n      ),\n      path,\n    ];\n\n    dockerExec(dockerArgs);\n\n    // Fingerprints the directory containing the Dockerfile we're building and\n    // differentiates the fingerprint based on build arguments. We do this so\n    // we can provide a stable image hash. Otherwise, the image ID will be\n    // different every time the Docker layer cache is cleared, due primarily to\n    // timestamps.\n    const hash = FileSystem.fingerprint(path, {\n      extraHash: JSON.stringify(options),\n    });\n    return new DockerImage(tag, hash);\n  }\n\n  /**\n   * Reference an image on DockerHub or another online registry.\n   *\n   * @param image the image name\n   */\n  public static override fromRegistry(image: string) {\n    return new DockerImage(image);\n  }\n\n  private static cacheOptionToFlag(option: DockerCacheOption): string {\n    let flag = `type=${option.type}`;\n    if (option.params) {\n      flag +=\n        \",\" +\n        Object.entries(option.params)\n          .map(([k, v]) => `${k}=${v}`)\n          .join(\",\");\n    }\n    return flag;\n  }\n\n  /** The Docker image */\n  public readonly image: string;\n\n  constructor(image: string, _imageHash?: string) {\n    // It is preferable for the deprecated class to inherit a non-deprecated class.\n    // However, in this case, the opposite has occurred which is incompatible with\n    // a deprecation feature. See https://github.com/aws/jsii/issues/3102.\n    const deprecated = quiet();\n\n    super(image, _imageHash);\n\n    reset(deprecated);\n    this.image = image;\n  }\n\n  /**\n   * Provides a stable representation of this image for JSON serialization.\n   *\n   * @return The overridden image name if set or image hash name in that order\n   */\n  public toJSON() {\n    // It is preferable for the deprecated class to inherit a non-deprecated class.\n    // However, in this case, the opposite has occurred which is incompatible with\n    // a deprecation feature. See https://github.com/aws/jsii/issues/3102.\n    const deprecated = quiet();\n\n    const json = super.toJSON();\n\n    reset(deprecated);\n    return json;\n  }\n\n  /**\n   * Runs a Docker image\n   */\n  public run(options: DockerRunOptions = {}) {\n    // It is preferable for the deprecated class to inherit a non-deprecated class.\n    // However, in this case, the opposite has occurred which is incompatible with\n    // a deprecation feature. See https://github.com/aws/jsii/issues/3102.\n    const deprecated = quiet();\n\n    const result = super.run(options);\n\n    reset(deprecated);\n    return result;\n  }\n\n  /**\n   * Copies a file or directory out of the Docker image to the local filesystem.\n   *\n   * If `outputPath` is omitted the destination path is a temporary directory.\n   *\n   * @param imagePath the path in the Docker image\n   * @param outputPath the destination path for the copy operation\n   * @returns the destination path\n   */\n  public cp(imagePath: string, outputPath?: string): string {\n    // It is preferable for the deprecated class to inherit a non-deprecated class.\n    // However, in this case, the opposite has occurred which is incompatible with\n    // a deprecation feature. See https://github.com/aws/jsii/issues/3102.\n    const deprecated = quiet();\n\n    const result = super.cp(imagePath, outputPath);\n\n    reset(deprecated);\n    return result;\n  }\n}\n\n/**\n * A Docker volume\n */\nexport interface DockerVolume {\n  /**\n   * The path to the file or directory on the host machine\n   */\n  readonly hostPath: string;\n\n  /**\n   * The path where the file or directory is mounted in the container\n   */\n  readonly containerPath: string;\n\n  /**\n   * Mount consistency. Only applicable for macOS\n   *\n   * @default DockerConsistency.DELEGATED\n   * @see https://docs.docker.com/storage/bind-mounts/#configure-mount-consistency-for-macos\n   */\n  readonly consistency?: DockerVolumeConsistency;\n}\n\n/**\n * Supported Docker volume consistency types. Only valid on macOS due to the way file storage works on Mac\n */\nexport enum DockerVolumeConsistency {\n  /**\n   * Read/write operations inside the Docker container are applied immediately on the mounted host machine volumes\n   */\n  CONSISTENT = \"consistent\",\n  /**\n   * Read/write operations on mounted Docker volumes are first written inside the container and then synchronized to the host machine\n   */\n  DELEGATED = \"delegated\",\n  /**\n   * Read/write operations on mounted Docker volumes are first applied on the host machine and then synchronized to the container\n   */\n  CACHED = \"cached\",\n}\n\n/**\n * Docker run options\n */\nexport interface DockerRunOptions {\n  /**\n   * The entrypoint to run in the container.\n   *\n   * @default - run the entrypoint defined in the image\n   */\n  readonly entrypoint?: string[];\n\n  /**\n   * The command to run in the container.\n   *\n   * @default - run the command defined in the image\n   */\n  readonly command?: string[];\n\n  /**\n   * Docker volumes to mount.\n   *\n   * @default - no volumes are mounted\n   */\n  readonly volumes?: DockerVolume[];\n\n  /**\n   * Where to mount the specified volumes from\n   * @see https://docs.docker.com/engine/reference/commandline/run/#mount-volumes-from-container---volumes-from\n   * @default - no containers are specified to mount volumes from\n   */\n  readonly volumesFrom?: string[];\n\n  /**\n   * The environment variables to pass to the container.\n   *\n   * @default - no environment variables.\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * Working directory inside the container.\n   *\n   * @default - image default\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * The user to use when running the container.\n   *\n   * @default - root or image default\n   */\n  readonly user?: string;\n\n  /**\n   * [Security configuration](https://docs.docker.com/engine/reference/run/#security-configuration)\n   * when running the docker container.\n   *\n   * @default - no security options\n   */\n  readonly securityOpt?: string;\n\n  /**\n   * Docker [Networking options](https://docs.docker.com/engine/reference/commandline/run/#connect-a-container-to-a-network---network)\n   *\n   * @default - no networking options\n   */\n  readonly network?: string;\n\n  /**\n   * Set platform if server is multi-platform capable. _Requires Docker Engine API v1.38+_.\n   *\n   * Example value: `linux/amd64`\n   *\n   * @default - no platform specified\n   */\n  readonly platform?: string;\n}\n\n/**\n * Docker build options\n */\nexport interface DockerBuildOptions {\n  /**\n   * Build args\n   *\n   * @default - no build args\n   */\n  readonly buildArgs?: { [key: string]: string };\n\n  /**\n   * Name of the Dockerfile, must relative to the docker build path.\n   *\n   * @default `Dockerfile`\n   */\n  readonly file?: string;\n\n  /**\n   * Set platform if server is multi-platform capable. _Requires Docker Engine API v1.38+_.\n   *\n   * Example value: `linux/amd64`\n   *\n   * @default - no platform specified\n   */\n  readonly platform?: string;\n\n  /**\n   * Set build target for multi-stage container builds. Any stage defined afterwards will be ignored.\n   *\n   * Example value: `build-env`\n   *\n   * @default - Build all stages defined in the Dockerfile\n   */\n  readonly targetStage?: string;\n\n  /**\n   * Cache from options to pass to the `docker build` command.\n   *\n   * @default - no cache from args are passed\n   */\n  readonly cacheFrom?: DockerCacheOption[];\n\n  /**\n   * Cache to options to pass to the `docker build` command.\n   *\n   * @default - no cache to args are passed\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\nfunction flatten(x: string[][]) {\n  return Array.prototype.concat([], ...x);\n}\n\nfunction isSeLinux(): boolean {\n  if (process.platform != \"linux\") {\n    return false;\n  }\n  try {\n    const prog = \"selinuxenabled\";\n    const proc = spawnSync(prog, [], {\n      stdio: [\n        // show selinux status output\n        \"pipe\", // get value of stdio\n        process.stderr, // redirect stdout to stderr\n        \"inherit\", // inherit stderr\n      ],\n    });\n    if (proc.error) {\n      // selinuxenabled not a valid command, therefore not enabled\n      return false;\n    }\n    if (proc.status == 0) {\n      // selinux enabled\n      return true;\n    } else {\n      // selinux not enabled\n      return false;\n    }\n  } catch (e) {\n    // If anything goes wrong, assume SELinux is not enabled\n    return false;\n  }\n}\n"]}

package/lib/construct-base.js

@@ -27,7 +27,7 @@ class GridTags {
 }
 exports.GridTags = GridTags;
 _a = JSII_RTTI_SYMBOL_1;
-GridTags[_a] = { fqn: "terraconstructs.GridTags", version: "0.0.24" };
+GridTags[_a] = { fqn: "terraconstructs.GridTags", version: "0.1.0" };
 /**
  * Base class for all TerraConstructs
  *
@@ -88,5 +88,5 @@ class TerraConstructBase extends cdktf_1.TerraformElement {
 }
 exports.TerraConstructBase = TerraConstructBase;
 _b = JSII_RTTI_SYMBOL_1;
-TerraConstructBase[_b] = { fqn: "terraconstructs.TerraConstructBase", version: "0.0.24" };
+TerraConstructBase[_b] = { fqn: "terraconstructs.TerraConstructBase", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct-base.js","sourceRoot":"","sources":["../src/construct-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Lazy,\n  TerraformResource,\n  TerraformElement,\n  TerraformOutput,\n  TerraformMetaArguments,\n  Aspects,\n  IAspect,\n} from \"cdktf\";\nimport { Construct, IConstruct } from \"constructs\";\nimport { StackBase } from \"./stack-base\";\n\nexport interface TerraConstructProps extends TerraformMetaArguments {\n  /**\n   * The friendly name for TerraConstruct resources\n   *\n   * @default - `environmentName-id`\n   */\n  readonly friendlyName?: string;\n\n  /**\n   * Whether to register Terraform outputs for this TerraConstruct\n   *\n   * @default false\n   */\n  readonly registerOutputs?: boolean;\n\n  /**\n   * Optional override for the outputs name\n   *\n   * @default id\n   */\n  readonly outputName?: string;\n}\n\nexport interface ITerraConstruct extends IConstruct {\n  /**\n   * Environment Name passed in from the CLI\n   */\n  readonly environmentName: string;\n  readonly gridUUID: string;\n  readonly outputs: Record<string, any>;\n}\n\n// TODO: this is aws specific, should be moved to aws module\nexport type TaggableConstruct = TerraformResource & {\n  tags?: { [key: string]: string };\n  tagsInput?: { [key: string]: string };\n};\n\n// TODO: this is aws specific, should be moved to aws module\nexport function isTaggableTerraformResource(\n  x: IConstruct,\n): x is TaggableConstruct {\n  return (\n    TerraformResource.isTerraformResource(x) && \"tags\" in x && \"tagsInput\" in x\n  );\n}\n\nconst GRID_TAG_PREFIX = \"grid\";\n\n// Add Grid Tags to all TerraConstruct resources\nexport class GridTags implements IAspect {\n  constructor(private tagsToAdd: Record<string, string>) {}\n  visit(node: IConstruct) {\n    if (isTaggableTerraformResource(node)) {\n      // https://developer.hashicorp.com/terraform/cdktf/concepts/aspects\n      const currentTags = node.tagsInput || {};\n      // TODO: Bug - tagsToAdd are overwritten by currenTags\n      node.tags = { ...this.tagsToAdd, ...currentTags };\n    }\n  }\n}\n\n/**\n * Base class for all TerraConstructs\n *\n * Allows a TerraConstruct to lazily register its outputs with its parent Stack\n */\nexport abstract class TerraConstructBase\n  extends TerraformElement\n  implements ITerraConstruct\n{\n  /**\n   * Returns true if the construct was created by CDKTF, and false otherwise\n   */\n  public static isOwnedResource(construct: IConstruct): boolean {\n    return construct.node.defaultChild\n      ? TerraformResource.isTerraformResource(construct.node.defaultChild)\n      : false;\n  }\n\n  /**\n   * The name under which the outputs are registered in the parent Scope\n   */\n  public readonly outputName: string;\n\n  /**\n   * TerraConstruct friendly name\n   */\n  public readonly friendlyName: string;\n\n  /**\n   * TerraConstruct unique grid identifier\n   */\n  public get gridUUID(): string {\n    return StackBase.ofTerraConstruct(this).gridUUID;\n  }\n\n  /**\n   * Environment Name passed in from the CLI\n   */\n  public get environmentName(): string {\n    return StackBase.ofTerraConstruct(this).environmentName;\n  }\n\n  /**\n   * Outputs to register with the parent Scope or undefined if there are no outputs\n   */\n  public abstract get outputs(): Record<string, any>; // TODO: should be allowed to be undefined?\n\n  constructor(\n    scope: Construct,\n    private readonly constructId: string,\n    props: TerraConstructProps = {},\n  ) {\n    super(scope, constructId);\n    this.outputName = props.outputName || `${constructId}Outputs`;\n    this.friendlyName =\n      props.friendlyName || `${this.environmentName}-${constructId}`;\n\n    Aspects.of(this) // Add Grid tags to every resource defined within.\n      .add(\n        new GridTags({\n          [`${GRID_TAG_PREFIX}:EnvironmentName`]: this.environmentName,\n          [`${GRID_TAG_PREFIX}:UUID`]: this.gridUUID,\n          Name: this.friendlyName,\n        }),\n      );\n    const registerOutputs = props.registerOutputs || false;\n    if (registerOutputs) {\n      new TerraformOutput(scope, this.outputName, {\n        staticId: true,\n        description: `Outputs for ${this.friendlyName}`,\n        value: Lazy.anyValue({ produce: () => this.outputs || null }),\n      });\n    }\n  }\n\n  // force usage of node.addDependency instead of passing TerraConstructs via dependsOn\n  // Referring a TerraConstruct by fqn always triggers an error?\n  public get fqn(): string {\n    // try {\n    //   return super.fqn;\n    // } catch (e) {\n    // ref: https://github.com/aws/constructs/blob/10.x/src/construct.ts#L345\n    throw new Error(\n      `Use Construct node.addDependency instead of passing TerraConstruct fqn ${this.constructor.name} ${this.constructId}`,\n    );\n    // }\n  }\n}\n"]}

package/lib/duration.js

@@ -283,7 +283,7 @@ class Duration {
 }
 exports.Duration = Duration;
 _a = JSII_RTTI_SYMBOL_1;
-Duration[_a] = { fqn: "terraconstructs.Duration", version: "0.0.24" };
+Duration[_a] = { fqn: "terraconstructs.Duration", version: "0.1.0" };
 class TimeUnit {
     constructor(label, isoLabel, inMillis) {
         this.label = label;

package/lib/expiration.js

@@ -64,5 +64,5 @@ class Expiration {
 }
 exports.Expiration = Expiration;
 _a = JSII_RTTI_SYMBOL_1;
-Expiration[_a] = { fqn: "terraconstructs.Expiration", version: "0.0.24" };
+Expiration[_a] = { fqn: "terraconstructs.Expiration", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/fs/copy.d.ts

@@ -0,0 +1,2 @@
+import { CopyOptions } from "./options";
+export declare function copyDirectory(srcDir: string, destDir: string, options?: CopyOptions, rootDir?: string): void;

package/lib/fs/copy.js

@@ -0,0 +1,57 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/fs/copy.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDirectory = copyDirectory;
+const fs = require("fs");
+const path = require("path");
+const ignore_1 = require("./ignore");
+const options_1 = require("./options");
+const utils_1 = require("./utils");
+function copyDirectory(srcDir, destDir, options = {}, rootDir) {
+    const follow = options.follow ?? options_1.SymlinkFollowMode.EXTERNAL;
+    rootDir = rootDir || srcDir;
+    // ensure the destination directory exists
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const ignoreStrategy = ignore_1.IgnoreStrategy.fromCopyOptions(options, rootDir);
+    if (!fs.statSync(srcDir).isDirectory()) {
+        throw new Error(`${srcDir} is not a directory`);
+    }
+    const files = fs.readdirSync(srcDir);
+    for (const file of files) {
+        let sourceFilePath = path.join(srcDir, file);
+        if (ignoreStrategy.ignores(sourceFilePath)) {
+            continue;
+        }
+        const destFilePath = path.join(destDir, file);
+        let stat = follow === options_1.SymlinkFollowMode.ALWAYS
+            ? fs.statSync(sourceFilePath)
+            : fs.lstatSync(sourceFilePath);
+        if (stat && stat.isSymbolicLink()) {
+            const target = fs.readlinkSync(sourceFilePath);
+            // determine if this is an external link (i.e. the target's absolute path
+            // is outside of the root directory).
+            const targetPath = path.normalize(path.resolve(srcDir, target));
+            if ((0, utils_1.shouldFollow)(follow, rootDir, targetPath)) {
+                stat = fs.statSync(targetPath);
+                // Update sourceFilePath to be the resolved target path
+                sourceFilePath = targetPath;
+            }
+            else {
+                fs.symlinkSync(target, destFilePath);
+                stat = undefined;
+            }
+        }
+        if (stat && stat.isDirectory()) {
+            fs.mkdirSync(destFilePath);
+            copyDirectory(sourceFilePath, destFilePath, options, rootDir);
+            stat = undefined;
+        }
+        if (stat && stat.isFile()) {
+            fs.copyFileSync(sourceFilePath, destFilePath);
+            stat = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/fs/fingerprint.d.ts

@@ -0,0 +1,21 @@
+import { FingerprintOptions } from "./options";
+/**
+ * Files are fingerprinted only the first time they are encountered, to save
+ * time hashing large files. This function clears this cache, should it be
+ * necessary for some reason.
+ */
+export declare function clearLargeFileFingerprintCache(): void;
+/**
+ * Produces fingerprint based on the contents of a single file or an entire directory tree.
+ *
+ * Line endings are converted from CRLF to LF.
+ *
+ * The fingerprint will also include:
+ * 1. An extra string if defined in `options.extra`.
+ * 2. The symlink follow mode value.
+ *
+ * @param fileOrDirectory The directory or file to fingerprint
+ * @param options Fingerprinting options
+ */
+export declare function fingerprint(fileOrDirectory: string, options?: FingerprintOptions): string;
+export declare function contentFingerprint(file: string): string;