raindancers-cloudfront 0.0.43 → 0.0.45

package/lib/cloudfront/edgeAssetHash.d.ts

@@ -2,15 +2,15 @@
  * Compute a deterministic content hash for a Lambda@Edge asset bundle.
  *
  * Why this exists: `cloudfront.experimental.EdgeFunction` publishes a new
- * `AWS::Lambda::Version` whenever the asset hash changes. When the asset is
- * created via `lambda.Code.fromAsset(dir, { bundling })` WITHOUT an explicit
- * `assetHash`, CDK falls back to hashing the bundling OUTPUT — and the local
- * bundler here copies files with `fs.cpSync`, which does not reproduce a
- * byte-identical tree across synths (mtimes/ordering drift). The result is a
- * fresh edge-Lambda version on EVERY deploy even when the code is unchanged,
- * each of which forces a global CloudFront re-association + propagation and
- * locks the prior version from deletion (it also slowly fills the regional
- * Lambda storage quota).
+ * `AWS::Lambda::Version` whenever the asset hash changes. Passing a stable
+ * `assetHash` with `assetHashType: AssetHashType.CUSTOM` pins the SOURCE
+ * identity so unchanged inputs yield an unchanged hash and no new version.
+ *
+ * NOTE: a CUSTOM assetHash alone is not sufficient for determinism — CDK also
+ * folds `JSON.stringify(bundling)` into the final hash (see aws-cdk-lib
+ * `AssetStaging.calculateHash`), so any non-deterministic value inside the
+ * `bundling` options (e.g. a random `volumes[].hostPath`) still churns the
+ * hash. See {@link deterministicConfigDir}, which keeps that path stable.
  *
  * This helper produces a hash from the actual INPUTS — the source directory
  * contents, the generated config, and the optional pre-bundled deps directory —
@@ -21,3 +21,21 @@
  * excluded because it is not shipped in the bundle (the bundler skips it).
  */
 export declare function computeEdgeAssetHash(sourceDir: string, generatedConfig: string, bundledDepsDir?: string): string;
+/**
+ * Create a DETERMINISTIC temp directory holding the generated `config_generated.py`,
+ * and return its path. Used as the `hostPath` of the Docker-fallback bundling
+ * volume for a Lambda@Edge function.
+ *
+ * Why this must be deterministic: CDK derives an asset's final hash even under
+ * `assetHashType: CUSTOM` by folding `JSON.stringify(bundling)` into the custom
+ * hash (see aws-cdk-lib `AssetStaging.calculateHash`). `bundling.volumes[].hostPath`
+ * is therefore part of the hash. A random `fs.mkdtempSync(...)` path changes on
+ * every synth, so the asset hash — and thus the published S3 key — changes every
+ * synth for byte-identical code, publishing a fresh `AWS::Lambda::Version` and
+ * forcing a global CloudFront distribution update on EVERY deploy (and orphaning
+ * the prior replicated edge version, which cannot be deleted for hours).
+ *
+ * Keying the directory on `key` (a per-function id) plus the config content keeps
+ * it stable for unchanged inputs while staying unique per function.
+ */
+export declare function deterministicConfigDir(key: string, configPy: string): string;

package/lib/cloudfront/edgeAssetHash.js

