Merge pull request #120 from linuxfoundation/feat/lfxv2-643-get-user-profile-from-auth-service

feat(auth-service): user profile from auth-service

Author: mauriciozanettisalomao

apps/lfx-one/src/server/controllers/profile.controller.ts

@@ -1,7 +1,14 @@
 // Copyright The Linux Foundation and each contributor to LFX.
 // SPDX-License-Identifier: MIT
 
-import { AddEmailRequest, CombinedProfile, ProfileUpdateRequest, UpdateEmailPreferencesRequest, UserMetadataUpdateRequest } from '@lfx-one/shared/interfaces';
+import {
+  AddEmailRequest,
+  CombinedProfile,
+  ProfileUpdateRequest,
+  UpdateEmailPreferencesRequest,
+  UserMetadata,
+  UserMetadataUpdateRequest,
+} from '@lfx-one/shared/interfaces';
 import { NextFunction, Request, Response } from 'express';
 
 import { AuthenticationError, AuthorizationError, MicroserviceError, ResourceNotFoundError, ServiceValidationError } from '../errors';
@@ -41,7 +48,27 @@ export class ProfileController {
 
       let combinedProfile: CombinedProfile | null = null;
 
-      // Get combined profile using JOIN
+      // Step 1: Try to get user metadata from NATS first (authoritative source)
+      let natsUserData: UserMetadata | null = null;
+      try {
+        const natsResponse = await this.userService.getUserInfo(req, userId);
+        req.log.info({ userId, natsSuccess: natsResponse.success }, 'Fetched user data from NATS');
+
+        if (natsResponse.success && natsResponse.data) {
+          natsUserData = natsResponse.data;
+        }
+      } catch (error) {
+        // Log but don't fail - we'll fall back to Supabase
+        req.log.warn(
+          {
+            userId,
+            error: error instanceof Error ? error.message : error,
+          },
+          'Failed to fetch user data from NATS, will use Supabase as fallback'
+        );
+      }
+
+      // Step 2: Get user from Supabase
       const user = await this.supabaseService.getUser(userId);
 
       if (!user) {
@@ -54,12 +81,20 @@ export class ProfileController {
         return next(validationError);
       }
 
+      // Step 3: Merge NATS data into Supabase user if available
+      if (natsUserData) {
+        // Merge fields from NATS, preferring NATS data when available
+        if (natsUserData.given_name) user.first_name = natsUserData.given_name;
+        if (natsUserData.family_name) user.last_name = natsUserData.family_name;
+        // Note: email and username are not part of UserMetadata, they come from the user table
+      }
+
       combinedProfile = {
         user,
         profile: null,
       };
 
-      // Get profile details
+      // Step 4: Get profile details from Supabase
       const profile = await this.supabaseService.getProfile(user.id);
 
       // If no profile details exist, create them
@@ -72,9 +107,38 @@ export class ProfileController {
         combinedProfile.profile = profile;
       }
 
+      // Step 5: Merge NATS metadata into profile if available
+      if (natsUserData && combinedProfile.profile) {
+        // Merge all available fields from NATS into the profile
+        const fieldsToMerge: (keyof UserMetadata)[] = [
+          'name',
+          'given_name',
+          'family_name',
+          'picture',
+          'phone_number',
+          'address',
+          'city',
+          'state_province',
+          'postal_code',
+          'country',
+          'organization',
+          'job_title',
+          't_shirt_size',
+          'zoneinfo',
+        ];
+
+        const natsData = natsUserData;
+        fieldsToMerge.forEach((field) => {
+          if (natsData[field] !== undefined && natsData[field] !== null) {
+            (combinedProfile.profile as UserMetadata)[field] = natsData[field];
+          }
+        });
+      }
+
       Logger.success(req, 'get_current_user_profile', startTime, {
         user_id: user.id,
         has_profile_details: !!combinedProfile.profile,
+        used_nats_data: !!natsUserData,
       });
 
       res.json(combinedProfile);

apps/lfx-one/src/server/server.ts

@@ -160,7 +160,7 @@ const authConfig: ConfigParams = {
   authorizationParams: {
     response_type: 'code',
     audience: process.env['PCC_AUTH0_AUDIENCE'] || 'https://example.com',
-    scope: 'openid email profile access:api offline_access update:current_user_metadata',
+    scope: 'openid email profile access:api offline_access',
   },
   clientSecret: process.env['PCC_AUTH0_CLIENT_SECRET'] || 'bar',
   routes: {

apps/lfx-one/src/server/services/user.service.ts

@@ -7,6 +7,7 @@ import { UserMetadata, UserMetadataUpdateRequest, UserMetadataUpdateResponse } f
 import { Request } from 'express';
 
 import { serverLogger } from '../server';
+import { ResourceNotFoundError } from '../errors';
 import { NatsService } from './nats.service';
 
 /**
@@ -19,6 +20,54 @@ export class UserService {
     this.natsService = new NatsService();
   }
 
+  /**
+   * Fetch user information by username or email using NATS request-reply pattern
+   * The userArg is either a username or a sub (subject) or a user's token
+   * @param req - Express request object for logging
+   * @param userArg - Username, sub, or token
+   * @returns UserMetadataUpdateResponse object with success, data, and error
+   * @throws ResourceNotFoundError if user not found
+   */
+  public async getUserInfo(req: Request, userArg: string): Promise<UserMetadataUpdateResponse> {
+    const codec = this.natsService.getCodec();
+
+    try {
+      req.log.info({ userArgProvided: !!userArg }, 'Fetching user metadata via NATS');
+
+      const response = await this.natsService.request(NatsSubjects.USER_METADATA_READ, codec.encode(userArg), { timeout: NATS_CONFIG.REQUEST_TIMEOUT });
+
+      const responseText = codec.decode(response.data);
+
+      const userMetadata: UserMetadataUpdateResponse = JSON.parse(responseText);
+
+      if (!userMetadata || typeof userMetadata !== 'object') {
+        throw new ResourceNotFoundError('User', undefined, {
+          operation: 'get_user_info',
+          service: 'user_service',
+          path: '/nats/user-metadata-read',
+        });
+      }
+
+      return userMetadata;
+    } catch (error) {
+      if (error instanceof ResourceNotFoundError) {
+        throw error;
+      }
+
+      req.log.error({ error: error instanceof Error ? error.message : error, userArgProvided: !!userArg }, 'Failed to fetch user metadata via NATS');
+
+      if (error instanceof Error && (error.message.includes('timeout') || error.message.includes('503'))) {
+        throw new ResourceNotFoundError('User', undefined, {
+          operation: 'get_user_info',
+          service: 'user_service',
+          path: '/nats/user-metadata-read',
+        });
+      }
+
+      throw error;
+    }
+  }
+
   /**
    * Update user metadata through NATS
    * @param req - Express request object

packages/shared/src/interfaces/user-profile.interface.ts

@@ -160,5 +160,6 @@ export interface UserMetadataUpdateResponse {
   username: string;
   message?: string;
   updated_fields?: string[];
+  data?: UserMetadata;
   error?: string;
 }