updates layer to also use layername:version (#2316)

* updates layer to also use layername:version

Author: ykethan

.changeset/silent-files-appear.md

@@ -0,0 +1,6 @@
+---
+'@aws-amplify/backend-function': minor
+'@aws-amplify/backend': minor
+---
+
+updates layer to also use layername:version

packages/backend-function/src/factory.ts

@@ -46,8 +46,8 @@ import * as path from 'path';
 import { FunctionEnvironmentTranslator } from './function_env_translator.js';
 import { FunctionEnvironmentTypeGenerator } from './function_env_type_generator.js';
 import { FunctionLayerArnParser } from './layer_parser.js';
-import { convertFunctionSchedulesToRuleSchedules } from './schedule_parser.js';
 import { convertLoggingOptionsToCDK } from './logging_options_parser.js';
+import { convertFunctionSchedulesToRuleSchedules } from './schedule_parser.js';
 
 const functionStackType = 'function-Lambda';
 
@@ -148,6 +148,11 @@ export type FunctionProps = {
    * layers: {
    *    "@aws-lambda-powertools/logger": "arn:aws:lambda:<current-region>:094274105915:layer:AWSLambdaPowertoolsTypeScriptV2:11"
    * },
+   * or
+   * @example
+   * layers: {
+   *    "Sharp": "SharpLayer:1"
+   * },
    * @see [Amplify documentation for Lambda layers](https://docs.amplify.aws/react/build-a-backend/functions/add-lambda-layers)
    * @see [AWS documentation for Lambda layers](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html)
    */
@@ -225,8 +230,7 @@ class FunctionFactory implements ConstructFactory<AmplifyFunction> {
   ): HydratedFunctionProps => {
     const name = this.resolveName();
     resourceNameValidator?.validate(name);
-    const parser = new FunctionLayerArnParser();
-    const layers = parser.parseLayers(this.props.layers ?? {}, name);
+
     return {
       name,
       entry: this.resolveEntry(),
@@ -236,7 +240,7 @@ class FunctionFactory implements ConstructFactory<AmplifyFunction> {
       runtime: this.resolveRuntime(),
       schedule: this.resolveSchedule(),
       bundling: this.resolveBundling(),
-      layers,
+      layers: this.props.layers ?? {},
       resourceGroupName: this.props.resourceGroupName ?? 'function',
       logging: this.props.logging ?? {},
     };
@@ -413,8 +417,18 @@ class FunctionGenerator implements ConstructContainerEntryGenerator {
     scope,
     backendSecretResolver,
   }: GenerateContainerEntryProps) => {
-    // resolve layers to LayerVersion objects for the NodejsFunction constructor using the scope.
-    const resolvedLayers = Object.entries(this.props.layers).map(([key, arn]) =>
+    // Move layer resolution here where we have access to scope
+    const parser = new FunctionLayerArnParser(
+      Stack.of(scope).region,
+      Stack.of(scope).account
+    );
+    const resolvedLayerArns = parser.parseLayers(
+      this.props.layers ?? {},
+      this.props.name
+    );
+
+    // resolve layers to LayerVersion objects for the NodejsFunction constructor
+    const resolvedLayers = Object.entries(resolvedLayerArns).map(([key, arn]) =>
       LayerVersion.fromLayerVersionArn(
         scope,
         `${this.props.name}-${key}-layer`,

packages/backend-function/src/layer_parser.test.ts

@@ -10,12 +10,12 @@ import {
   ResourceNameValidator,
 } from '@aws-amplify/plugin-types';
 import { App, Stack } from 'aws-cdk-lib';
-import { Template } from 'aws-cdk-lib/assertions';
+import { Match, Template } from 'aws-cdk-lib/assertions';
+import fsp from 'fs/promises';
 import assert from 'node:assert';
+import path from 'node:path';
 import { after, beforeEach, describe, it } from 'node:test';
 import { defineFunction } from './factory.js';
-import path from 'node:path';
-import fsp from 'fs/promises';
 
 const createStackAndSetContext = (): Stack => {
   const app = new App();
@@ -115,7 +115,7 @@ void describe('AmplifyFunctionFactory - Layers', () => {
       (error: AmplifyUserError) => {
         assert.strictEqual(
           error.message,
-          `Invalid ARN format for layer: ${invalidLayerArn}`
+          `Invalid format for layer: ${invalidLayerArn}`
         );
         assert.ok(error.resolution);
         return true;
@@ -184,4 +184,77 @@ void describe('AmplifyFunctionFactory - Layers', () => {
       Layers: [duplicateArn],
     });
   });
+
+  void it('accepts and converts name:version format to ARN', () => {
+    const functionFactory = defineFunction({
+      entry: './test-assets/default-lambda/handler.ts',
+      name: 'lambdaWithNameVersionLayer',
+      layers: {
+        myLayer: 'my-layer:1',
+      },
+    });
+    const lambda = functionFactory.getInstance(getInstanceProps);
+    const template = Template.fromStack(Stack.of(lambda.resources.lambda));
+
+    template.hasResourceProperties('AWS::Lambda::Function', {
+      Handler: 'index.handler',
+      Layers: [
+        {
+          'Fn::Join': [
+            '',
+            [
+              'arn:aws:lambda:',
+              { Ref: 'AWS::Region' },
+              ':',
+              { Ref: 'AWS::AccountId' },
+              ':layer:my-layer:1',
+            ],
+          ],
+        },
+      ],
+    });
+  });
+
+  void it('throws an error for invalid name:version format', () => {
+    const invalidFormat = 'my-layer'; // missing version number
+    const functionFactory = defineFunction({
+      entry: './test-assets/default-lambda/handler.ts',
+      name: 'lambdaWithInvalidNameVersion',
+      layers: {
+        myLayer: invalidFormat,
+      },
+    });
+
+    assert.throws(
+      () => functionFactory.getInstance(getInstanceProps),
+      (error: AmplifyUserError) => {
+        assert.strictEqual(
+          error.message,
+          `Invalid format for layer: ${invalidFormat}`
+        );
+        assert.ok(error.resolution);
+        return true;
+      }
+    );
+  });
+
+  void it('accepts mixed format of ARNs and name:version', () => {
+    const fullArn =
+      'arn:aws:lambda:us-east-1:123456789012:layer:full-arn-layer:1';
+    const functionFactory = defineFunction({
+      entry: './test-assets/default-lambda/handler.ts',
+      name: 'lambdaWithMixedLayerFormats',
+      layers: {
+        fullArnLayer: fullArn,
+        nameVersionLayer: 'name-version-layer:2',
+      },
+    });
+    const lambda = functionFactory.getInstance(getInstanceProps);
+    const template = Template.fromStack(Stack.of(lambda.resources.lambda));
+
+    template.hasResourceProperties('AWS::Lambda::Function', {
+      Handler: 'index.handler',
+      Layers: Match.arrayWith([fullArn]),
+    });
+  });
 });

packages/backend-function/src/layer_parser.ts

@@ -7,13 +7,26 @@ export class FunctionLayerArnParser {
   private arnPattern = new RegExp(
     'arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+'
   );
+  private nameVersionPattern = new RegExp('^[a-zA-Z0-9-_]+:[0-9]+$');
+
+  /**
+   * Creates a new FunctionLayerArnParser
+   * @param region - AWS region
+   * @param account - AWS account ID
+   */
+  constructor(
+    private readonly region: string,
+    private readonly account: string
+  ) {}
 
   /**
    * Parse the layers for a function
-   * @param layers - Layers to be attached to the function
+   * @param layers - Layers to be attached to the function. Each layer can be specified as either:
+   *                - A full ARN (arn:aws:lambda:<region>:<account>:layer:<name>:<version>)
+   *                - A name:version format (e.g., "my-layer:1")
    * @param functionName - Name of the function
-   * @returns Valid layers for the function
-   * @throws AmplifyUserError if the layer ARN is invalid
+   * @returns Valid layers for the function with resolved ARNs
+   * @throws AmplifyUserError if the layer ARN or name:version format is invalid
    * @throws AmplifyUserError if the number of layers exceeds the limit
    */
   parseLayers(
@@ -23,36 +36,56 @@ export class FunctionLayerArnParser {
     const validLayers: Record<string, string> = {};
     const uniqueArns = new Set<string>();
 
-    for (const [key, arn] of Object.entries(layers)) {
-      if (!this.isValidLayerArn(arn)) {
-        throw new AmplifyUserError('InvalidLayerArnFormatError', {
-          message: `Invalid ARN format for layer: ${arn}`,
-          resolution: `Update the layer ARN with the expected format: arn:aws:lambda:<current-region>:<account-id>:layer:<layer-name>:<version> for function: ${functionName}`,
+    for (const [key, value] of Object.entries(layers)) {
+      let arn: string;
+
+      if (this.isValidLayerArn(value)) {
+        // If it's already a valid ARN, use it as is
+        arn = value;
+      } else if (this.isValidNameVersion(value)) {
+        // If it's in name:version format, construct the ARN using provided region and account
+        const [name, version] = value.split(':');
+        arn = `arn:aws:lambda:${this.region}:${this.account}:layer:${name}:${version}`;
+      } else {
+        throw new AmplifyUserError('InvalidLayerFormatError', {
+          message: `Invalid format for layer: ${value}`,
+          resolution: `Layer must be either a full ARN (arn:aws:lambda:<region>:<account>:layer:<name>:<version>) or name:version format for function: ${functionName}`,
         });
       }
 
-      // Add to validLayers and uniqueArns only if the ARN hasn't been added already
+      // Ensure we don't add duplicate ARNs
       if (!uniqueArns.has(arn)) {
         uniqueArns.add(arn);
         validLayers[key] = arn;
       }
     }
 
-    // Validate the number of unique layers
     this.validateLayerCount(uniqueArns);
-
     return validLayers;
   }
 
   /**
    * Validate the ARN format for a Lambda Layer
+   * @param arn - The ARN string to validate
+   * @returns boolean indicating if the ARN format is valid
    */
   private isValidLayerArn(arn: string): boolean {
     return this.arnPattern.test(arn);
   }
 
+  /**
+   * Validate the name:version format for a Lambda Layer
+   * @param value - The string to validate in format "name:version"
+   * @returns boolean indicating if the format is valid
+   */
+  private isValidNameVersion(value: string): boolean {
+    return this.nameVersionPattern.test(value);
+  }
+
   /**
    * Validate the number of layers attached to a function
+   * @param uniqueArns - Set of unique layer ARNs
+   * @throws AmplifyUserError if the number of layers exceeds 5
    * @see https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution
    */
   private validateLayerCount(uniqueArns: Set<string>): void {