add output and configuration for customer owned lambdas (#1029)

* add output and configuration for customer owned lambdas

* add back removed code

* refactor logic to add to backend output

* small api update

* prevent prototype-polluting assignment

* prevent prototype-polluting assignment

* small updates to deployed backend client

* update changeset

* use maps for lazyLists

* fix lint

* add test to throw when trying to enter a different version than existing version

* poke ci

* remove function outputs accumulator

* remove comment

* nit fixes

* add tests

* rename customerFunctions to definedFunctions

* nit fixes

Author: rtpascual

.changeset/brave-carrots-glow.md

@@ -0,0 +1,13 @@
+---
+'@aws-amplify/deployed-backend-client': minor
+'@aws-amplify/backend-output-schemas': minor
+'@aws-amplify/backend-output-storage': minor
+'@aws-amplify/backend-function': minor
+'@aws-amplify/backend-storage': patch
+'@aws-amplify/auth-construct-alpha': patch
+'@aws-amplify/platform-core': patch
+'@aws-amplify/plugin-types': patch
+'@aws-amplify/backend': patch
+---
+
+Add output and configuration for customer owned lambdas

packages/auth-construct/src/construct.test.ts

@@ -533,6 +533,7 @@ void describe('Auth construct', () => {
     const stubBackendOutputStorageStrategy: BackendOutputStorageStrategy<BackendOutputEntry> =
       {
         addBackendOutputEntry: storeOutputMock,
+        appendToBackendOutputList: storeOutputMock,
       };
 
     void beforeEach(() => {

packages/backend-function/package.json

@@ -18,6 +18,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
+    "@aws-amplify/backend-output-schemas": "^0.6.0",
     "@aws-amplify/backend-output-storage": "^0.3.1-beta.0",
     "@aws-amplify/plugin-types": "^0.8.0",
     "execa": "^8.0.1"

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

@@ -24,17 +24,18 @@ const createStackAndSetContext = (): Stack => {
 };
 
 void describe('AmplifyFunctionFactory', () => {
+  let rootStack: Stack;
   let getInstanceProps: ConstructFactoryGetInstanceProps;
 
   beforeEach(() => {
-    const stack = createStackAndSetContext();
+    rootStack = createStackAndSetContext();
 
     const constructContainer = new ConstructContainerStub(
-      new StackResolverStub(stack)
+      new StackResolverStub(rootStack)
     );
 
     const outputStorageStrategy = new StackMetadataBackendOutputStorageStrategy(
-      stack
+      rootStack
     );
 
     getInstanceProps = {
@@ -304,4 +305,35 @@ void describe('AmplifyFunctionFactory', () => {
       });
     });
   });
+
+  void describe('storeOutput', () => {
+    void it('stores output using the provided strategy', () => {
+      const functionFactory = defineFunction({
+        entry: './test-assets/default-lambda/handler.ts',
+        name: 'testLambdaName',
+      });
+      functionFactory.getInstance(getInstanceProps);
+      const template = Template.fromStack(rootStack);
+      // Getting output value is messy due to usage of Lazy to defer output value
+      const outputValue =
+        template.findOutputs('definedFunctions').definedFunctions.Value;
+      assert.deepStrictEqual(outputValue, {
+        ['Fn::Join']: [
+          '',
+          [
+            '["',
+            {
+              ['Fn::GetAtt']: [
+                /* eslint-disable spellcheck/spell-checker */
+                'functionNestedStackfunctionNestedStackResource1351588B',
+                'Outputs.functiontestLambdaNamelambda36106226Ref',
+                /* eslint-enable spellcheck/spell-checker */
+              ],
+            },
+            '"]',
+          ],
+        ],
+      });
+    });
+  });
 });

packages/backend-function/src/factory.ts

@@ -1,4 +1,5 @@
 import {
+  BackendOutputStorageStrategy,
   BackendSecret,
   BackendSecretResolver,
   ConstructContainerEntryGenerator,
@@ -21,6 +22,10 @@ import { FunctionEnvironmentTranslator } from './function_env_translator.js';
 import { Policy } from 'aws-cdk-lib/aws-iam';
 import { readFileSync } from 'fs';
 import { EOL } from 'os';
+import {
+  FunctionOutput,
+  functionOutputKey,
+} from '@aws-amplify/backend-output-schemas';
 
 /**
  * Entry point for defining a function in the Amplify ecosystem
@@ -95,9 +100,13 @@ class FunctionFactory implements ConstructFactory<AmplifyFunction> {
    */
   getInstance = ({
     constructContainer,
+    outputStorageStrategy,
   }: ConstructFactoryGetInstanceProps): AmplifyFunction => {
     if (!this.generator) {
-      this.generator = new FunctionGenerator(this.hydrateDefaults());
+      this.generator = new FunctionGenerator(
+        this.hydrateDefaults(),
+        outputStorageStrategy
+      );
     }
     return constructContainer.getOrCompute(this.generator) as AmplifyFunction;
   };
@@ -206,7 +215,10 @@ type HydratedFunctionProps = Required<FunctionProps>;
 class FunctionGenerator implements ConstructContainerEntryGenerator {
   readonly resourceGroupName = 'function';
 
-  constructor(private readonly props: HydratedFunctionProps) {}
+  constructor(
+    private readonly props: HydratedFunctionProps,
+    private readonly outputStorageStrategy: BackendOutputStorageStrategy<FunctionOutput>
+  ) {}
 
   generateContainerEntry = ({
     scope,
@@ -216,7 +228,8 @@ class FunctionGenerator implements ConstructContainerEntryGenerator {
       scope,
       this.props.name,
       this.props,
-      backendSecretResolver
+      backendSecretResolver,
+      this.outputStorageStrategy
     );
   };
 }
@@ -231,7 +244,8 @@ class AmplifyFunction
     scope: Construct,
     id: string,
     props: HydratedFunctionProps,
-    backendSecretResolver: BackendSecretResolver
+    backendSecretResolver: BackendSecretResolver,
+    outputStorageStrategy: BackendOutputStorageStrategy<FunctionOutput>
   ) {
     super(scope, id);
 
@@ -284,6 +298,8 @@ class AmplifyFunction
     this.resources = {
       lambda: functionLambda,
     };
+
+    this.storeOutput(outputStorageStrategy);
   }
 
   getResourceAccessAcceptor = () => ({
@@ -305,6 +321,20 @@ class AmplifyFunction
       });
     },
   });
+
+  /**
+   * Store storage outputs using provided strategy
+   */
+  private storeOutput = (
+    outputStorageStrategy: BackendOutputStorageStrategy<FunctionOutput>
+  ): void => {
+    outputStorageStrategy.appendToBackendOutputList(functionOutputKey, {
+      version: '1',
+      payload: {
+        definedFunctions: this.resources.lambda.functionName,
+      },
+    });
+  };
 }
 
 const isWholeNumberBetweenInclusive = (

packages/backend-function/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": { "rootDir": "src", "outDir": "lib" },
   "references": [
+    { "path": "../backend-output-schemas" },
     { "path": "../backend-output-storage" },
     { "path": "../plugin-types" },
     { "path": "../backend-platform-test-stubs" },

packages/backend-output-schemas/API.md

@@ -54,6 +54,12 @@ export type CustomOutput = z.infer<typeof versionedCustomOutputSchema>;
 // @public
 export const customOutputKey = "AWS::Amplify::Custom";
 
+// @public (undocumented)
+export type FunctionOutput = z.infer<typeof versionedFunctionOutputSchema>;
+
+// @public
+export const functionOutputKey = "AWS::Amplify::Function";
+
 // @public (undocumented)
 export type GraphqlOutput = z.infer<typeof versionedGraphqlOutputSchema>;
 
@@ -329,6 +335,26 @@ export const unifiedBackendOutputSchema: z.ZodObject<{
             customOutputs: string;
         };
     }>]>>;
+    "AWS::Amplify::Function": z.ZodOptional<z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
+        version: z.ZodLiteral<"1">;
+        payload: z.ZodObject<{
+            definedFunctions: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            definedFunctions: string;
+        }, {
+            definedFunctions: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        version: "1";
+        payload: {
+            definedFunctions: string;
+        };
+    }, {
+        version: "1";
+        payload: {
+            definedFunctions: string;
+        };
+    }>]>>;
 }, "strip", z.ZodTypeAny, {
     "AWS::Amplify::Platform"?: {
         version: "1";
@@ -391,6 +417,12 @@ export const unifiedBackendOutputSchema: z.ZodObject<{
             customOutputs: string;
         };
     } | undefined;
+    "AWS::Amplify::Function"?: {
+        version: "1";
+        payload: {
+            definedFunctions: string;
+        };
+    } | undefined;
 }, {
     "AWS::Amplify::Platform"?: {
         version: "1";
@@ -453,6 +485,12 @@ export const unifiedBackendOutputSchema: z.ZodObject<{
             customOutputs: string;
         };
     } | undefined;
+    "AWS::Amplify::Function"?: {
+        version: "1";
+        payload: {
+            definedFunctions: string;
+        };
+    } | undefined;
 }>;
 
 // @public (undocumented)
