terraconstructs 0.0.25 → 0.1.1

package/lib/fs/fingerprint.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLargeFileFingerprintCache = clearLargeFileFingerprintCache;
+exports.fingerprint = fingerprint;
+exports.contentFingerprint = contentFingerprint;
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const ignore_1 = require("./ignore");
+const options_1 = require("./options");
+const utils_1 = require("./utils");
+const cache_1 = require("../private/cache");
+const BUFFER_SIZE = 8 * 1024;
+const CTRL_SOH = "\x01";
+const CTRL_SOT = "\x02";
+const CTRL_ETX = "\x03";
+const CR = "\r";
+const LF = "\n";
+const CRLF = `${CR}${LF}`;
+const fingerprintCache = new cache_1.Cache();
+/**
+ * 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.
+ */
+function clearLargeFileFingerprintCache() {
+    fingerprintCache.clear();
+}
+/**
+ * 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
+ */
+function fingerprint(fileOrDirectory, options = {}) {
+    const hash = crypto.createHash("sha256");
+    _hashField(hash, "options.extra", options.extraHash || "");
+    const follow = options.follow || options_1.SymlinkFollowMode.EXTERNAL;
+    _hashField(hash, "options.follow", follow);
+    // Resolve symlinks in the initial path (for example, the root directory
+    // might be symlinked). It's important that we know the absolute path, so we
+    // can judge if further symlinks inside the target directory are within the
+    // target or not (if we don't resolve, we would test w.r.t. the wrong path).
+    fileOrDirectory = fs.realpathSync(fileOrDirectory);
+    const isDir = fs.statSync(fileOrDirectory).isDirectory();
+    const rootDirectory = isDir ? fileOrDirectory : path.dirname(fileOrDirectory);
+    const ignoreMode = options.ignoreMode || options_1.IgnoreMode.GLOB;
+    if (ignoreMode != options_1.IgnoreMode.GLOB) {
+        _hashField(hash, "options.ignoreMode", ignoreMode);
+    }
+    const ignoreStrategy = ignore_1.IgnoreStrategy.fromCopyOptions(options, fileOrDirectory);
+    _processFileOrDirectory(fileOrDirectory, isDir);
+    return hash.digest("hex");
+    function _processFileOrDirectory(symbolicPath, isRootDir = false, realPath = symbolicPath) {
+        if (!isRootDir && ignoreStrategy.ignores(symbolicPath)) {
+            return;
+        }
+        const stat = fs.lstatSync(realPath);
+        // Use relative path as hash component. Normalize it with forward slashes to ensure
+        // same hash on Windows and Linux.
+        const hashComponent = path
+            .relative(fileOrDirectory, symbolicPath)
+            .replace(/\\/g, "/");
+        if (stat.isSymbolicLink()) {
+            const linkTarget = fs.readlinkSync(realPath);
+            const resolvedLinkTarget = path.resolve(path.dirname(realPath), linkTarget);
+            if ((0, utils_1.shouldFollow)(follow, rootDirectory, resolvedLinkTarget)) {
+                _processFileOrDirectory(symbolicPath, false, resolvedLinkTarget);
+            }
+            else {
+                _hashField(hash, `link:${hashComponent}`, linkTarget);
+            }
+        }
+        else if (stat.isFile()) {
+            _hashField(hash, `file:${hashComponent}`, contentFingerprint(realPath));
+        }
+        else if (stat.isDirectory()) {
+            for (const item of fs.readdirSync(realPath).sort()) {
+                _processFileOrDirectory(path.join(symbolicPath, item), false, path.join(realPath, item));
+            }
+        }
+        else {
+            throw new Error(`Unable to hash ${symbolicPath}: it is neither a file nor a directory`);
+        }
+    }
+}
+function contentFingerprint(file) {
+    // On windows it's particularly important to pass bigint: true to ensure that
+    // floating-point inaccuracies don't result in false matches. ( see
+    // https://github.com/nodejs/node/issues/12115#issuecomment-438741212 )
+    //
+    // Note that even if we do get a inode collision somehow, it's unlikely that
+    // both mtime and size would have a false-positive as well.
+    // We also must suppress typescript typechecks as we are using a version of
+    // @types/node that only supports node 10 declarations.
+    const stats = fs.statSync(file, { bigint: true });
+    const cacheKey = JSON.stringify({
+        mtime_unix: stats.mtime.toUTCString(),
+        mtime_ms: stats.mtimeMs.toString(),
+        inode: stats.ino.toString(),
+        size: stats.size.toString(),
+    });
+    return fingerprintCache.obtain(cacheKey, () => contentFingerprintMiss(file));
+}
+function contentFingerprintMiss(file) {
+    const hash = crypto.createHash("sha256");
+    const buffer = Buffer.alloc(BUFFER_SIZE);
+    const fd = fs.openSync(file, 
+    // eslint-disable-next-line no-bitwise
+    fs.constants.O_DSYNC | fs.constants.O_RDONLY | fs.constants.O_SYNC);
+    let size = 0;
+    let isBinary = false;
+    let lastStr = "";
+    let read = 0;
+    try {
+        while ((read = fs.readSync(fd, buffer, 0, BUFFER_SIZE, null)) !== 0) {
+            const slicedBuffer = buffer.slice(0, read);
+            // Detect if file is binary by checking the first 8k bytes for the
+            // null character (git like implementation)
+            if (size === 0) {
+                isBinary = slicedBuffer.indexOf(0) !== -1;
+            }
+            let dataBuffer = slicedBuffer;
+            if (!isBinary) {
+                // Line endings normalization (CRLF -> LF)
+                const str = buffer.slice(0, read).toString();
+                // We are going to normalize line endings to LF. So if the current
+                // buffer ends with CR, it could be that the next one starts with
+                // LF so we need to save it for later use.
+                if (new RegExp(`${CR}$`).test(str)) {
+                    lastStr += str;
+                    continue;
+                }
+                const data = lastStr + str;
+                const normalizedData = data.replace(new RegExp(CRLF, "g"), LF);
+                dataBuffer = Buffer.from(normalizedData);
+                lastStr = "";
+            }
+            size += dataBuffer.length;
+            hash.update(dataBuffer);
+        }
+        if (lastStr) {
+            hash.update(Buffer.from(lastStr));
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return `${size}:${hash.digest("hex")}`;
+}
+function _hashField(hash, header, value) {
+    hash
+        .update(CTRL_SOH)
+        .update(header)
+        .update(CTRL_SOT)
+        .update(value)
+        .update(CTRL_ETX);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fingerprint.js","sourceRoot":"","sources":["../../src/fs/fingerprint.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from \"crypto\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { IgnoreStrategy } from \"./ignore\";\nimport { FingerprintOptions, IgnoreMode, SymlinkFollowMode } from \"./options\";\nimport { shouldFollow } from \"./utils\";\nimport { Cache } from \"../private/cache\";\n\nconst BUFFER_SIZE = 8 * 1024;\nconst CTRL_SOH = \"\\x01\";\nconst CTRL_SOT = \"\\x02\";\nconst CTRL_ETX = \"\\x03\";\nconst CR = \"\\r\";\nconst LF = \"\\n\";\nconst CRLF = `${CR}${LF}`;\n\nconst fingerprintCache = new Cache<string>();\n\n/**\n * Files are fingerprinted only the first time they are encountered, to save\n * time hashing large files. This function clears this cache, should it be\n * necessary for some reason.\n */\nexport function clearLargeFileFingerprintCache() {\n  fingerprintCache.clear();\n}\n\n/**\n * Produces fingerprint based on the contents of a single file or an entire directory tree.\n *\n * Line endings are converted from CRLF to LF.\n *\n * The fingerprint will also include:\n * 1. An extra string if defined in `options.extra`.\n * 2. The symlink follow mode value.\n *\n * @param fileOrDirectory The directory or file to fingerprint\n * @param options Fingerprinting options\n */\nexport function fingerprint(\n  fileOrDirectory: string,\n  options: FingerprintOptions = {},\n) {\n  const hash = crypto.createHash(\"sha256\");\n  _hashField(hash, \"options.extra\", options.extraHash || \"\");\n  const follow = options.follow || SymlinkFollowMode.EXTERNAL;\n  _hashField(hash, \"options.follow\", follow);\n\n  // Resolve symlinks in the initial path (for example, the root directory\n  // might be symlinked). It's important that we know the absolute path, so we\n  // can judge if further symlinks inside the target directory are within the\n  // target or not (if we don't resolve, we would test w.r.t. the wrong path).\n  fileOrDirectory = fs.realpathSync(fileOrDirectory);\n\n  const isDir = fs.statSync(fileOrDirectory).isDirectory();\n  const rootDirectory = isDir ? fileOrDirectory : path.dirname(fileOrDirectory);\n\n  const ignoreMode = options.ignoreMode || IgnoreMode.GLOB;\n  if (ignoreMode != IgnoreMode.GLOB) {\n    _hashField(hash, \"options.ignoreMode\", ignoreMode);\n  }\n\n  const ignoreStrategy = IgnoreStrategy.fromCopyOptions(\n    options,\n    fileOrDirectory,\n  );\n  _processFileOrDirectory(fileOrDirectory, isDir);\n\n  return hash.digest(\"hex\");\n\n  function _processFileOrDirectory(\n    symbolicPath: string,\n    isRootDir: boolean = false,\n    realPath = symbolicPath,\n  ) {\n    if (!isRootDir && ignoreStrategy.ignores(symbolicPath)) {\n      return;\n    }\n\n    const stat = fs.lstatSync(realPath);\n\n    // Use relative path as hash component. Normalize it with forward slashes to ensure\n    // same hash on Windows and Linux.\n    const hashComponent = path\n      .relative(fileOrDirectory, symbolicPath)\n      .replace(/\\\\/g, \"/\");\n\n    if (stat.isSymbolicLink()) {\n      const linkTarget = fs.readlinkSync(realPath);\n      const resolvedLinkTarget = path.resolve(\n        path.dirname(realPath),\n        linkTarget,\n      );\n      if (shouldFollow(follow, rootDirectory, resolvedLinkTarget)) {\n        _processFileOrDirectory(symbolicPath, false, resolvedLinkTarget);\n      } else {\n        _hashField(hash, `link:${hashComponent}`, linkTarget);\n      }\n    } else if (stat.isFile()) {\n      _hashField(hash, `file:${hashComponent}`, contentFingerprint(realPath));\n    } else if (stat.isDirectory()) {\n      for (const item of fs.readdirSync(realPath).sort()) {\n        _processFileOrDirectory(\n          path.join(symbolicPath, item),\n          false,\n          path.join(realPath, item),\n        );\n      }\n    } else {\n      throw new Error(\n        `Unable to hash ${symbolicPath}: it is neither a file nor a directory`,\n      );\n    }\n  }\n}\n\nexport function contentFingerprint(file: string): string {\n  // On windows it's particularly important to pass bigint: true to ensure that\n  // floating-point inaccuracies don't result in false matches. ( see\n  // https://github.com/nodejs/node/issues/12115#issuecomment-438741212 )\n  //\n  // Note that even if we do get a inode collision somehow, it's unlikely that\n  // both mtime and size would have a false-positive as well.\n\n  // We also must suppress typescript typechecks as we are using a version of\n  // @types/node that only supports node 10 declarations.\n  const stats = fs.statSync(file, { bigint: true });\n  const cacheKey = JSON.stringify({\n    mtime_unix: stats.mtime.toUTCString(),\n    mtime_ms: stats.mtimeMs.toString(),\n    inode: stats.ino.toString(),\n    size: stats.size.toString(),\n  });\n\n  return fingerprintCache.obtain(cacheKey, () => contentFingerprintMiss(file));\n}\n\nfunction contentFingerprintMiss(file: string): string {\n  const hash = crypto.createHash(\"sha256\");\n  const buffer = Buffer.alloc(BUFFER_SIZE);\n  const fd = fs.openSync(\n    file,\n    // eslint-disable-next-line no-bitwise\n    fs.constants.O_DSYNC | fs.constants.O_RDONLY | fs.constants.O_SYNC,\n  );\n  let size = 0;\n  let isBinary = false;\n  let lastStr = \"\";\n  let read = 0;\n  try {\n    while ((read = fs.readSync(fd, buffer, 0, BUFFER_SIZE, null)) !== 0) {\n      const slicedBuffer = buffer.slice(0, read);\n\n      // Detect if file is binary by checking the first 8k bytes for the\n      // null character (git like implementation)\n      if (size === 0) {\n        isBinary = slicedBuffer.indexOf(0) !== -1;\n      }\n\n      let dataBuffer = slicedBuffer;\n      if (!isBinary) {\n        // Line endings normalization (CRLF -> LF)\n        const str = buffer.slice(0, read).toString();\n\n        // We are going to normalize line endings to LF. So if the current\n        // buffer ends with CR, it could be that the next one starts with\n        // LF so we need to save it for later use.\n        if (new RegExp(`${CR}$`).test(str)) {\n          lastStr += str;\n          continue;\n        }\n\n        const data = lastStr + str;\n        const normalizedData = data.replace(new RegExp(CRLF, \"g\"), LF);\n        dataBuffer = Buffer.from(normalizedData);\n        lastStr = \"\";\n      }\n\n      size += dataBuffer.length;\n      hash.update(dataBuffer);\n    }\n\n    if (lastStr) {\n      hash.update(Buffer.from(lastStr));\n    }\n  } finally {\n    fs.closeSync(fd);\n  }\n  return `${size}:${hash.digest(\"hex\")}`;\n}\n\nfunction _hashField(\n  hash: crypto.Hash,\n  header: string,\n  value: string | Buffer | DataView,\n) {\n  hash\n    .update(CTRL_SOH)\n    .update(header)\n    .update(CTRL_SOT)\n    .update(value)\n    .update(CTRL_ETX);\n}\n"]}

package/lib/fs/ignore.d.ts

@@ -0,0 +1,107 @@
+import { CopyOptions } from "./options";
+/**
+ * Represents file path ignoring behavior.
+ */
+export declare abstract class IgnoreStrategy {
+    /**
+     * Ignores file paths based on simple glob patterns.
+     *
+     * @returns `GlobIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static glob(absoluteRootPath: string, patterns: string[]): GlobIgnoreStrategy;
+    /**
+     * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+     *
+     * @returns `GitIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static git(absoluteRootPath: string, patterns: string[]): GitIgnoreStrategy;
+    /**
+     * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+     *
+     * @returns `DockerIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static docker(absoluteRootPath: string, patterns: string[]): DockerIgnoreStrategy;
+    /**
+     * Creates an IgnoreStrategy based on the `ignoreMode` and `exclude` in a `CopyOptions`.
+     *
+     * @returns `IgnoreStrategy` based on the `CopyOptions`
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     * @param options the `CopyOptions` to create the `IgnoreStrategy` from
+     */
+    static fromCopyOptions(options: CopyOptions, absoluteRootPath: string): IgnoreStrategy;
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    abstract add(pattern: string): void;
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    abstract ignores(absoluteFilePath: string): boolean;
+}
+/**
+ * Ignores file paths based on simple glob patterns.
+ */
+export declare class GlobIgnoreStrategy extends IgnoreStrategy {
+    private readonly absoluteRootPath;
+    private readonly patterns;
+    constructor(absoluteRootPath: string, patterns: string[]);
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern: string): void;
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath: string): boolean;
+}
+/**
+ * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+ */
+export declare class GitIgnoreStrategy extends IgnoreStrategy {
+    private readonly absoluteRootPath;
+    private readonly ignore;
+    constructor(absoluteRootPath: string, patterns: string[]);
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern: string): void;
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath: string): boolean;
+}
+/**
+ * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+ */
+export declare class DockerIgnoreStrategy extends IgnoreStrategy {
+    private readonly absoluteRootPath;
+    private readonly ignore;
+    constructor(absoluteRootPath: string, patterns: string[]);
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern: string): void;
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath: string): boolean;
+}

