Merge pull request #71 from aws-solutions/release/v1.2.2

Author: abhirpat

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.2] - 2026-06-29
+
+### Fixed
+
+- Stacks could become stuck in `DELETE_FAILED` state during teardown.
+- Non-admin participants received a "You don't have permission" error on the live race page.
+- Corrected the minimum speed helper text on the create model page to match the API validation value.
+
 ## [1.2.1] - 2026-06-22
 
 ### Security

solution-manifest.yaml

@@ -1,6 +1,6 @@
 id: SO0310
 name: deepracer-on-aws
-version: v1.2.1
+version: v1.2.2
 cloudformation_templates:
   - template: deepracer-on-aws.template
     main_template: true

source/apps/infra/lib/constructs/live-race/__tests__/liveRaceEvents.spec.ts

@@ -88,13 +88,26 @@ describe('LiveRaceEvents', () => {
         PolicyDocument: {
           Statement: Match.arrayWith([
             Match.objectLike({
-              Action: Match.arrayWith(['iot:ListTargetsForPolicy', 'iot:DetachPolicy']),
+              Action: 'iot:ListTargetsForPolicy',
               Effect: 'Allow',
             }),
           ]),
         },
       }),
     ).not.toThrow();
+    expect(() =>
+      template.hasResourceProperties('AWS::IAM::Policy', {
+        PolicyDocument: {
+          Statement: Match.arrayWith([
+            Match.objectLike({
+              Action: 'iot:DetachPolicy',
+              Effect: 'Allow',
+              Resource: '*',
+            }),
+          ]),
+        },
+      }),
+    ).not.toThrow();
     expect(() =>
       template.hasResourceProperties('AWS::IAM::Policy', {
         PolicyDocument: {

source/apps/infra/lib/constructs/live-race/liveRaceEvents.ts

@@ -90,10 +90,19 @@ export class LiveRaceEvents extends Construct {
     deletePolicyEventHandlerFn.addToRolePolicy(
       new PolicyStatement({
         effect: Effect.ALLOW,
-        actions: ['iot:ListTargetsForPolicy', 'iot:DetachPolicy'],
+        actions: ['iot:ListTargetsForPolicy'],
         resources: [this.spectatorPolicyArn],
       }),
     );
+    // iot:DetachPolicy evaluates against the target (a Cognito Identity ID, not ARN-able),
+    // so it must be scoped to '*'. Blast radius is bounded by the preceding ListTargetsForPolicy.
+    deletePolicyEventHandlerFn.addToRolePolicy(
+      new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: ['iot:DetachPolicy'],
+        resources: ['*'],
+      }),
+    );
     const deletePolicyIsCompleteFn = new NodeLambdaFunction(this, 'DeleteIoTPolicyIsCompleteFn', {
       entry: path.join(__dirname, '../../../../../libs/lambda/src/live-race/deleteIotPolicy.ts'),
       functionName: `${namespace}-LiveRace-DeleteIoTPolicy-IsComplete`,

source/apps/website/src/hooks/useLiveRaceMqtt.ts

@@ -32,7 +32,13 @@ const BASE_RETRY_MS = 1000;
 const MAX_RETRY_MS = 30000;
 
 const getRetryDelay = (attempt: number): number => {
-  return Math.min(BASE_RETRY_MS * Math.pow(2, attempt), MAX_RETRY_MS) + Math.random() * 1000;
+  //  Create holding unsigned 32 bit array of length 1
+  const array = new Uint32Array(1);
+  //  Modify array in place
+  crypto.getRandomValues(array);
+  //  Normalize to [0, 1) (exclusive of 1). 0xffffffff + 1 is used because we provided 32 bit array; need to divide by Uint32.Max + 1
+  const random = array[0] / (0xffffffff + 1);
+  return Math.min(BASE_RETRY_MS * Math.pow(2, attempt), MAX_RETRY_MS) + random * 1000;
 };
 
 const callAttachPolicy = async (signal: AbortSignal): Promise<void> => {

source/apps/website/src/i18n/en/createModel.json

@@ -147,7 +147,7 @@
       "rightSteeringAngle": "Right steering angle",
       "rightSteeringAngleConstraintText": "Values are between -30 and 0.",
       "minimumSpeed": "Minimum speed",
-      "speedConstraintText": "Values are between 0.1 and 4.",
+      "speedConstraintText": "Values are between 0.5 and 4.",
       "maximumSpeed": "Maximum speed",
       "resetButton": "Reset to default values",
       "graphLabel": "Dynamic sector graph",

source/apps/website/src/pages/LiveRace/LiveRace.spec.tsx

@@ -14,7 +14,6 @@ import {
   Leaderboard,
   LiveEventStatus,
   ListLiveQueueItemsCommand,
-  ListProfilesCommand,
 } from '@deepracer-indy/typescript-client';
 import { act, cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
@@ -1207,40 +1206,19 @@ describe('<LiveRace />', () => {
         status: 'IN_PROGRESS' as const,
         resetCount: 0,
         submittedAt: new Date('2026-01-01T00:00:00Z'),
+        avatar: { top: 'short', skinColor: 'light', eyes: 'default' },
       },
     ];
 
-    it('renders RacerInfoBanner when profiles and queue items are both available', async () => {
-      mockDeepRacerClient.on(GetLiveRaceStateCommand).resolves(baseRaceState);
-      mockDeepRacerClient.on(ListLiveQueueItemsCommand).resolves({ items: queueItems });
-      mockDeepRacerClient.on(ListProfilesCommand).resolves({
-        profiles: [
-          {
-            profileId: 'profile-alice',
-            alias: 'alice',
-            avatar: { top: 'short', skinColor: 'light', eyes: 'default' },
-            computeMinutesUsed: 0,
-            computeMinutesQueued: 0,
-            maxTotalComputeMinutes: 600,
-            maxModelCount: 10,
-          },
-        ],
-      });
-
-      render(<LiveRace />, {
-        componentRoute: '/races/:leaderboardId/live',
-        initialRouteEntries: ['/races/test-lb/live'],
-      });
-
-      await waitFor(() => {
-        expect(screen.getByTestId('racer-info-banner')).toBeInTheDocument();
+    it('renders RacerInfoBanner when queue items are available with avatar data', async () => {
+      mockDeepRacerClient.on(GetLiveRaceStateCommand).resolves({
+        ...baseRaceState,
+        currentEvaluation: {
+          ...baseRaceState.currentEvaluation,
+          avatar: { top: 'short', skinColor: 'light', eyes: 'default' },
+        },
       });
-    });
-
-    it('renders RacerInfoBanner even when no matching profile exists (graceful fallback)', async () => {
-      mockDeepRacerClient.on(GetLiveRaceStateCommand).resolves(baseRaceState);
       mockDeepRacerClient.on(ListLiveQueueItemsCommand).resolves({ items: queueItems });
-      mockDeepRacerClient.on(ListProfilesCommand).resolves({ profiles: [] });
 
       render(<LiveRace />, {
         componentRoute: '/races/:leaderboardId/live',
@@ -1252,30 +1230,20 @@ describe('<LiveRace />', () => {
       });
     });
 
-    it('renders RacerInfoBanner even when profiles resolve after queue items', async () => {
+    it('renders RacerInfoBanner even when avatar is missing (graceful fallback)', async () => {
       mockDeepRacerClient.on(GetLiveRaceStateCommand).resolves(baseRaceState);
-      mockDeepRacerClient.on(ListLiveQueueItemsCommand).resolves({ items: queueItems });
-
-      let resolveProfiles!: (value: unknown) => void;
-      mockDeepRacerClient.on(ListProfilesCommand).callsFake(
-        () =>
-          new Promise((resolve) => {
-            resolveProfiles = resolve;
-          }),
-      );
+      mockDeepRacerClient.on(ListLiveQueueItemsCommand).resolves({
+        items: [{ ...queueItems[0], avatar: undefined }],
+      });
 
       render(<LiveRace />, {
         componentRoute: '/races/:leaderboardId/live',
         initialRouteEntries: ['/races/test-lb/live'],
       });
 
-      // Banner renders before profiles arrive
       await waitFor(() => {
         expect(screen.getByTestId('racer-info-banner')).toBeInTheDocument();
       });
-
-      // Profiles resolve late — should not crash
-      resolveProfiles({ profiles: [] });
     });
   });
 });

source/apps/website/src/pages/LiveRace/LiveRace.tsx

@@ -12,7 +12,7 @@ import ProgressBar from '@cloudscape-design/components/progress-bar';
 import SpaceBetween from '@cloudscape-design/components/space-between';
 import StatusIndicator from '@cloudscape-design/components/status-indicator';
 import { UserGroups } from '@deepracer-indy/typescript-client';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useParams, useSearchParams } from 'react-router-dom';
 
@@ -34,7 +34,7 @@ import {
   useReorderLiveQueueMutation,
   useResetLiveQueueModelMutation,
 } from '#services/deepRacer/leaderboardsApi.js';
-import { useGetProfileQuery, useListProfilesQuery } from '#services/deepRacer/profileApi.js';
+import { useGetProfileQuery } from '#services/deepRacer/profileApi.js';
 import { displayInfoNotification, displaySuccessNotification } from '#store/notifications/notificationsSlice.js';
 import { checkUserGroupMembership } from '#utils/authUtils.js';
 import { millisToMinutesAndSeconds } from '#utils/dateTimeUtils.js';
@@ -88,7 +88,6 @@ const LiveRace = ({ __forceFacilitator }: LiveRaceProps = {}) => {
   );
   const { data: leaderboard } = useGetLeaderboardQuery({ leaderboardId });
   const { data: profile } = useGetProfileQuery();
-  const { data: profilesData } = useListProfilesQuery();
 
   // Seed reducer state from REST response
   useEffect(() => {
@@ -115,6 +114,7 @@ const LiveRace = ({ __forceFacilitator }: LiveRaceProps = {}) => {
         ? {
             participantName: liveRaceState.currentEvaluation.participantName,
             modelName: liveRaceState.currentEvaluation.modelName,
+            currentAvatar: liveRaceState.currentEvaluation.avatar ?? null,
             streamUrl: liveRaceState.currentEvaluation.streamUrl ?? null,
             isExecutionRunning: true,
           }
@@ -138,10 +138,6 @@ const LiveRace = ({ __forceFacilitator }: LiveRaceProps = {}) => {
 
   // Seed queue items from REST response
   const lastQueueRef = useRef<string>('');
-  const profileAvatarMap = useMemo(
-    () => new Map((profilesData ?? []).map((p) => [p.profileId, p.avatar])),
-    [profilesData],
-  );
   useEffect(() => {
     if (!liveQueueData?.items) return;
     const key = liveQueueData.items.map((i) => `${i.submissionId}:${i.status}`).join(',');
@@ -155,7 +151,7 @@ const LiveRace = ({ __forceFacilitator }: LiveRaceProps = {}) => {
       queuePosition: item.queuePosition,
       status: item.status as 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED',
       submittedAt: typeof item.submittedAt === 'string' ? item.submittedAt : new Date(item.submittedAt).toISOString(),
-      avatar: profileAvatarMap.get(item.profileId),
+      avatar: item.avatar,
     }));
     const nextPending = items.find((i) => i.status === 'PENDING');
     setRaceState((prev) => ({
@@ -169,25 +165,7 @@ const LiveRace = ({ __forceFacilitator }: LiveRaceProps = {}) => {
           }
         : {}),
     }));
-  }, [liveQueueData, profileAvatarMap]);
-
-  // When profiles load after queue items, back-fill avatars on existing queue items
-  useEffect(() => {
-    if (!profilesData?.length) return;
-    setRaceState((prev) => {
-      const enriched = prev.queueItems.map((item) =>
-        item.avatar ? item : { ...item, avatar: profileAvatarMap.get(item.profileId ?? '') },
-      );
-      const currentItem = enriched.find(
-        (i) => i.participantName === prev.participantName && i.status === 'IN_PROGRESS',
-      );
-      return {
-        ...prev,
-        queueItems: enriched,
-        currentAvatar: currentItem?.avatar ?? prev.currentAvatar,
-      };
-    });
-  }, [profilesData, profileAvatarMap]);
+  }, [liveQueueData]);
 
   // Check facilitator role
 

source/libs/lambda/src/api/handlers/getLiveRaceState.ts

@@ -2,7 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Operation } from '@aws-smithy/server-common';
-import { leaderboardDao, liveQueueItemDao, rankingDao, submissionDao, ResourceId } from '@deepracer-indy/database';
+import {
+  leaderboardDao,
+  liveQueueItemDao,
+  profileDao,
+  rankingDao,
+  submissionDao,
+  ResourceId,
+} from '@deepracer-indy/database';
 import {
   BadRequestError,
   getGetLiveRaceStateHandler,
@@ -36,17 +43,20 @@ export const GetLiveRaceStateOperation: Operation<
   const currentItem = queue.find((queueItem) => queueItem.status === LiveQueueItemStatus.IN_PROGRESS);
 
   let streamUrl: string | undefined;
+  let avatar: Awaited<ReturnType<typeof profileDao.load>>['avatar'] | undefined;
   if (currentItem) {
-    try {
-      const submission = await submissionDao.get({
-        profileId: currentItem.profileId,
-        leaderboardId,
-        submissionId: currentItem.submissionId as ResourceId,
-      });
-      streamUrl = submission?.videoStreamUrl;
-    } catch {
-      /** no-op — streamUrl remains undefined */
-    }
+    const [submission, profile] = await Promise.all([
+      submissionDao
+        .get({
+          profileId: currentItem.profileId,
+          leaderboardId,
+          submissionId: currentItem.submissionId as ResourceId,
+        })
+        .catch(() => undefined),
+      profileDao.load({ profileId: currentItem.profileId }).catch(() => undefined),
+    ]);
+    streamUrl = submission?.videoStreamUrl;
+    avatar = profile?.avatar;
   }
 
   return {
@@ -65,6 +75,7 @@ export const GetLiveRaceStateOperation: Operation<
           modelName: currentItem.modelName,
           status: currentItem.status,
           streamUrl,
+          avatar,
         }
       : undefined,
     queue: {

source/libs/lambda/src/api/handlers/listLiveQueueItems.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Operation } from '@aws-smithy/server-common';
-import { liveQueueItemDao, type ResourceId } from '@deepracer-indy/database';
+import { liveQueueItemDao, profileDao, type ResourceId } from '@deepracer-indy/database';
 import {
   getListLiveQueueItemsHandler,
   type ListLiveQueueItemsServerInput,
@@ -22,6 +22,14 @@ export const ListLiveQueueItemsOperation: Operation<
   const leaderboardId = input.leaderboardId as ResourceId;
   const queueItems = await liveQueueItemDao.getQueue({ leaderboardId });
 
+  // Avatars live on the profile, not the queue item. Batch-load the unique profileIds
+  // referenced by the queue and attach each item's avatar from the resulting map.
+  const uniqueProfileIds = Array.from(new Set(queueItems.map((item) => item.profileId)));
+  const profiles = uniqueProfileIds.length
+    ? await profileDao.batchGet(uniqueProfileIds.map((profileId) => ({ profileId }))).catch(() => [])
+    : [];
+  const avatarByProfileId = new Map(profiles.map((profile) => [profile.profileId, profile.avatar]));
+
   const items: LiveQueueItem[] = queueItems.map((item) => ({
     leaderboardId: item.leaderboardId,
     submissionId: item.submissionId,
@@ -33,6 +41,7 @@ export const ListLiveQueueItemsOperation: Operation<
     status: item.status,
     resetCount: item.resetCount,
     submittedAt: new Date(item.submittedAt),
+    avatar: avatarByProfileId.get(item.profileId),
   }));
 
   return { items } satisfies ListLiveQueueItemsServerOutput;