@@ -609,6 +647,28 @@ export const versionedCustomOutputSchema: z.ZodDiscriminatedUnion<"version", [z.
     };
 }>]>;
 
+// @public (undocumented)
+export const versionedFunctionOutputSchema: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    payload: z.ZodObject<{
+        definedFunctions: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        definedFunctions: string;
+    }, {
+        definedFunctions: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: "1";
+    payload: {
+        definedFunctions: string;
+    };
+}, {
+    version: "1";
+    payload: {
+        definedFunctions: string;
+    };
+}>]>;
+
 // @public (undocumented)
 export const versionedGraphqlOutputSchema: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
     version: z.ZodLiteral<"1">;

packages/backend-output-schemas/src/function/index.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { functionOutputSchema as functionOutputSchemaV1 } from './v1';
+
+export const versionedFunctionOutputSchema = z.discriminatedUnion('version', [
+  functionOutputSchemaV1,
+  // this is where additional function major version schemas would go
+]);
+
+export type FunctionOutput = z.infer<typeof versionedFunctionOutputSchema>;

packages/backend-output-schemas/src/function/v1.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const functionOutputSchema = z.object({
+  version: z.literal('1'),
+  payload: z.object({
+    definedFunctions: z.string(), // JSON array as string
+  }),
+});

