Implement batch name resolution for emails

src/api/functions/uin.ts

@@ -1,10 +1,13 @@
 import {
+  BatchGetItemCommand,
   DynamoDBClient,
   PutItemCommand,
   QueryCommand,
   UpdateItemCommand,
 } from "@aws-sdk/client-dynamodb";
 import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+import { ValidLoggers } from "api/types.js";
+import { retryDynamoTransactionWithBackoff } from "api/utils.js";
 import { argon2id, hash } from "argon2";
 import { genericConfig } from "common/config.js";
 import {
@@ -235,3 +238,80 @@ export async function getUserIdByUin({
   const data = unmarshall(response.Items[0]) as { id: string };
   return data;
 }
+
+export async function batchGetUserInfo({
+  emails,
+  dynamoClient,
+  logger,
+}: {
+  emails: string[];
+  dynamoClient: DynamoDBClient;
+  logger: ValidLoggers;
+}) {
+  const results: Record<
+    string,
+    {
+      firstName?: string;
+      lastName?: string;
+    }
+  > = {};
+
+  // DynamoDB BatchGetItem has a limit of 100 items per request
+  const BATCH_SIZE = 100;
+
+  for (let i = 0; i < emails.length; i += BATCH_SIZE) {
+    const batch = emails.slice(i, i + BATCH_SIZE);
+
+    try {
+      await retryDynamoTransactionWithBackoff(
+        async () => {
+          const response = await dynamoClient.send(
+            new BatchGetItemCommand({
+              RequestItems: {
+                [genericConfig.UserInfoTable]: {
+                  Keys: batch.map((email) => ({
+                    id: { S: email },
+                  })),
+                  ProjectionExpression: "id, firstName, lastName",
+                },
+              },
+            }),
+          );
+
+          // Process responses
+          const items = response.Responses?.[genericConfig.UserInfoTable] || [];
+          for (const item of items) {
+            const email = item.id?.S;
+            if (email) {
+              results[email] = {
+                firstName: item.firstName?.S,
+                lastName: item.lastName?.S,
+              };
+            }
+          }
+
+          // If there are unprocessed keys, throw to trigger retry
+          if (
+            response.UnprocessedKeys &&
+            Object.keys(response.UnprocessedKeys).length > 0
+          ) {
+            const error = new Error(
+              "UnprocessedKeys present - triggering retry",
+            );
+            error.name = "TransactionCanceledException";
+            throw error;
+          }
+        },
+        logger,
+        `batchGetUserInfo (batch ${i / BATCH_SIZE + 1})`,
+      );
+    } catch (error) {
+      logger.warn(
+        `Failed to fetch batch ${i / BATCH_SIZE + 1} after retries, returning partial results`,
+        { error },
+      );
+    }
+  }
+
+  return results;
+}

src/api/routes/user.ts

@@ -9,10 +9,16 @@ import {
 } from "common/errors/index.js";
 import * as z from "zod/v4";
 import {
+  batchResolveUserInfoRequest,
+  batchResolveUserInfoResponse,
   searchUserByUinRequest,
   searchUserByUinResponse,
 } from "common/types/user.js";
-import { getUinHash, getUserIdByUin } from "api/functions/uin.js";
+import {
+  batchGetUserInfo,
+  getUinHash,
+  getUserIdByUin,
+} from "api/functions/uin.js";
 import { FastifyZodOpenApiTypeProvider } from "fastify-zod-openapi";
 import { QueryCommand } from "@aws-sdk/client-dynamodb";
 import { genericConfig } from "common/config.js";
@@ -58,6 +64,38 @@ const userRoute: FastifyPluginAsync = async (fastify, _options) => {
       );
     },
   );
+  fastify.withTypeProvider<FastifyZodOpenApiTypeProvider>().post(
+    "/batchResolveInfo",
+    {
+      schema: withRoles(
+        [],
+        withTags(["Generic"], {
+          summary: "Resolve user emails to user info.",
+          body: batchResolveUserInfoRequest,
+          response: {
+            200: {
+              description: "The search was performed.",
+              content: {
+                "application/json": {
+                  schema: batchResolveUserInfoResponse,
+                },
+              },
+            },
+          },
+        }),
+      ),
+      onRequest: fastify.authorizeFromSchema,
+    },
+    async (request, reply) => {
+      return reply.send(
+        await batchGetUserInfo({
+          dynamoClient: fastify.dynamoClient,
+          emails: request.body.emails,
+          logger: request.log,
+        }),
+      );
+    },
+  );
 };
 
 export default userRoute;

src/common/types/user.ts

@@ -8,3 +8,18 @@ export const searchUserByUinRequest = z.object({
 export const searchUserByUinResponse = z.object({
   email: z.email(),
 });
+
+export const batchResolveUserInfoRequest = z.object({
+  emails: z.array(z.email()).min(1)
+})
+
+
+export const batchResolveUserInfoResponse = z.object({
+}).catchall(
+  z.object({
+    firstName: z.string().optional(),
+    lastName: z.string().optional()
+  })
+);
+
+export type BatchResolveUserInfoResponse = z.infer<typeof batchResolveUserInfoResponse>;

src/ui/App.tsx

@@ -8,6 +8,7 @@ import { Notifications } from "@mantine/notifications";
 
 import ColorSchemeContext from "./ColorSchemeContext";
 import { Router } from "./Router";
+import { UserResolverProvider } from "./components/NameOptionalCard";
 
 export default function App() {
   const preferredColorScheme = useColorScheme();
@@ -25,7 +26,9 @@ export default function App() {
         forceColorScheme={colorScheme}
       >
         <Notifications position="top-right" />
-        <Router />
+        <UserResolverProvider>
+          <Router />
+        </UserResolverProvider>
       </MantineProvider>
     </ColorSchemeContext.Provider>
   );