package/lib/fs/ignore.js

@@ -0,0 +1,190 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerIgnoreStrategy = exports.GitIgnoreStrategy = exports.GlobIgnoreStrategy = exports.IgnoreStrategy = 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/fs/ignore.ts
+const path = require("path");
+const dockerignore_1 = require("@balena/dockerignore");
+const ignore_1 = require("ignore");
+const options_1 = require("./options");
+// Must be a 'require' to not run afoul of ESM module import rules
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const minimatch = require("minimatch");
+/**
+ * Represents file path ignoring behavior.
+ */
+class IgnoreStrategy {
+    /**
+     * Ignores file paths based on simple glob patterns.
+     *
+     * @returns `GlobIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static glob(absoluteRootPath, patterns) {
+        return new GlobIgnoreStrategy(absoluteRootPath, patterns);
+    }
+    /**
+     * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+     *
+     * @returns `GitIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static git(absoluteRootPath, patterns) {
+        return new GitIgnoreStrategy(absoluteRootPath, patterns);
+    }
+    /**
+     * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+     *
+     * @returns `DockerIgnorePattern` associated with the given patterns.
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     */
+    static docker(absoluteRootPath, patterns) {
+        return new DockerIgnoreStrategy(absoluteRootPath, patterns);
+    }
+    /**
+     * Creates an IgnoreStrategy based on the `ignoreMode` and `exclude` in a `CopyOptions`.
+     *
+     * @returns `IgnoreStrategy` based on the `CopyOptions`
+     * @param absoluteRootPath the absolute path to the root directory of the paths to be considered
+     * @param options the `CopyOptions` to create the `IgnoreStrategy` from
+     */
+    static fromCopyOptions(options, absoluteRootPath) {
+        const ignoreMode = options.ignoreMode || options_1.IgnoreMode.GLOB;
+        const exclude = options.exclude || [];
+        switch (ignoreMode) {
+            case options_1.IgnoreMode.GLOB:
+                return this.glob(absoluteRootPath, exclude);
+            case options_1.IgnoreMode.GIT:
+                return this.git(absoluteRootPath, exclude);
+            case options_1.IgnoreMode.DOCKER:
+                return this.docker(absoluteRootPath, exclude);
+        }
+    }
+}
+exports.IgnoreStrategy = IgnoreStrategy;
+_a = JSII_RTTI_SYMBOL_1;
+IgnoreStrategy[_a] = { fqn: "terraconstructs.IgnoreStrategy", version: "0.1.1" };
+/**
+ * Ignores file paths based on simple glob patterns.
+ */
+class GlobIgnoreStrategy extends IgnoreStrategy {
+    constructor(absoluteRootPath, patterns) {
+        super();
+        if (!path.isAbsolute(absoluteRootPath)) {
+            throw new Error("GlobIgnoreStrategy expects an absolute file path");
+        }
+        this.absoluteRootPath = absoluteRootPath;
+        this.patterns = patterns;
+    }
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern) {
+        this.patterns.push(pattern);
+    }
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath) {
+        if (!path.isAbsolute(absoluteFilePath)) {
+            throw new Error("GlobIgnoreStrategy.ignores() expects an absolute path");
+        }
+        let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);
+        let excludeOutput = false;
+        for (const pattern of this.patterns) {
+            const negate = pattern.startsWith("!");
+            const match = minimatch(relativePath, pattern, {
+                matchBase: true,
+                flipNegate: true,
+            });
+            if (!negate && match) {
+                excludeOutput = true;
+            }
+            if (negate && match) {
+                excludeOutput = false;
+            }
+        }
+        return excludeOutput;
+    }
+}
+exports.GlobIgnoreStrategy = GlobIgnoreStrategy;
+_b = JSII_RTTI_SYMBOL_1;
+GlobIgnoreStrategy[_b] = { fqn: "terraconstructs.GlobIgnoreStrategy", version: "0.1.1" };
+/**
+ * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
+ */
+class GitIgnoreStrategy extends IgnoreStrategy {
+    constructor(absoluteRootPath, patterns) {
+        super();
+        if (!path.isAbsolute(absoluteRootPath)) {
+            throw new Error("GitIgnoreStrategy expects an absolute file path");
+        }
+        this.absoluteRootPath = absoluteRootPath;
+        this.ignore = (0, ignore_1.default)().add(patterns);
+    }
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern) {
+        this.ignore.add(pattern);
+    }
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath) {
+        if (!path.isAbsolute(absoluteFilePath)) {
+            throw new Error("GitIgnoreStrategy.ignores() expects an absolute path");
+        }
+        let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);
+        return this.ignore.ignores(relativePath);
+    }
+}
+exports.GitIgnoreStrategy = GitIgnoreStrategy;
+_c = JSII_RTTI_SYMBOL_1;
+GitIgnoreStrategy[_c] = { fqn: "terraconstructs.GitIgnoreStrategy", version: "0.1.1" };
+/**
+ * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
+ */
+class DockerIgnoreStrategy extends IgnoreStrategy {
+    constructor(absoluteRootPath, patterns) {
+        super();
+        if (!path.isAbsolute(absoluteRootPath)) {
+            throw new Error("DockerIgnoreStrategy expects an absolute file path");
+        }
+        this.absoluteRootPath = absoluteRootPath;
+        this.ignore = (0, dockerignore_1.default)().add(patterns);
+    }
+    /**
+     * Adds another pattern.
+     * @params pattern the pattern to add
+     */
+    add(pattern) {
+        this.ignore.add(pattern);
+    }
+    /**
+     * Determines whether a given file path should be ignored or not.
+     *
+     * @param absoluteFilePath absolute file path to be assessed against the pattern
+     * @returns `true` if the file should be ignored
+     */
+    ignores(absoluteFilePath) {
+        if (!path.isAbsolute(absoluteFilePath)) {
+            throw new Error("DockerIgnoreStrategy.ignores() expects an absolute path");
+        }
+        let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);
+        return this.ignore.ignores(relativePath);
+    }
+}
+exports.DockerIgnoreStrategy = DockerIgnoreStrategy;
+_d = JSII_RTTI_SYMBOL_1;
+DockerIgnoreStrategy[_d] = { fqn: "terraconstructs.DockerIgnoreStrategy", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ignore.js","sourceRoot":"","sources":["../../src/fs/ignore.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/fs/ignore.ts\n\nimport * as path from \"path\";\nimport dockerIgnore, * as DockerIgnore from \"@balena/dockerignore\";\nimport gitIgnore, * as GitIgnore from \"ignore\";\nimport { CopyOptions, IgnoreMode } from \"./options\";\n\n// Must be a 'require' to not run afoul of ESM module import rules\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst minimatch = require(\"minimatch\");\n\n/**\n * Represents file path ignoring behavior.\n */\nexport abstract class IgnoreStrategy {\n  /**\n   * Ignores file paths based on simple glob patterns.\n   *\n   * @returns `GlobIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static glob(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): GlobIgnoreStrategy {\n    return new GlobIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).\n   *\n   * @returns `GitIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static git(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): GitIgnoreStrategy {\n    return new GitIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).\n   *\n   * @returns `DockerIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static docker(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): DockerIgnoreStrategy {\n    return new DockerIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Creates an IgnoreStrategy based on the `ignoreMode` and `exclude` in a `CopyOptions`.\n   *\n   * @returns `IgnoreStrategy` based on the `CopyOptions`\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   * @param options the `CopyOptions` to create the `IgnoreStrategy` from\n   */\n  public static fromCopyOptions(\n    options: CopyOptions,\n    absoluteRootPath: string,\n  ): IgnoreStrategy {\n    const ignoreMode = options.ignoreMode || IgnoreMode.GLOB;\n    const exclude = options.exclude || [];\n\n    switch (ignoreMode) {\n      case IgnoreMode.GLOB:\n        return this.glob(absoluteRootPath, exclude);\n\n      case IgnoreMode.GIT:\n        return this.git(absoluteRootPath, exclude);\n\n      case IgnoreMode.DOCKER:\n        return this.docker(absoluteRootPath, exclude);\n    }\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public abstract add(pattern: string): void;\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public abstract ignores(absoluteFilePath: string): boolean;\n}\n\n/**\n * Ignores file paths based on simple glob patterns.\n */\nexport class GlobIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly patterns: string[];\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"GlobIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.patterns = patterns;\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.patterns.push(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\"GlobIgnoreStrategy.ignores() expects an absolute path\");\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n    let excludeOutput = false;\n\n    for (const pattern of this.patterns) {\n      const negate = pattern.startsWith(\"!\");\n      const match = minimatch(relativePath, pattern, {\n        matchBase: true,\n        flipNegate: true,\n      });\n\n      if (!negate && match) {\n        excludeOutput = true;\n      }\n\n      if (negate && match) {\n        excludeOutput = false;\n      }\n    }\n\n    return excludeOutput;\n  }\n}\n\n/**\n * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).\n */\nexport class GitIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly ignore: GitIgnore.Ignore;\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"GitIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.ignore = gitIgnore().add(patterns);\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.ignore.add(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\"GitIgnoreStrategy.ignores() expects an absolute path\");\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n\n    return this.ignore.ignores(relativePath);\n  }\n}\n\n/**\n * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).\n */\nexport class DockerIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly ignore: DockerIgnore.Ignore;\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"DockerIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.ignore = dockerIgnore().add(patterns);\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.ignore.add(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\n        \"DockerIgnoreStrategy.ignores() expects an absolute path\",\n      );\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n\n    return this.ignore.ignores(relativePath);\n  }\n}\n"]}

package/lib/fs/index.d.ts

@@ -0,0 +1,47 @@
+import { CopyOptions, FingerprintOptions } from "./options";
+export * from "./ignore";
+export * from "./options";
+/**
+ * File system utilities.
+ */
+export declare class FileSystem {
+    /**
+     * Copies an entire directory structure.
+     * @param srcDir Source directory
+     * @param destDir Destination directory
+     * @param options options
+     * @param rootDir Root directory to calculate exclusions from
+     */
+    static copyDirectory(srcDir: string, destDir: string, options?: CopyOptions, rootDir?: string): 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
+     */
+    static fingerprint(fileOrDirectory: string, options?: FingerprintOptions): string;
+    /**
+     * Checks whether a directory is empty
+     *
+     * @param dir The directory to check
+     */
+    static isEmpty(dir: string): boolean;
+    /**
+     * The real path of the system temp directory
+     */
+    static get tmpdir(): string;
+    /**
+     * Creates a unique temporary directory in the **system temp directory**.
+     *
+     * @param prefix A prefix for the directory name. Six random characters
+     * will be generated and appended behind this prefix.
+     */
+    static mkdtemp(prefix: string): string;
+    private static _tmpdir?;
+}

package/lib/fs/index.js

@@ -0,0 +1,88 @@
+"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);
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = 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/fs/index.ts
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const copy_1 = require("./copy");
+const fingerprint_1 = require("./fingerprint");
+__exportStar(require("./ignore"), exports);
+__exportStar(require("./options"), exports);
+/**
+ * File system utilities.
+ */
+class FileSystem {
+    /**
+     * Copies an entire directory structure.
+     * @param srcDir Source directory
+     * @param destDir Destination directory
+     * @param options options
+     * @param rootDir Root directory to calculate exclusions from
+     */
+    static copyDirectory(srcDir, destDir, options = {}, rootDir) {
+        return (0, copy_1.copyDirectory)(srcDir, destDir, options, rootDir);
+    }
+    /**
+     * 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
+     */
+    static fingerprint(fileOrDirectory, options = {}) {
+        return (0, fingerprint_1.fingerprint)(fileOrDirectory, options);
+    }
+    /**
+     * Checks whether a directory is empty
+     *
+     * @param dir The directory to check
+     */
+    static isEmpty(dir) {
+        return fs.readdirSync(dir).length === 0;
+    }
+    /**
+     * The real path of the system temp directory
+     */
+    static get tmpdir() {
+        if (FileSystem._tmpdir) {
+            return FileSystem._tmpdir;
+        }
+        FileSystem._tmpdir = fs.realpathSync(os.tmpdir());
+        return FileSystem._tmpdir;
+    }
+    /**
+     * Creates a unique temporary directory in the **system temp directory**.
+     *
+     * @param prefix A prefix for the directory name. Six random characters
+     * will be generated and appended behind this prefix.
+     */
+    static mkdtemp(prefix) {
+        return fs.mkdtempSync(path.join(FileSystem.tmpdir, prefix));
+    }
+}
+exports.FileSystem = FileSystem;
+_a = JSII_RTTI_SYMBOL_1;
+FileSystem[_a] = { fqn: "terraconstructs.FileSystem", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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