packages/backend-output-schemas/src/index.ts

@@ -4,6 +4,7 @@ import { versionedGraphqlOutputSchema } from './graphql/index.js';
 import { versionedStorageOutputSchema } from './storage/index.js';
 import { versionedStackOutputSchema } from './stack/index.js';
 import { versionedCustomOutputSchema } from './custom';
+import { versionedFunctionOutputSchema } from './function/index.js';
 
 /**
  * The auth, graphql and storage exports here are duplicated from the submodule exports in the package.json file
@@ -69,6 +70,20 @@ export * from './storage/index.js';
  */
 export const storageOutputKey = 'AWS::Amplify::Storage';
 
+/**
+ * ---------- Function exports ----------
+ */
+
+/**
+ * re-export the function output schema
+ */
+export * from './function/index.js';
+
+/**
+ * Expected key that function output is stored under
+ */
+export const functionOutputKey = 'AWS::Amplify::Function';
+
 /**
  * ---------- Unified exports ----------
  */
@@ -83,6 +98,7 @@ export const unifiedBackendOutputSchema = z.object({
   [graphqlOutputKey]: versionedGraphqlOutputSchema.optional(),
   [storageOutputKey]: versionedStorageOutputSchema.optional(),
   [customOutputKey]: versionedCustomOutputSchema.optional(),
+  [functionOutputKey]: versionedFunctionOutputSchema.optional(),
 });
 /**
  * This type is a subset of the BackendOutput type that is exposed by the platform.