@aws-cdk/aws-lambda/lib/function-hash.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.VERSION_LOCKED = exports.trimFromStart = exports.calculateFunctionHash = void 0;
const crypto = require("crypto");
const core_1 = require("@aws-cdk/core");
const cx_api_1 = require("@aws-cdk/cx-api");
const function_1 = require("./function");
function calculateFunctionHash(fn) {
    const stack = core_1.Stack.of(fn);
    const functionResource = fn.node.defaultChild;
    // render the cloudformation resource from this function
    const config = stack.resolve(functionResource._toCloudFormation());
    // config is of the shape: { Resources: { LogicalId: { Type: 'Function', Properties: { ... } }}}
    const resources = config.Resources;
    const resourceKeys = Object.keys(resources);
    if (resourceKeys.length !== 1) {
        throw new Error(`Expected one rendered CloudFormation resource but found ${resourceKeys.length}`);
    }
    const logicalId = resourceKeys[0];
    const properties = resources[logicalId].Properties;
    let stringifiedConfig;
    if (core_1.FeatureFlags.of(fn).isEnabled(cx_api_1.LAMBDA_RECOGNIZE_VERSION_PROPS)) {
        const updatedProps = sortProperties(filterUsefulKeys(properties));
        stringifiedConfig = JSON.stringify(updatedProps);
    }
    else {
        const sorted = sortProperties(properties);
        config.Resources[logicalId].Properties = sorted;
        stringifiedConfig = JSON.stringify(config);
    }
    const hash = crypto.createHash('md5');
    hash.update(stringifiedConfig);
    return hash.digest('hex');
}
exports.calculateFunctionHash = calculateFunctionHash;
function trimFromStart(s, maxLength) {
    const desiredLength = Math.min(maxLength, s.length);
    const newStart = s.length - desiredLength;
    return s.substring(newStart);
}
exports.trimFromStart = trimFromStart;
/*
 * The list of properties found in CfnFunction (or AWS::Lambda::Function).
 * They are classified as "locked" to a Function Version or not.
 * When a property is locked, any change to that property will not take effect on previously created Versions.
 * Instead, a new Version must be generated for the change to take effect.
 * Similarly, if a property that's not locked to a Version is modified, a new Version
 * must not be generated.
 *
 * Adding a new property to this list - If the property is part of the UpdateFunctionConfiguration
 * API or UpdateFunctionCode API, then it must be classified as true, otherwise false.
 * See https://docs.aws.amazon.com/lambda/latest/dg/API_UpdateFunctionConfiguration.html and
 * https://docs.aws.amazon.com/lambda/latest/dg/API_UpdateFunctionConfiguration.html
 */
