@aws-cdk/core
Version:
AWS Cloud Development Kit Core Library
330 lines • 45.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AssetStaging = void 0;
const crypto = require("crypto");
const os = require("os");
const path = require("path");
const cxapi = require("@aws-cdk/cx-api");
const fs = require("fs-extra");
const minimatch = require("minimatch");
const assets_1 = require("./assets");
const fs_1 = require("./fs");
const stack_1 = require("./stack");
const stage_1 = require("./stage");
// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.
// eslint-disable-next-line
const construct_compat_1 = require("./construct-compat");
/**
* Stages a file or directory from a location on the file system into a staging directory.
*
* This is controlled by the context key 'aws:cdk:asset-staging' and enabled
* by the CLI by default in order to ensure that when the CDK app exists, all
* assets are available for deployment. Otherwise, if an app references assets
* in temporary locations, those will not be available when it exists (see
* https://github.com/aws/aws-cdk/issues/1716).
*
* The `stagedPath` property is a stringified token that represents the location
* of the file or directory after staging. It will be resolved only during the
* "prepare" stage and may be either the original path or the staged path
* depending on the context setting.
*
* The file/directory are staged based on their content hash (fingerprint). This
* means that only if content was changed, copy will happen.
*/
class AssetStaging extends construct_compat_1.Construct {
/**
*
*/
constructor(scope, id, props) {
var _a, _b, _c;
super(scope, id);
this.sourcePath = props.sourcePath;
this.fingerprintOptions = props;
const outdir = (_a = stage_1.Stage.of(this)) === null || _a === void 0 ? void 0 : _a.outdir;
if (!outdir) {
throw new Error('unable to determine cloud assembly output directory. Assets must be defined indirectly within a "Stage" or an "App" scope');
}
// Determine the hash type based on the props as props.assetHashType is
// optional from a caller perspective.
const hashType = determineHashType(props.assetHashType, props.assetHash);
// Calculate a cache key from the props. This way we can check if we already
// staged this asset (e.g. the same asset with the same configuration is used
// in multiple stacks). In this case we can completely skip file system and
// bundling operations.
this.cacheKey = calculateCacheKey({
sourcePath: path.resolve(props.sourcePath),
bundling: props.bundling,
assetHashType: hashType,
extraHash: props.extraHash,
exclude: props.exclude,
});
if (props.bundling) {
// Check if we actually have to bundle for this stack
const bundlingStacks = (_b = this.node.tryGetContext(cxapi.BUNDLING_STACKS)) !== null && _b !== void 0 ? _b : ['*'];
const runBundling = !!bundlingStacks.find(pattern => minimatch(stack_1.Stack.of(this).stackName, pattern));
if (runBundling) {
const bundling = props.bundling;
this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => {
// Determine the source hash in advance of bundling if the asset hash type
// is SOURCE so that the bundler can opt to re-use its previous output.
const sourceHash = hashType === assets_1.AssetHashType.SOURCE
? this.calculateHash(hashType, props.assetHash, props.bundling)
: undefined;
this.bundleDir = this.bundle(bundling, outdir, sourceHash);
return sourceHash !== null && sourceHash !== void 0 ? sourceHash : this.calculateHash(hashType, props.assetHash, props.bundling);
});
this.relativePath = renderAssetFilename(this.assetHash);
this.stagedPath = this.relativePath;
}
else { // Bundling is skipped
this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => {
return props.assetHashType === assets_1.AssetHashType.BUNDLE || props.assetHashType === assets_1.AssetHashType.OUTPUT
? this.calculateHash(assets_1.AssetHashType.CUSTOM, this.node.path) // Use node path as dummy hash because we're not bundling
: this.calculateHash(hashType, props.assetHash);
});
this.stagedPath = this.sourcePath;
}
}
else {
this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => this.calculateHash(hashType, props.assetHash));
this.relativePath = renderAssetFilename(this.assetHash, path.extname(this.sourcePath));
this.stagedPath = this.relativePath;
}
const stagingDisabled = this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT);
if (stagingDisabled) {
this.relativePath = undefined;
this.stagedPath = (_c = this.bundleDir) !== null && _c !== void 0 ? _c : this.sourcePath;
}
this.sourceHash = this.assetHash;
this.stageAsset(outdir);
}
/**
* Clears the asset hash cache.
*/
static clearAssetHashCache() {
this.assetHashCache = {};
}
/**
* Get asset hash from cache or calculate it in case of cache miss.
*/
static getOrCalcAssetHash(cacheKey, calcFn) {
var _a;
this.assetHashCache[cacheKey] = (_a = this.assetHashCache[cacheKey]) !== null && _a !== void 0 ? _a : calcFn();
return this.assetHashCache[cacheKey];
}
stageAsset(outdir) {
// Staging is disabled
if (!this.relativePath) {
return;
}
const targetPath = path.join(outdir, this.relativePath);
// Staging the bundling asset.
if (this.bundleDir) {
const isAlreadyStaged = fs.existsSync(targetPath);
if (isAlreadyStaged && path.resolve(this.bundleDir) !== path.resolve(targetPath)) {
// When an identical asset is already staged and the bundler used an
// intermediate bundling directory, we remove the extra directory.
fs.removeSync(this.bundleDir);
}
else if (!isAlreadyStaged) {
fs.renameSync(this.bundleDir, targetPath);
}
return;
}
// Already staged
if (fs.existsSync(targetPath)) {
return;
}
// Copy file/directory to staging directory
const stat = fs.statSync(this.sourcePath);
if (stat.isFile()) {
fs.copyFileSync(this.sourcePath, targetPath);
}
else if (stat.isDirectory()) {
fs.mkdirSync(targetPath);
fs_1.FileSystem.copyDirectory(this.sourcePath, targetPath, this.fingerprintOptions);
}
else {
throw new Error(`Unknown file type: ${this.sourcePath}`);
}
}
/**
* Bundles an asset and provides the emitted asset's directory in return.
*
* @param options Bundling options
* @param outdir Parent directory to create the bundle output directory in
* @param sourceHash The asset source hash if known in advance. If this field
* is provided, the bundler may opt to skip bundling, providing any already-
* emitted bundle. If this field is not provided, the bundler uses an
* intermediate directory in outdir.
* @returns The fully resolved bundle output directory.
*/
bundle(options, outdir, sourceHash) {
var _a, _b, _c;
let bundleDir;
if (sourceHash) {
// When an asset hash is known in advance of bundling, the bundler outputs
// directly to the assembly output directory.
bundleDir = path.resolve(path.join(outdir, renderAssetFilename(sourceHash)));
if (fs.existsSync(bundleDir)) {
// Pre-existing bundle directory. The bundle has already been generated
// once before, so we'll give the caller nothing.
return bundleDir;
}
}
else {
// When the asset hash isn't known in advance, bundler outputs to an
// intermediate directory named after the asset's cache key
bundleDir = path.resolve(path.join(outdir, `bundling-temp-${this.cacheKey}`));
}
fs.ensureDirSync(bundleDir);
// Chmod the bundleDir to full access.
fs.chmodSync(bundleDir, 0o777);
let user;
if (options.user) {
user = options.user;
}
else { // Default to current user
const userInfo = os.userInfo();
user = userInfo.uid !== -1 // uid is -1 on Windows
? `${userInfo.uid}:${userInfo.gid}`
: '1000:1000';
}
// Always mount input and output dir
const volumes = [
{
hostPath: this.sourcePath,
containerPath: AssetStaging.BUNDLING_INPUT_DIR,
},
{
hostPath: bundleDir,
containerPath: AssetStaging.BUNDLING_OUTPUT_DIR,
},
...(_a = options.volumes) !== null && _a !== void 0 ? _a : [],
];
let localBundling;
try {
process.stderr.write(`Bundling asset ${this.node.path}...\n`);
localBundling = (_b = options.local) === null || _b === void 0 ? void 0 : _b.tryBundle(bundleDir, options);
if (!localBundling) {
options.image.run({
command: options.command,
user,
volumes,
environment: options.environment,
workingDirectory: (_c = options.workingDirectory) !== null && _c !== void 0 ? _c : AssetStaging.BUNDLING_INPUT_DIR,
});
}
}
catch (err) {
// When bundling fails, keep the bundle output for diagnosability, but
// rename it out of the way so that the next run doesn't assume it has a
// valid bundleDir.
const bundleErrorDir = bundleDir + '-error';
if (fs.existsSync(bundleErrorDir)) {
// Remove the last bundleErrorDir.
fs.removeSync(bundleErrorDir);
}
fs.renameSync(bundleDir, bundleErrorDir);
throw new Error(`Failed to bundle asset ${this.node.path}, bundle output is located at ${bundleErrorDir}: ${err}`);
}
if (fs_1.FileSystem.isEmpty(bundleDir)) {
const outputDir = localBundling ? bundleDir : AssetStaging.BUNDLING_OUTPUT_DIR;
throw new Error(`Bundling did not produce any output. Check that content is written to ${outputDir}.`);
}
return bundleDir;
}
calculateHash(hashType, assetHash, bundling) {
if (hashType === assets_1.AssetHashType.CUSTOM && !assetHash) {
throw new Error('`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.');
}
// When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include
// the bundling configuration. We handle CUSTOM and bundled SOURCE hash types
// as a special case to preserve existing user asset hashes in all other cases.
if (hashType == assets_1.AssetHashType.CUSTOM || (hashType == assets_1.AssetHashType.SOURCE && bundling)) {
const hash = crypto.createHash('sha256');
// if asset hash is provided by user, use it, otherwise fingerprint the source.
hash.update(assetHash !== null && assetHash !== void 0 ? assetHash : fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions));
// If we're bundling an asset, include the bundling configuration in the hash
if (bundling) {
hash.update(JSON.stringify(bundling));
}
return hash.digest('hex');
}
switch (hashType) {
case assets_1.AssetHashType.SOURCE:
return fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);
case assets_1.AssetHashType.BUNDLE:
case assets_1.AssetHashType.OUTPUT:
if (!this.bundleDir) {
throw new Error(`Cannot use \`${hashType}\` hash type when \`bundling\` is not specified.`);
}
return fs_1.FileSystem.fingerprint(this.bundleDir, this.fingerprintOptions);
default:
throw new Error('Unknown asset hash type.');
}
}
}
exports.AssetStaging = AssetStaging;
/**
* (experimental) The directory inside the bundling container into which the asset sources will be mounted.
*
* @experimental
*/
AssetStaging.BUNDLING_INPUT_DIR = '/asset-input';
/**
* (experimental) The directory inside the bundling container into which the bundled output should be written.
*
* @experimental
*/
AssetStaging.BUNDLING_OUTPUT_DIR = '/asset-output';
/**
* Cache of asset hashes based on asset configuration to avoid repeated file
* system and bundling operations.
*/
AssetStaging.assetHashCache = {};
function renderAssetFilename(assetHash, extension = '') {
return `asset.${assetHash}${extension}`;
}
/**
* Determines the hash type from user-given prop values.
*
* @param assetHashType Asset hash type construct prop
* @param assetHash Asset hash given in the construct props
*/
function determineHashType(assetHashType, assetHash) {
if (assetHash) {
if (assetHashType && assetHashType !== assets_1.AssetHashType.CUSTOM) {
throw new Error(`Cannot specify \`${assetHashType}\` for \`assetHashType\` when \`assetHash\` is specified. Use \`CUSTOM\` or leave \`undefined\`.`);
}
return assets_1.AssetHashType.CUSTOM;
}
else if (assetHashType) {
return assetHashType;
}
else {
return assets_1.AssetHashType.SOURCE;
}
}
/**
* Calculates a cache key from the props. Normalize by sorting keys.
*/
function calculateCacheKey(props) {
return crypto.createHash('sha256')
.update(JSON.stringify(sortObject(props)))
.digest('hex');
}
/**
* Recursively sort object keys
*/
function sortObject(object) {
if (typeof object !== 'object' || object instanceof Array) {
return object;
}
const ret = {};
for (const key of Object.keys(object).sort()) {
ret[key] = sortObject(object[key]);
}
return ret;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-staging.js","sourceRoot":"","sources":["asset-staging.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { Construct } from 'constructs';\nimport * as fs from 'fs-extra';\nimport * as minimatch from 'minimatch';\nimport { AssetHashType, AssetOptions } from './assets';\nimport { BundlingOptions } from './bundling';\nimport { FileSystem, FingerprintOptions } from './fs';\nimport { Stack } from './stack';\nimport { Stage } from './stage';\n\n// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.\n// eslint-disable-next-line\nimport { Construct as CoreConstruct } from './construct-compat';\n\n                                                        \nexport interface AssetStagingProps extends FingerprintOptions, AssetOptions {\n                                                           \n  readonly sourcePath: string;\n}\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \nexport class AssetStaging extends CoreConstruct {\n                                                                                                                             \n  public static readonly BUNDLING_INPUT_DIR = '/asset-input';\n\n                                                                                                                                \n  public static readonly BUNDLING_OUTPUT_DIR = '/asset-output';\n\n                                            \n  public static clearAssetHashCache() {\n    this.assetHashCache = {};\n  }\n\n  /**\n   * Cache of asset hashes based on asset configuration to avoid repeated file\n   * system and bundling operations.\n   */\n  private static assetHashCache: { [key: string]: string } = {};\n\n  /**\n   * Get asset hash from cache or calculate it in case of cache miss.\n   */\n  private static getOrCalcAssetHash(cacheKey: string, calcFn: () => string) {\n    this.assetHashCache[cacheKey] = this.assetHashCache[cacheKey] ?? calcFn();\n    return this.assetHashCache[cacheKey];\n  }\n\n                                                                                                                                                                                                      \n  public readonly stagedPath: string;\n\n                                                                        \n  public readonly sourcePath: string;\n\n                                                                                          \n  public readonly sourceHash: string;\n\n                                                   \n  public readonly assetHash: string;\n\n  private readonly fingerprintOptions: FingerprintOptions;\n\n  private readonly relativePath?: string;\n\n  private bundleDir?: string;\n\n  private readonly cacheKey: string;\n\n  constructor(scope: Construct, id: string, props: AssetStagingProps) {\n    super(scope, id);\n\n    this.sourcePath = props.sourcePath;\n    this.fingerprintOptions = props;\n\n    const outdir = Stage.of(this)?.outdir;\n    if (!outdir) {\n      throw new Error('unable to determine cloud assembly output directory. Assets must be defined indirectly within a \"Stage\" or an \"App\" scope');\n    }\n\n    // Determine the hash type based on the props as props.assetHashType is\n    // optional from a caller perspective.\n    const hashType = determineHashType(props.assetHashType, props.assetHash);\n\n    // Calculate a cache key from the props. This way we can check if we already\n    // staged this asset (e.g. the same asset with the same configuration is used\n    // in multiple stacks). In this case we can completely skip file system and\n    // bundling operations.\n    this.cacheKey = calculateCacheKey({\n      sourcePath: path.resolve(props.sourcePath),\n      bundling: props.bundling,\n      assetHashType: hashType,\n      extraHash: props.extraHash,\n      exclude: props.exclude,\n    });\n\n    if (props.bundling) {\n      // Check if we actually have to bundle for this stack\n      const bundlingStacks: string[] = this.node.tryGetContext(cxapi.BUNDLING_STACKS) ?? ['*'];\n      const runBundling = !!bundlingStacks.find(pattern => minimatch(Stack.of(this).stackName, pattern));\n      if (runBundling) {\n        const bundling = props.bundling;\n        this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => {\n          // Determine the source hash in advance of bundling if the asset hash type\n          // is SOURCE so that the bundler can opt to re-use its previous output.\n          const sourceHash = hashType === AssetHashType.SOURCE\n            ? this.calculateHash(hashType, props.assetHash, props.bundling)\n            : undefined;\n          this.bundleDir = this.bundle(bundling, outdir, sourceHash);\n          return sourceHash ?? this.calculateHash(hashType, props.assetHash, props.bundling);\n        });\n        this.relativePath = renderAssetFilename(this.assetHash);\n        this.stagedPath = this.relativePath;\n      } else { // Bundling is skipped\n        this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => {\n          return props.assetHashType === AssetHashType.BUNDLE || props.assetHashType === AssetHashType.OUTPUT\n            ? this.calculateHash(AssetHashType.CUSTOM, this.node.path) // Use node path as dummy hash because we're not bundling\n            : this.calculateHash(hashType, props.assetHash);\n        });\n        this.stagedPath = this.sourcePath;\n      }\n    } else {\n      this.assetHash = AssetStaging.getOrCalcAssetHash(this.cacheKey, () => this.calculateHash(hashType, props.assetHash));\n      this.relativePath = renderAssetFilename(this.assetHash, path.extname(this.sourcePath));\n      this.stagedPath = this.relativePath;\n    }\n\n    const stagingDisabled = this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT);\n    if (stagingDisabled) {\n      this.relativePath = undefined;\n      this.stagedPath = this.bundleDir ?? this.sourcePath;\n    }\n\n    this.sourceHash = this.assetHash;\n\n    this.stageAsset(outdir);\n  }\n\n  private stageAsset(outdir: string) {\n    // Staging is disabled\n    if (!this.relativePath) {\n      return;\n    }\n\n    const targetPath = path.join(outdir, this.relativePath);\n\n    // Staging the bundling asset.\n    if (this.bundleDir) {\n      const isAlreadyStaged = fs.existsSync(targetPath);\n\n      if (isAlreadyStaged && path.resolve(this.bundleDir) !== path.resolve(targetPath)) {\n        // When an identical asset is already staged and the bundler used an\n        // intermediate bundling directory, we remove the extra directory.\n        fs.removeSync(this.bundleDir);\n      } else if (!isAlreadyStaged) {\n        fs.renameSync(this.bundleDir, targetPath);\n      }\n\n      return;\n    }\n\n    // Already staged\n    if (fs.existsSync(targetPath)) {\n      return;\n    }\n\n    // Copy file/directory to staging directory\n    const stat = fs.statSync(this.sourcePath);\n    if (stat.isFile()) {\n      fs.copyFileSync(this.sourcePath, targetPath);\n    } else if (stat.isDirectory()) {\n      fs.mkdirSync(targetPath);\n      FileSystem.copyDirectory(this.sourcePath, targetPath, this.fingerprintOptions);\n    } else {\n      throw new Error(`Unknown file type: ${this.sourcePath}`);\n    }\n  }\n\n  /**\n   * Bundles an asset and provides the emitted asset's directory in return.\n   *\n   * @param options Bundling options\n   * @param outdir Parent directory to create the bundle output directory in\n   * @param sourceHash The asset source hash if known in advance. If this field\n   * is provided, the bundler may opt to skip bundling, providing any already-\n   * emitted bundle. If this field is not provided, the bundler uses an\n   * intermediate directory in outdir.\n   * @returns The fully resolved bundle output directory.\n   */\n  private bundle(options: BundlingOptions, outdir: string, sourceHash?: string): string {\n    let bundleDir: string;\n    if (sourceHash) {\n      // When an asset hash is known in advance of bundling, the bundler outputs\n      // directly to the assembly output directory.\n      bundleDir = path.resolve(path.join(outdir, renderAssetFilename(sourceHash)));\n\n      if (fs.existsSync(bundleDir)) {\n        // Pre-existing bundle directory. The bundle has already been generated\n        // once before, so we'll give the caller nothing.\n        return bundleDir;\n      }\n    } else {\n      // When the asset hash isn't known in advance, bundler outputs to an\n      // intermediate directory named after the asset's cache key\n      bundleDir = path.resolve(path.join(outdir, `bundling-temp-${this.cacheKey}`));\n    }\n\n    fs.ensureDirSync(bundleDir);\n    // Chmod the bundleDir to full access.\n    fs.chmodSync(bundleDir, 0o777);\n\n    let user: string;\n    if (options.user) {\n      user = options.user;\n    } else { // Default to current user\n      const userInfo = os.userInfo();\n      user = userInfo.uid !== -1 // uid is -1 on Windows\n        ? `${userInfo.uid}:${userInfo.gid}`\n        : '1000:1000';\n    }\n\n    // Always mount input and output dir\n    const volumes = [\n      {\n        hostPath: this.sourcePath,\n        containerPath: AssetStaging.BUNDLING_INPUT_DIR,\n      },\n      {\n        hostPath: bundleDir,\n        containerPath: AssetStaging.BUNDLING_OUTPUT_DIR,\n      },\n      ...options.volumes ?? [],\n    ];\n\n    let localBundling: boolean | undefined;\n    try {\n      process.stderr.write(`Bundling asset ${this.node.path}...\\n`);\n\n      localBundling = options.local?.tryBundle(bundleDir, options);\n      if (!localBundling) {\n        options.image.run({\n          command: options.command,\n          user,\n          volumes,\n          environment: options.environment,\n          workingDirectory: options.workingDirectory ?? AssetStaging.BUNDLING_INPUT_DIR,\n        });\n      }\n    } catch (err) {\n      // When bundling fails, keep the bundle output for diagnosability, but\n      // rename it out of the way so that the next run doesn't assume it has a\n      // valid bundleDir.\n      const bundleErrorDir = bundleDir + '-error';\n      if (fs.existsSync(bundleErrorDir)) {\n        // Remove the last bundleErrorDir.\n        fs.removeSync(bundleErrorDir);\n      }\n\n      fs.renameSync(bundleDir, bundleErrorDir);\n      throw new Error(`Failed to bundle asset ${this.node.path}, bundle output is located at ${bundleErrorDir}: ${err}`);\n    }\n\n    if (FileSystem.isEmpty(bundleDir)) {\n      const outputDir = localBundling ? bundleDir : AssetStaging.BUNDLING_OUTPUT_DIR;\n      throw new Error(`Bundling did not produce any output. Check that content is written to ${outputDir}.`);\n    }\n\n    return bundleDir;\n  }\n\n  private calculateHash(hashType: AssetHashType, assetHash?: string, bundling?: BundlingOptions): string {\n    if (hashType === AssetHashType.CUSTOM && !assetHash) {\n      throw new Error('`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.');\n    }\n\n    // When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include\n    // the bundling configuration. We handle CUSTOM and bundled SOURCE hash types\n    // as a special case to preserve existing user asset hashes in all other cases.\n    if (hashType == AssetHashType.CUSTOM || (hashType == AssetHashType.SOURCE && bundling)) {\n      const hash = crypto.createHash('sha256');\n\n      // if asset hash is provided by user, use it, otherwise fingerprint the source.\n      hash.update(assetHash ?? FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions));\n\n      // If we're bundling an asset, include the bundling configuration in the hash\n      if (bundling) {\n        hash.update(JSON.stringify(bundling));\n      }\n\n      return hash.digest('hex');\n    }\n\n    switch (hashType) {\n      case AssetHashType.SOURCE:\n        return FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);\n      case AssetHashType.BUNDLE:\n      case AssetHashType.OUTPUT:\n        if (!this.bundleDir) {\n          throw new Error(`Cannot use \\`${hashType}\\` hash type when \\`bundling\\` is not specified.`);\n        }\n        return FileSystem.fingerprint(this.bundleDir, this.fingerprintOptions);\n      default:\n        throw new Error('Unknown asset hash type.');\n    }\n  }\n}\n\nfunction renderAssetFilename(assetHash: string, extension = '') {\n  return `asset.${assetHash}${extension}`;\n}\n\n/**\n * Determines the hash type from user-given prop values.\n *\n * @param assetHashType Asset hash type construct prop\n * @param assetHash Asset hash given in the construct props\n */\nfunction determineHashType(assetHashType?: AssetHashType, assetHash?: string) {\n  if (assetHash) {\n    if (assetHashType && assetHashType !== AssetHashType.CUSTOM) {\n      throw new Error(`Cannot specify \\`${assetHashType}\\` for \\`assetHashType\\` when \\`assetHash\\` is specified. Use \\`CUSTOM\\` or leave \\`undefined\\`.`);\n    }\n    return AssetHashType.CUSTOM;\n  } else if (assetHashType) {\n    return assetHashType;\n  } else {\n    return AssetHashType.SOURCE;\n  }\n}\n\n/**\n * Calculates a cache key from the props. Normalize by sorting keys.\n */\nfunction calculateCacheKey(props: AssetStagingProps): string {\n  return crypto.createHash('sha256')\n    .update(JSON.stringify(sortObject(props)))\n    .digest('hex');\n}\n\n/**\n * Recursively sort object keys\n */\nfunction sortObject(object: { [key: string]: any }): { [key: string]: any } {\n  if (typeof object !== 'object' || object instanceof Array) {\n    return object;\n  }\n  const ret: { [key: string]: any } = {};\n  for (const key of Object.keys(object).sort()) {\n    ret[key] = sortObject(object[key]);\n  }\n  return ret;\n}\n"]}