fix(slack/onboard-llmo): fire and forget onboarding process

Author: cwjwisse

src/support/slack/actions/onboard-llmo-modal.js

@@ -670,8 +670,7 @@ export function onboardLLMOModal(lambdaContext) {
         originalThreadTs,
       });
 
-      // eslint-disable-next-line max-statements-per-line
-      await new Promise((resolve) => { setTimeout(resolve, 500); });
+      // Acknowledge the modal immediately to avoid Slack's 3-second timeout
       await ack();
 
       // Create a slack context for the onboarding process
@@ -692,9 +691,14 @@ export function onboardLLMOModal(lambdaContext) {
         threadTs: responseThreadTs,
       };
 
-      await onboardSite({
+      // Fire-and-forget: Start the onboarding process without awaiting
+      // This allows the handler to return immediately after ack() while the
+      // onboarding continues in the background
+      onboardSite({
         brandName, baseURL: brandURL, imsOrgId, deliveryType,
-      }, lambdaContext, slackContext);
+      }, lambdaContext, slackContext).catch((error) => {
+        log.error(`Error in background onboarding for site ${brandURL}:`, error);
+      });
 
       log.debug(`Onboard LLMO modal processed for user ${user.id}, site ${brandURL}`);
     } catch (e) {

test/support/slack/actions/onboard-llmo-modal.test.js

@@ -1188,7 +1188,62 @@ example-com:
       expect(mockAck).to.have.been.calledOnce;
     });
 
-    it('should print error message if onboarding throws an error', async () => {
+    it('should return immediately after ack without waiting for onboarding to complete', async () => {
+      const mockBody = {
+        view: {
+          state: {
+            values: {
+              brand_name_input: {
+                brand_name: { value: 'Test Brand' },
+              },
+              ims_org_input: {
+                ims_org_id: { value: 'ABC123@AdobeOrg' },
+              },
+              delivery_type_input: {
+                delivery_type: {
+                  selected_option: { value: 'aem_edge' },
+                },
+              },
+            },
+          },
+          private_metadata: JSON.stringify({
+            originalChannel: 'C1234567890',
+            originalThreadTs: '1234567890.123456',
+            brandURL: 'https://example.com',
+          }),
+        },
+        user: { id: 'U1234567890' },
+      };
+
+      const mockAck = sandbox.stub();
+      const mockClient = {
+        chat: {
+          postMessage: sandbox.stub().resolves(),
+        },
+      };
+
+      // Create a slow onboarding process to verify fire-and-forget behavior
+      const lambdaCtx = createDefaultMockLambdaCtx(sandbox);
+      const slowOnboardingPromise = new Promise((resolve) => {
+        setTimeout(resolve, 1000); // Simulate slow operation
+      });
+      lambdaCtx.dataAccess.Site.findByBaseURL = sandbox.stub().returns(slowOnboardingPromise);
+
+      const { onboardLLMOModal } = mockedModule;
+      const handler = onboardLLMOModal(lambdaCtx);
+
+      const startTime = Date.now();
+      await handler({ ack: mockAck, body: mockBody, client: mockClient });
+      const endTime = Date.now();
+
+      // Handler should return quickly (well under 1 second), not wait for the slow operation
+      expect(endTime - startTime).to.be.lessThan(500);
+      expect(mockAck).to.have.been.calledOnce;
+      expect(mockAck).to.have.been.calledWith(); // Called without errors
+      expect(lambdaCtx.log.debug).to.have.been.calledWith('Onboard LLMO modal processed for user U1234567890, site https://example.com');
+    });
+
+    it('should log error if onboarding throws an error in background', async () => {
       const mockBody = {
         view: {
           state: {
@@ -1224,13 +1279,20 @@ example-com:
 
       await handler({ ack: mockAck, body: mockBody, client: mockClient });
 
-      expect(lambdaCtx.log.error).to.have.been.calledWith('Error handling onboard site modal:', sinon.match.instanceOf(Error));
-      expect(mockAck).to.have.been.calledWith({
-        response_action: 'errors',
-        errors: {
-          brand_name_input: 'There was an error processing the onboarding request.',
-        },
+      // The handler should acknowledge successfully even if onboarding will fail
+      expect(mockAck).to.have.been.calledOnce;
+      expect(mockAck).to.have.been.calledWith();
+
+      // Wait a bit for the background promise to settle
+      await new Promise((resolve) => {
+        setTimeout(resolve, 100);
       });
+
+      // The error should be logged by the background error handler
+      expect(lambdaCtx.log.error).to.have.been.calledWith(
+        sinon.match(/Error in background onboarding for site/),
+        sinon.match.instanceOf(Error),
+      );
     });
 
     it('should return validation error when IMS org ID is not provided', async () => {