exports.VERSION_LOCKED = {
    // locked to the version
    Architectures: true,
    Code: true,
    DeadLetterConfig: true,
    Description: true,
    Environment: true,
    EphemeralStorage: true,
    FileSystemConfigs: true,
    FunctionName: true,
    Handler: true,
    ImageConfig: true,
    KmsKeyArn: true,
    Layers: true,
    MemorySize: true,
    PackageType: true,
    Role: true,
    Runtime: true,
    Timeout: true,
    TracingConfig: true,
    VpcConfig: true,
    // not locked to the version
    CodeSigningConfigArn: false,
    ReservedConcurrentExecutions: false,
    Tags: false,
};
function filterUsefulKeys(properties) {
    const versionProps = { ...exports.VERSION_LOCKED, ...function_1.Function._VER_PROPS };
    const unclassified = Object.entries(properties)
        .filter(([k, v]) => v != null && !Object.keys(versionProps).includes(k))
        .map(([k, _]) => k);
    if (unclassified.length > 0) {
        throw new Error(`The following properties are not recognized as version properties: [${unclassified}].`
            + ' See the README of the aws-lambda module to learn more about this and to fix it.');
    }
    const notLocked = Object.entries(versionProps).filter(([_, v]) => !v).map(([k, _]) => k);
    notLocked.forEach(p => delete properties[p]);
    const ret = {};
    Object.entries(properties).filter(([k, _]) => versionProps[k]).forEach(([k, v]) => ret[k] = v);
    return ret;
}
function sortProperties(properties) {
    const ret = {};
    // We take all required properties in the order that they were historically,
    // to make sure the hash we calculate is stable.
    // There cannot be more required properties added in the future,
    // as that would be a backwards-incompatible change.
    const requiredProperties = ['Code', 'Handler', 'Role', 'Runtime'];
    for (const requiredProperty of requiredProperties) {
        ret[requiredProperty] = properties[requiredProperty];
    }
    // then, add all of the non-required properties,
    // in the original order
    for (const property of Object.keys(properties)) {
        if (requiredProperties.indexOf(property) === -1) {
            ret[property] = properties[property];
        }
    }
    return ret;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-hash.js","sourceRoot":"","sources":["function-hash.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport { CfnResource, FeatureFlags, Stack } from '@aws-cdk/core';\nimport { LAMBDA_RECOGNIZE_VERSION_PROPS } from '@aws-cdk/cx-api';\nimport { Function as LambdaFunction } from './function';\n\nexport function calculateFunctionHash(fn: LambdaFunction) {\n  const stack = Stack.of(fn);\n\n  const functionResource = fn.node.defaultChild as CfnResource;\n\n  // render the cloudformation resource from this function\n  const config = stack.resolve((functionResource as any)._toCloudFormation());\n  // config is of the shape: { Resources: { LogicalId: { Type: 'Function', Properties: { ... } }}}\n  const resources = config.Resources;\n  const resourceKeys = Object.keys(resources);\n  if (resourceKeys.length !== 1) {\n    throw new Error(`Expected one rendered CloudFormation resource but found ${resourceKeys.length}`);\n  }\n  const logicalId = resourceKeys[0];\n  const properties = resources[logicalId].Properties;\n\n  let stringifiedConfig;\n  if (FeatureFlags.of(fn).isEnabled(LAMBDA_RECOGNIZE_VERSION_PROPS)) {\n    const updatedProps = sortProperties(filterUsefulKeys(properties));\n    stringifiedConfig = JSON.stringify(updatedProps);\n  } else {\n    const sorted = sortProperties(properties);\n    config.Resources[logicalId].Properties = sorted;\n    stringifiedConfig = JSON.stringify(config);\n  }\n\n  const hash = crypto.createHash('md5');\n  hash.update(stringifiedConfig);\n  return hash.digest('hex');\n}\n\nexport function trimFromStart(s: string, maxLength: number) {\n  const desiredLength = Math.min(maxLength, s.length);\n  const newStart = s.length - desiredLength;\n  return s.substring(newStart);\n}\n\n/*\n * The list of properties found in CfnFunction (or AWS::Lambda::Function).\n * They are classified as \"locked\" to a Function Version or not.\n * When a property is locked, any change to that property will not take effect on previously created Versions.\n * Instead, a new Version must be generated for the change to take effect.\n * Similarly, if a property that's not locked to a Version is modified, a new Version\n * must not be generated.\n *\n * Adding a new property to this list - If the property is part of the UpdateFunctionConfiguration\n * API or UpdateFunctionCode API, then it must be classified as true, otherwise false.\n * See https://docs.aws.amazon.com/lambda/latest/dg/API_UpdateFunctionConfiguration.html and\n * https://docs.aws.amazon.com/lambda/latest/dg/API_UpdateFunctionConfiguration.html\n */\nexport const VERSION_LOCKED: { [key: string]: boolean } = {\n  // locked to the version\n  Architectures: true,\n  Code: true,\n  DeadLetterConfig: true,\n  Description: true,\n  Environment: true,\n  EphemeralStorage: true,\n  FileSystemConfigs: true,\n  FunctionName: true,\n  Handler: true,\n  ImageConfig: true,\n  KmsKeyArn: true,\n  Layers: true,\n  MemorySize: true,\n  PackageType: true,\n  Role: true,\n  Runtime: true,\n  Timeout: true,\n  TracingConfig: true,\n  VpcConfig: true,\n\n  // not locked to the version\n  CodeSigningConfigArn: false,\n  ReservedConcurrentExecutions: false,\n  Tags: false,\n};\n\nfunction filterUsefulKeys(properties: any) {\n  const versionProps = { ...VERSION_LOCKED, ...LambdaFunction._VER_PROPS };\n  const unclassified = Object.entries(properties)\n    .filter(([k, v]) => v != null && !Object.keys(versionProps).includes(k))\n    .map(([k, _]) => k);\n  if (unclassified.length > 0) {\n    throw new Error(`The following properties are not recognized as version properties: [${unclassified}].`\n      + ' See the README of the aws-lambda module to learn more about this and to fix it.');\n  }\n  const notLocked = Object.entries(versionProps).filter(([_, v]) => !v).map(([k, _]) => k);\n  notLocked.forEach(p => delete properties[p]);\n\n  const ret: { [key: string]: any } = {};\n  Object.entries(properties).filter(([k, _]) => versionProps[k]).forEach(([k, v]) => ret[k] = v);\n  return ret;\n}\n\nfunction sortProperties(properties: any) {\n  const ret: any = {};\n  // We take all required properties in the order that they were historically,\n  // to make sure the hash we calculate is stable.\n  // There cannot be more required properties added in the future,\n  // as that would be a backwards-incompatible change.\n  const requiredProperties = ['Code', 'Handler', 'Role', 'Runtime'];\n  for (const requiredProperty of requiredProperties) {\n    ret[requiredProperty] = properties[requiredProperty];\n  }\n  // then, add all of the non-required properties,\n  // in the original order\n  for (const property of Object.keys(properties)) {\n    if (requiredProperties.indexOf(property) === -1) {\n      ret[property] = properties[property];\n    }\n  }\n  return ret;\n}\n"]}