@@ -34,22 +34,24 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeEdgeAssetHash = computeEdgeAssetHash;
+exports.deterministicConfigDir = deterministicConfigDir;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 /**
  * Compute a deterministic content hash for a Lambda@Edge asset bundle.
  *
  * Why this exists: `cloudfront.experimental.EdgeFunction` publishes a new
- * `AWS::Lambda::Version` whenever the asset hash changes. When the asset is
- * created via `lambda.Code.fromAsset(dir, { bundling })` WITHOUT an explicit
- * `assetHash`, CDK falls back to hashing the bundling OUTPUT — and the local
- * bundler here copies files with `fs.cpSync`, which does not reproduce a
- * byte-identical tree across synths (mtimes/ordering drift). The result is a
- * fresh edge-Lambda version on EVERY deploy even when the code is unchanged,
- * each of which forces a global CloudFront re-association + propagation and
- * locks the prior version from deletion (it also slowly fills the regional
- * Lambda storage quota).
+ * `AWS::Lambda::Version` whenever the asset hash changes. Passing a stable
+ * `assetHash` with `assetHashType: AssetHashType.CUSTOM` pins the SOURCE
+ * identity so unchanged inputs yield an unchanged hash and no new version.
+ *
+ * NOTE: a CUSTOM assetHash alone is not sufficient for determinism — CDK also
+ * folds `JSON.stringify(bundling)` into the final hash (see aws-cdk-lib
+ * `AssetStaging.calculateHash`), so any non-deterministic value inside the
+ * `bundling` options (e.g. a random `volumes[].hostPath`) still churns the
+ * hash. See {@link deterministicConfigDir}, which keeps that path stable.
  *
  * This helper produces a hash from the actual INPUTS — the source directory
  * contents, the generated config, and the optional pre-bundled deps directory —
@@ -69,6 +71,36 @@ function computeEdgeAssetHash(sourceDir, generatedConfig, bundledDepsDir) {
     }
     return hash.digest('hex');
 }
+/**
+ * Create a DETERMINISTIC temp directory holding the generated `config_generated.py`,
+ * and return its path. Used as the `hostPath` of the Docker-fallback bundling
+ * volume for a Lambda@Edge function.
+ *
+ * Why this must be deterministic: CDK derives an asset's final hash even under
+ * `assetHashType: CUSTOM` by folding `JSON.stringify(bundling)` into the custom
+ * hash (see aws-cdk-lib `AssetStaging.calculateHash`). `bundling.volumes[].hostPath`
+ * is therefore part of the hash. A random `fs.mkdtempSync(...)` path changes on
+ * every synth, so the asset hash — and thus the published S3 key — changes every
+ * synth for byte-identical code, publishing a fresh `AWS::Lambda::Version` and
+ * forcing a global CloudFront distribution update on EVERY deploy (and orphaning
+ * the prior replicated edge version, which cannot be deleted for hours).
+ *
+ * Keying the directory on `key` (a per-function id) plus the config content keeps
+ * it stable for unchanged inputs while staying unique per function.
+ */
+function deterministicConfigDir(key, configPy) {
+    const digest = crypto
+        .createHash('sha256')
+        .update(`${key}\0`)
+        .update(configPy)
+        .digest('hex')
+        .slice(0, 16);
+    const dir = path.join(os.tmpdir(), `raindancers-edge-config-${digest}`);
+    fs.mkdirSync(dir, { recursive: true });
+    const configPyPath = path.join(dir, 'config_generated.py');
+    fs.writeFileSync(configPyPath, configPy);
+    return configPyPath;
+}
 /**
  * Fold every regular file under `dir` (recursively, sorted) into `hash`. Each
  * file contributes its relative path and its bytes under a namespace prefix so
@@ -94,4 +126,4 @@ function hashDir(hash, dir, namespace, skip) {
     };
     walk(dir, '');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edgeAssetHash.js","sourceRoot":"","sources":["../../src/cloudfront/edgeAssetHash.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\n\n/**\n * Compute a deterministic content hash for a Lambda@Edge asset bundle.\n *\n * Why this exists: `cloudfront.experimental.EdgeFunction` publishes a new\n * `AWS::Lambda::Version` whenever the asset hash changes. Passing a stable\n * `assetHash` with `assetHashType: AssetHashType.CUSTOM` pins the SOURCE\n * identity so unchanged inputs yield an unchanged hash and no new version.\n *\n * NOTE: a CUSTOM assetHash alone is not sufficient for determinism — CDK also\n * folds `JSON.stringify(bundling)` into the final hash (see aws-cdk-lib\n * `AssetStaging.calculateHash`), so any non-deterministic value inside the\n * `bundling` options (e.g. a random `volumes[].hostPath`) still churns the\n * hash. See {@link deterministicConfigDir}, which keeps that path stable.\n *\n * This helper produces a hash from the actual INPUTS — the source directory\n * contents, the generated config, and the optional pre-bundled deps directory —\n * so an unchanged input yields an unchanged hash and no new version. Pass the\n * result as `assetHash` with `assetHashType: AssetHashType.CUSTOM`.\n *\n * Files are hashed in sorted order for determinism. `requirements.txt` is\n * excluded because it is not shipped in the bundle (the bundler skips it).\n */\nexport function computeEdgeAssetHash(\n  sourceDir: string,\n  generatedConfig: string,\n  bundledDepsDir?: string,\n): string {\n  const hash = crypto.createHash('sha256');\n  hash.update('config\\0');\n  hash.update(generatedConfig);\n\n  hashDir(hash, sourceDir, 'src', (file) => file === 'requirements.txt');\n\n  if (bundledDepsDir && fs.existsSync(bundledDepsDir)) {\n    hashDir(hash, bundledDepsDir, 'dep');\n  }\n\n  return hash.digest('hex');\n}\n\n/**\n * Create a DETERMINISTIC temp directory holding the generated `config_generated.py`,\n * and return its path. Used as the `hostPath` of the Docker-fallback bundling\n * volume for a Lambda@Edge function.\n *\n * Why this must be deterministic: CDK derives an asset's final hash even under\n * `assetHashType: CUSTOM` by folding `JSON.stringify(bundling)` into the custom\n * hash (see aws-cdk-lib `AssetStaging.calculateHash`). `bundling.volumes[].hostPath`\n * is therefore part of the hash. A random `fs.mkdtempSync(...)` path changes on\n * every synth, so the asset hash — and thus the published S3 key — changes every\n * synth for byte-identical code, publishing a fresh `AWS::Lambda::Version` and\n * forcing a global CloudFront distribution update on EVERY deploy (and orphaning\n * the prior replicated edge version, which cannot be deleted for hours).\n *\n * Keying the directory on `key` (a per-function id) plus the config content keeps\n * it stable for unchanged inputs while staying unique per function.\n */\nexport function deterministicConfigDir(key: string, configPy: string): string {\n  const digest = crypto\n    .createHash('sha256')\n    .update(`${key}\\0`)\n    .update(configPy)\n    .digest('hex')\n    .slice(0, 16);\n  const dir = path.join(os.tmpdir(), `raindancers-edge-config-${digest}`);\n  fs.mkdirSync(dir, { recursive: true });\n  const configPyPath = path.join(dir, 'config_generated.py');\n  fs.writeFileSync(configPyPath, configPy);\n  return configPyPath;\n}\n\n/**\n * Fold every regular file under `dir` (recursively, sorted) into `hash`. Each\n * file contributes its relative path and its bytes under a namespace prefix so\n * that two directories cannot collide and file moves change the hash.\n */\nfunction hashDir(\n  hash: crypto.Hash,\n  dir: string,\n  namespace: string,\n  skip?: (relPath: string) => boolean,\n): void {\n  const walk = (current: string, rel: string): void => {\n    const entries = fs.readdirSync(current).sort();\n    for (const name of entries) {\n      const abs = path.join(current, name);\n      const relPath = rel ? `${rel}/${name}` : name;\n      const stat = fs.statSync(abs);\n      if (stat.isDirectory()) {\n        walk(abs, relPath);\n      } else if (stat.isFile()) {\n        if (skip && skip(relPath)) continue;\n        hash.update(`${namespace}\\0${relPath}\\0`);\n        hash.update(fs.readFileSync(abs));\n      }\n    }\n  };\n  walk(dir, '');\n}\n"]}