Fix lambda logical version id for layers in same stack

lib/plugins/aws/package/compile/functions/index.js

@@ -441,98 +441,125 @@ class AwsCompileFunctions {
         fileHash.setEncoding('base64');
         versionHash.setEncoding('base64');
 
-        // Read the file in chunks and add them to the hash (saves memory and performance)
-        versionCompilationPromise = BbPromise.fromCallback(cb => {
-          const readStream = fs.createReadStream(artifactFilePath);
-
-          readStream
-            .on('data', chunk => {
-              fileHash.write(chunk);
-              versionHash.write(chunk);
-            })
-            .on('close', () => {
-              cb();
-            })
-            .on('error', error => {
-              cb(error);
+        // Include function and layer configuration in version id hash (without the Code part)
+        versionCompilationPromise = this.addFileContentsToHashes(artifactFilePath, [
+          fileHash,
+          versionHash,
+        ])
+          .then(() => {
+            // Include all referenced layer code in the version id hash
+            const functionProperties = _.omit(_.get(functionResource, 'Properties', {}), 'Code');
+            const layerProperties = this.extractLayerPropertiesFromFunction(
+              functionProperties,
+              cfTemplate
+            );
+
+            const layerZipFilePaths = [];
+            layerProperties.forEach(layer => {
+              const layerZipFileName = layer.properties.Properties.Content.S3Key.split(
+                path.sep
+              ).pop();
+              const layerZipFilePath = path.join(this.packagePath, layerZipFileName);
+              layerZipFilePaths.push(layerZipFilePath);
             });
-        }).then(() => {
-          // Include function configuration in version id hash (without the Code part)
-          const properties = _.omit(_.get(functionResource, 'Properties', {}), 'Code');
-          _.forOwn(properties, value => {
-            if (_.isObject(value)) {
-              versionHash.write(JSON.stringify(value));
-            } else {
-              versionHash.write(value != null ? String(value) : '');
-            }
-          });
 
-          // Finalize hashes
-          fileHash.end();
-          versionHash.end();
+            return BbPromise.map(layerZipFilePaths, zipFileName => {
+              return this.addFileContentsToHashes(zipFileName, [versionHash]);
+            });
+          })
+          .then(() => {
+            // Include function and layer configuration in version id hash (without the Code part)
+            const functionProperties = _.omit(_.get(functionResource, 'Properties', {}), 'Code');
+            const layerProperties = this.extractLayerPropertiesFromFunction(
+              functionProperties,
+              cfTemplate
+            );
 
-          const fileDigest = fileHash.read();
-          const versionDigest = versionHash.read();
+            const mappedLayerFunctionProperties = layerProperties.map(layer => {
+              const clonedLayer = _.cloneDeep(layer);
+              clonedLayer.properties.Properties.Content.S3Key = '';
+              return clonedLayer.properties;
+            });
 
-          const versionResource = this.cfLambdaVersionTemplate();
+            mappedLayerFunctionProperties.push(functionProperties);
+
+            mappedLayerFunctionProperties.forEach(property => {
+              Object.keys(property).forEach(key => {
+                const value = property[key];
+                if (_.isObject(value)) {
+                  versionHash.write(JSON.stringify(value));
+                } else {
+                  versionHash.write(value != null ? String(value) : '');
+                }
+              });
+            });
 
-          versionResource.Properties.CodeSha256 = fileDigest;
-          versionResource.Properties.FunctionName = { Ref: functionLogicalId };
-          if (functionObject.description) {
-            versionResource.Properties.Description = functionObject.description;
-          }
+            // Finalize hashes
+            fileHash.end();
+            versionHash.end();
 
-          // use the version SHA in the logical resource ID of the version because
-          // AWS::Lambda::Version resource will not support updates
-          const versionLogicalId = this.provider.naming.getLambdaVersionLogicalId(
-            functionName,
-            versionDigest
-          );
-          functionObject.versionLogicalId = versionLogicalId;
-          const newVersionObject = {
-            [versionLogicalId]: versionResource,
-          };
+            const fileDigest = fileHash.read();
+            const versionDigest = versionHash.read();
 
-          Object.assign(cfTemplate.Resources, newVersionObject);
+            const versionResource = this.cfLambdaVersionTemplate();
 
-          // Add function versions to Outputs section
-          const functionVersionOutputLogicalId = this.provider.naming.getLambdaVersionOutputLogicalId(
-            functionName
-          );
-          const newVersionOutput = this.cfOutputLatestVersionTemplate();
+            versionResource.Properties.CodeSha256 = fileDigest;
+            versionResource.Properties.FunctionName = { Ref: functionLogicalId };
+            if (functionObject.description) {
+              versionResource.Properties.Description = functionObject.description;
+            }
+
+            // use the version SHA in the logical resource ID of the version because
+            // AWS::Lambda::Version resource will not support updates
+            const versionLogicalId = this.provider.naming.getLambdaVersionLogicalId(
+              functionName,
+              versionDigest
+            );
+            functionObject.versionLogicalId = versionLogicalId;
+            const newVersionObject = {
+              [versionLogicalId]: versionResource,
+            };
 
-          newVersionOutput.Value = { Ref: versionLogicalId };
+            Object.assign(cfTemplate.Resources, newVersionObject);
 
-          Object.assign(cfTemplate.Outputs, {
-            [functionVersionOutputLogicalId]: newVersionOutput,
-          });
+            // Add function versions to Outputs section
+            const functionVersionOutputLogicalId = this.provider.naming.getLambdaVersionOutputLogicalId(
+              functionName
+            );
+            const newVersionOutput = this.cfOutputLatestVersionTemplate();
 
-          if (!functionObject.provisionedConcurrency) return;
-          if (!shouldVersionFunction) delete versionResource.DeletionPolicy;
+            newVersionOutput.Value = { Ref: versionLogicalId };
 
-          const provisionedConcurrency = Number(functionObject.provisionedConcurrency);
-          const aliasLogicalId = this.provider.naming.getLambdaProvisionedConcurrencyAliasLogicalId(
-            functionName
-          );
-          const aliasName = this.provider.naming.getLambdaProvisionedConcurrencyAliasName();
-
-          functionObject.targetAlias = { name: aliasName, logicalId: aliasLogicalId };
-
-          const aliasResource = {
-            Type: 'AWS::Lambda::Alias',
-            Properties: {
-              FunctionName: { Ref: functionLogicalId },
-              FunctionVersion: { 'Fn::GetAtt': [versionLogicalId, 'Version'] },
-              Name: aliasName,
-              ProvisionedConcurrencyConfig: {
-                ProvisionedConcurrentExecutions: provisionedConcurrency,
+            Object.assign(cfTemplate.Outputs, {
+              [functionVersionOutputLogicalId]: newVersionOutput,
+            });
+
+            if (!functionObject.provisionedConcurrency) return;
+            if (!shouldVersionFunction) delete versionResource.DeletionPolicy;
+
+            const provisionedConcurrency = Number(functionObject.provisionedConcurrency);
+            const aliasLogicalId = this.provider.naming.getLambdaProvisionedConcurrencyAliasLogicalId(
+              functionName
+            );
+            const aliasName = this.provider.naming.getLambdaProvisionedConcurrencyAliasName();
+
+            functionObject.targetAlias = { name: aliasName, logicalId: aliasLogicalId };
+
+            const aliasResource = {
+              Type: 'AWS::Lambda::Alias',
+              Properties: {
+                FunctionName: { Ref: functionLogicalId },
+                FunctionVersion: { 'Fn::GetAtt': [versionLogicalId, 'Version'] },
+                Name: aliasName,
+                ProvisionedConcurrencyConfig: {
+                  ProvisionedConcurrentExecutions: provisionedConcurrency,
+                },
               },
-            },
-            DependsOn: functionLogicalId,
-          };
+              DependsOn: functionLogicalId,
+            };
 
-          cfTemplate.Resources[aliasLogicalId] = aliasResource;
-        });
+            cfTemplate.Resources[aliasLogicalId] = aliasResource;
+          });
       } else {
         versionCompilationPromise = BbPromise.resolve();
       }
@@ -719,6 +746,48 @@ class AwsCompileFunctions {
       Value: 'Value',
     };
   }
+
+  addFileContentsToHashes(filePath, hashes) {
+    // Read the file in chunks and add them to the hash (saves memory and performance)
+    return new BbPromise((cb, reject) => {
+      const readStream = fs.createReadStream(filePath);
+      readStream
+        .on('data', chunk => {
+          hashes.forEach(hash => {
+            hash.write(chunk);
+          });
+        })
+        .on('close', () => {
+          cb();
+        })
+        .on('error', error => {
+          reject(new this.serverless.classes.Error(`Could not file content to hash: ${error}`));
+        });
+    });
+  }
+
+  extractLayerPropertiesFromFunction(functionProperties, cfTemplate) {
+    const cloudformationLayerVersionType = 'AWS::Lambda::LayerVersion';
+    const layerProperties = [];
+    Object.keys(functionProperties).forEach(key => {
+      const value = functionProperties[key];
+      if (!Array.isArray(value)) {
+        return;
+      }
+      value.forEach(potentialLayerObject => {
+        if (!_.isObject(potentialLayerObject)) {
+          return;
+        }
+        if ('Ref' in potentialLayerObject) {
+          const properties = cfTemplate.Resources[potentialLayerObject.Ref];
+          if (properties.Type === cloudformationLayerVersionType && properties.Properties) {
+            layerProperties.push({ name: potentialLayerObject.Ref, properties });
+          }
+        }
+      });
+    });
+    return layerProperties;
+  }
 }
 
 module.exports = AwsCompileFunctions;