feat(lambda): Support Lambda durable functions (#8416)

## Problem
Current invoking Lambda durable functions will fail on remote invoke
panel

## Solution
Apply $LATEST as qualifier when invoking Lambda durable functions

---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

---------

Co-authored-by: Renato Valenzuela <37676028+valerena@users.noreply.github.com>

Author: roger-zhangg

packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts

@@ -272,6 +272,13 @@ export class RemoteInvokeWebview extends VueWebview {
             qualifier = RemoteDebugController.instance.qualifier
         }
 
+        const isLMI = (this.data.LambdaFunctionNode?.configuration as any)?.CapacityProviderConfig
+        const isDurable = (this.data.LambdaFunctionNode?.configuration as any)?.DurableConfig
+        if (isDurable && !qualifier) {
+            // Make sure to invoke with qualifier for Durable Function, invoking unqualified will fail
+            qualifier = isLMI ? '$LATEST.PUBLISHED' : '$LATEST'
+        }
+
         this.isInvoking = true
 
         // If debugging is active, reset the timer during invoke
@@ -284,7 +291,7 @@ export class RemoteInvokeWebview extends VueWebview {
         await telemetry.lambda_invokeRemote.run(async (span) => {
             try {
                 let funcResponse
-                const isLMI = (this.data.LambdaFunctionNode?.configuration as any)?.CapacityProviderConfig
+
                 if (remoteDebugEnabled) {
                     funcResponse = await this.clientDebug.invoke(this.data.FunctionArn, input, qualifier)
                 } else if (isLMI) {
@@ -313,6 +320,7 @@ export class RemoteInvokeWebview extends VueWebview {
                 this.channel.appendLine('')
             } finally {
                 let action = remoteDebugEnabled ? 'debug' : 'invoke'
+                action = `${action}${isDurable ? '-durable' : ''}${isLMI ? '-lmi' : ''}`
                 if (!this.data.isLambdaRemote) {
                     action = `${action}LocalStack`
                 }

packages/core/src/test/lambda/vue/remoteInvoke/remoteInvoke.test.ts

@@ -18,16 +18,6 @@ describe('RemoteInvokeWebview', function () {
     const mockData = {
         FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
     } as any
-    const mockDataLMI = {
-        FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
-        LambdaFunctionNode: {
-            configuration: {
-                CapacityProviderConfig: {
-                    blah: 'blah',
-                },
-            },
-        },
-    } as any
     const input = '{"key": "value"}'
     const mockResponse = {
         LogResult: Buffer.from('Test log').toString('base64'),
@@ -46,21 +36,83 @@ describe('RemoteInvokeWebview', function () {
     afterEach(() => {
         sinon.restore()
     })
-    it('should invoke with a simple payload', async function () {
-        const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockData)
-        client.invoke.resolves(mockResponse)
-        await remoteInvokeWebview.invokeLambda(input)
-        sinon.assert.calledOnce(client.invoke)
-        sinon.assert.calledWith(client.invoke, mockData.FunctionArn, input, undefined, 'Tail')
-    })
+    const invokeScenarios: {
+        name: string
+        data: any
+        expectedQualifier: string | undefined
+        expectedLogType: 'Tail' | 'None'
+    }[] = [
+        {
+            name: 'should invoke with a simple payload',
+            data: mockData,
+            expectedQualifier: undefined,
+            expectedLogType: 'Tail',
+        },
+        {
+            name: 'should invoke with no tail in LMI',
+            data: {
+                FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
+                LambdaFunctionNode: {
+                    configuration: {
+                        CapacityProviderConfig: {
+                            blah: 'blah',
+                        },
+                    },
+                },
+            },
+            expectedQualifier: undefined,
+            expectedLogType: 'None',
+        },
+        {
+            name: 'should invoke $LATEST in Durable Function',
+            data: {
+                FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
+                LambdaFunctionNode: {
+                    configuration: {
+                        DurableConfig: {
+                            blah: 'blah',
+                        },
+                    },
+                },
+            },
+            expectedQualifier: '$LATEST',
+            expectedLogType: 'Tail',
+        },
+        {
+            name: 'should invoke $LATEST.PUBLISHED in LMI Durable Function',
+            data: {
+                FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
+                LambdaFunctionNode: {
+                    configuration: {
+                        DurableConfig: {
+                            blah: 'blah',
+                        },
+                        CapacityProviderConfig: {
+                            blah: 'blah',
+                        },
+                    },
+                },
+            },
+            expectedQualifier: '$LATEST.PUBLISHED',
+            expectedLogType: 'None',
+        },
+    ]
 
-    it('should invoke with no tail in LMI', async function () {
-        const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockDataLMI)
-        client.invoke.resolves(mockResponse)
-        await remoteInvokeWebview.invokeLambda(input)
-        sinon.assert.calledOnce(client.invoke)
-        sinon.assert.calledWith(client.invoke, mockData.FunctionArn, input, undefined, 'None')
-    })
+    for (const scenario of invokeScenarios) {
+        it(scenario.name, async function () {
+            const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, scenario.data)
+            client.invoke.resolves(mockResponse)
+            await remoteInvokeWebview.invokeLambda(input)
+            sinon.assert.calledOnce(client.invoke)
+            sinon.assert.calledWith(
+                client.invoke,
+                scenario.data.FunctionArn,
+                input,
+                scenario.expectedQualifier,
+                scenario.expectedLogType
+            )
+        })
+    }
 
     const mockEvent = {
         name: 'TestEvent',

packages/toolkit/.changes/next-release/Feature-6cc0d3e7-60d9-49c8-a3af-a8f3ea5ba36c.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Lambda Remote Invoke panel now supports invoking Lambda durable functions"
+}