commit d70d81df123d62a7557eb1d5ea76e3a8499b972d · dunkirk.sh/smokie

+84 -68

src/features/api/routes/projects.ts

···

       1
        
       import { db } from "../../../libs/db";

     

       2
       -
       import { users as usersTable } from "../../../libs/schema";

     

       3
        
       import { handleApiError } from "../../../libs/apiError";

     

       4
       -
       import { eq } from "drizzle-orm";

     

       5
       -
       import { fetchUserData } from "../../../libs/cachet";

     

       6
        
       

     

       7
        
       export type Project = {

     

       8
        
       	projectName: string;

     
···

       12
        
       	totalTakesTime: number;

     

       13
        
       	userId: string;

     

       14
        
       	userName?: string;

     

       0
        
       
     

       0
        
       
     

       15
        
       };

     

       16
        
       

     

       17
       -
       // Cache for user data from cachet

     

       18
       -
       const userCache: Record<string, { name: string; timestamp: number }> = {};

     

       19
       -
       const pendingRequests: Record<string, Promise<string>> = {};

     

       20
       -
       const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

     

       21
       -
       

     

       22
       -
       // Function to get user name from cache or fetch it

     

       23
       -
       async function getUserName(userId: string): Promise<string> {

     

       24
       -
       	const now = Date.now();

     

       25
       -
       

     

       26
       -
       	// Check if user data is in cache and still valid

     

       27
       -
       	if (userCache[userId] && now - userCache[userId].timestamp < CACHE_TTL) {

     

       28
       -
       		return userCache[userId].name;

     

       29
       -
       	}

     

       30
       -
       

     

       31
       -
       	// If there's already a pending request for this user, return that promise

     

       32
       -
       	// instead of creating a new request

     

       33
       -
       	if (pendingRequests[userId]) {

     

       34
       -
       		return pendingRequests[userId];

     

       35
       -
       	}

     

       36
       -
       

     

       37
       -
       	// Create a new promise for this user and store it

     

       38
       -
       	const fetchPromise = (async () => {

     

       39
       -
       		try {

     

       40
       -
       			const userData = await fetchUserData(userId);

     

       41
       -
       			const userName = userData?.displayName || "Unknown User";

     

       42
       -
       

     

       43
       -
       			userCache[userId] = {

     

       44
       -
       				name: userName,

     

       45
       -
       				timestamp: now,

     

       46
       -
       			};

     

       47
       -
       

     

       48
       -
       			return userName;

     

       49
       -
       		} catch (error) {

     

       50
       -
       			console.error("Error fetching user data:", error);

     

       51
       -
       			return "Unknown User";

     

       52
       -
       		} finally {

     

       53
       -
       			// Clean up the pending request when done

     

       54
       -
       			delete pendingRequests[userId];

     

       55
       -
       		}

     

       56
       -
       	})();

     

       57
       -
       

     

       58
       -
       	// Store the promise

     

       59
       -
       	pendingRequests[userId] = fetchPromise;

     

       60
       -
       

     

       61
       -
       	// Return the promise

     

       62
       -
       	return fetchPromise;

     

       63
       -
       }

     

       64
        
       

     

       65
        
       export async function projects(url: URL): Promise<Response> {

     

       66
        
       	const user = url.searchParams.get("user");

     

       67
        
       	try {

     

       68
       -
       		const projects = await db

     

       69
       -
       			.select({

     

       70
       -
       				projectName: usersTable.projectName,

     

       71
       -
       				projectDescription: usersTable.projectDescription,

     

       72
       -
       				projectBannerUrl: usersTable.projectBannerUrl,

     

       73
       -
       				totalTakesTime: usersTable.totalTakesTime,

     

       74
       -
       				userId: usersTable.id,

     

       75
       -
       			})

     

       76
       -
       			.from(usersTable)

     

       77
       -
       			.where(eq(usersTable.id, user ? user : usersTable.id));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78
        
       

     

       79
       -
       		if (projects.length === 0) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       			return new Response(

     

       81
        
       				JSON.stringify({

     

       82
        
       					projects: [],

     
···

       90
        
       		}

     

       91
        
       

     

       92
        
       		// Get unique user IDs

     

       93
       -
       		const userIds = [...new Set(projects.map((project) => project.userId))];

     

       0
        
       
     

       0
        
       
     

       94
        
       

     

       95
       -
       		// Fetch all user names from cache or API

     

       96
       -
       		const userNamesPromises = userIds.map((id) => getUserName(id));

     

       0
        
       
     

       0
        
       
     

       97
        
       		const userNames = await Promise.all(userNamesPromises);

     

       98
        
       

     

       99
        
       		// Create a map of user names

     
···

       103
        
       		});

     

       104
        
       

     

       105
        
       		// Add user names to projects

     

       106
       -
       		const projectsWithUserNames = projects.map((project) => ({

     

       107
        
       			...project,

     

       108
        
       			userName: userNameMap[project.userId] || "Unknown User",

     

       109
        
       		}));

     

       110
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       111
        
       		return new Response(

     

       112
        
       			JSON.stringify({

     

       113
       -
       				projects: user

     

       114
       -
       					? projectsWithUserNames[0]

     

       115
       -
       					: projectsWithUserNames,

     

       116
        
       			}),

     

       117
        
       			{

     

       118
        
       				headers: {

···

       1
        
       import { db } from "../../../libs/db";

     

       2
       +
       import { users as usersTable, takes as takesTable } from "../../../libs/schema";

     

       3
        
       import { handleApiError } from "../../../libs/apiError";

     

       4
       +
       import { eq, count } from "drizzle-orm";

     

       5
       +
       import { userService } from "../../../libs/cachet";

     

       6
        
       

     

       7
        
       export type Project = {

     

       8
        
       	projectName: string;

     
···

       12
        
       	totalTakesTime: number;

     

       13
        
       	userId: string;

     

       14
        
       	userName?: string;

     

       15
       +
       	/** Total number of takes */

     

       16
       +
       	takesCount: number;

     

       17
        
       };

     

       18
        
       

     

       19
       +
       // Project cache to reduce database queries

     

       20
       +
       const projectCache = new Map<

     

       21
       +
       	string,

     

       22
       +
       	{ data: Project | Project[]; timestamp: number }

     

       23
       +
       >();

     

       24
       +
       const PROJECT_CACHE_TTL = 60 * 1000; // 1 minute

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
       

     

       26
        
       export async function projects(url: URL): Promise<Response> {

     

       27
        
       	const user = url.searchParams.get("user");

     

       28
        
       	try {

     

       29
       +
       		// Check cache before database query

     

       30
       +
       		const cacheKey = user || "all_projects";

     

       31
       +
       		const cached = projectCache.get(cacheKey);

     

       32
       +
       		if (cached && Date.now() - cached.timestamp < PROJECT_CACHE_TTL) {

     

       33
       +
       			return new Response(

     

       34
       +
       				JSON.stringify({

     

       35
       +
       					projects: cached.data,

     

       36
       +
       				}),

     

       37
       +
       				{

     

       38
       +
       					headers: {

     

       39
       +
       						"Content-Type": "application/json",

     

       40
       +
       					},

     

       41
       +
       				},

     

       42
       +
       			);

     

       43
       +
       		}

     

       44
        
       

     

       45
       +
       		// Use a JOIN query to get projects and takes count in a single database operation

     

       46
       +
       		let projectsWithCounts: {

     

       47
       +
       			projectName: string;

     

       48
       +
       			projectDescription: string;

     

       49
       +
       			projectBannerUrl: string;

     

       50
       +
       			totalTakesTime: number;

     

       51
       +
       			userId: string;

     

       52
       +
       			takesCount: number;

     

       53
       +
       		}[];

     

       54
       +
       

     

       55
       +
       		if (user) {

     

       56
       +
       			// For a single user, get their project data and takes count directly

     

       57
       +
       			projectsWithCounts = await db

     

       58
       +
       				.select({

     

       59
       +
       					projectName: usersTable.projectName,

     

       60
       +
       					projectDescription: usersTable.projectDescription,

     

       61
       +
       					projectBannerUrl: usersTable.projectBannerUrl,

     

       62
       +
       					totalTakesTime: usersTable.totalTakesTime,

     

       63
       +
       					userId: usersTable.id,

     

       64
       +
       					takesCount: count(takesTable.id).as("takes_count"),

     

       65
       +
       				})

     

       66
       +
       				.from(usersTable)

     

       67
       +
       				.leftJoin(takesTable, eq(usersTable.id, takesTable.userId))

     

       68
       +
       				.where(eq(usersTable.id, user))

     

       69
       +
       				.groupBy(usersTable.id);

     

       70
       +
       		} else {

     

       71
       +
       			// For all users, get project data and takes count

     

       72
       +
       			projectsWithCounts = await db

     

       73
       +
       				.select({

     

       74
       +
       					projectName: usersTable.projectName,

     

       75
       +
       					projectDescription: usersTable.projectDescription,

     

       76
       +
       					projectBannerUrl: usersTable.projectBannerUrl,

     

       77
       +
       					totalTakesTime: usersTable.totalTakesTime,

     

       78
       +
       					userId: usersTable.id,

     

       79
       +
       					takesCount: count(takesTable.id).as("takes_count"),

     

       80
       +
       				})

     

       81
       +
       				.from(usersTable)

     

       82
       +
       				.leftJoin(takesTable, eq(usersTable.id, takesTable.userId))

     

       83
       +
       				.groupBy(usersTable.id);

     

       84
       +
       		}

     

       85
       +
       

     

       86
       +
       		if (projectsWithCounts.length === 0) {

     

       87
        
       			return new Response(

     

       88
        
       				JSON.stringify({

     

       89
        
       					projects: [],

     
···

       97
        
       		}

     

       98
        
       

     

       99
        
       		// Get unique user IDs

     

       100
       +
       		const userIds = [

     

       101
       +
       			...new Set(projectsWithCounts.map((project) => project.userId)),

     

       102
       +
       		];

     

       103
        
       

     

       104
       +
       		// Fetch all user names from shared user service

     

       105
       +
       		const userNamesPromises = userIds.map((id) =>

     

       106
       +
       			userService.getUserName(id),

     

       107
       +
       		);

     

       108
        
       		const userNames = await Promise.all(userNamesPromises);

     

       109
        
       

     

       110
        
       		// Create a map of user names

     
···

       114
        
       		});

     

       115
        
       

     

       116
        
       		// Add user names to projects

     

       117
       +
       		const projectsWithUserNames = projectsWithCounts.map((project) => ({

     

       118
        
       			...project,

     

       119
        
       			userName: userNameMap[project.userId] || "Unknown User",

     

       120
        
       		}));

     

       121
        
       

     

       122
       +
       		// Store in cache

     

       123
       +
       		const result = user ? projectsWithUserNames[0] : projectsWithUserNames;

     

       124
       +
       		projectCache.set(cacheKey, {

     

       125
       +
       			data: result as Project | Project[],

     

       126
       +
       			timestamp: Date.now(),

     

       127
       +
       		});

     

       128
       +
       

     

       129
        
       		return new Response(

     

       130
        
       			JSON.stringify({

     

       131
       +
       				projects: result,

     

       0
        
       
     

       0
        
       
     

       132
        
       			}),

     

       133
        
       			{

     

       134
        
       				headers: {

+64 -84

src/features/api/routes/recentTakes.ts

···

       1
       -
       import { eq, desc, or } from "drizzle-orm";

     

       2
        
       import { db } from "../../../libs/db";

     

       3
        
       import { takes as takesTable, users as usersTable } from "../../../libs/schema";

     

       4
        
       import { handleApiError } from "../../../libs/apiError";

     

       5
       -
       import { fetchUserData } from "../../../libs/cachet";

     

       6
        
       

     

       7
        
       export type RecentTake = {

     

       8
        
       	id: string;

     
···

       18
        
       	userName?: string; // Add userName field

     

       19
        
       };

     

       20
        
       

     

       21
       -
       // Cache for user data from cachet

     

       22
       -
       const userCache: Record<string, { name: string; timestamp: number }> = {};

     

       23
       -
       const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

     

       24
       -
       // Track pending requests to avoid duplicate API calls

     

       25
       -
       const pendingRequests: Record<string, Promise<string>> = {};

     

       26
       -
       

     

       27
       -
       // Function to get user name from cache or fetch it

     

       28
       -
       async function getUserName(userId: string): Promise<string> {

     

       29
       -
       	const now = Date.now();

     

       30
       -
       

     

       31
       -
       	// Check if user data is in cache and still valid

     

       32
       -
       	if (userCache[userId] && now - userCache[userId].timestamp < CACHE_TTL) {

     

       33
       -
       		return userCache[userId].name;

     

       34
       -
       	}

     

       35
       -
       

     

       36
       -
       	// If there's already a pending request for this user, return that promise

     

       37
       -
       	// instead of creating a new request

     

       38
       -
       	if (pendingRequests[userId]) {

     

       39
       -
       		return pendingRequests[userId];

     

       40
       -
       	}

     

       41
       -
       

     

       42
       -
       	// Create a new promise for this user and store it

     

       43
       -
       	const fetchPromise = (async () => {

     

       44
       -
       		try {

     

       45
       -
       			const userData = await fetchUserData(userId);

     

       46
       -
       			const userName = userData?.displayName || "Unknown User";

     

       47
       -
       

     

       48
       -
       			userCache[userId] = {

     

       49
       -
       				name: userName,

     

       50
       -
       				timestamp: now,

     

       51
       -
       			};

     

       52
       -
       

     

       53
       -
       			return userName;

     

       54
       -
       		} catch (error) {

     

       55
       -
       			console.error("Error fetching user data:", error);

     

       56
       -
       			return "Unknown User";

     

       57
       -
       		} finally {

     

       58
       -
       			// Clean up the pending request when done

     

       59
       -
       			delete pendingRequests[userId];

     

       60
       -
       		}

     

       61
       -
       	})();

     

       62
       -
       

     

       63
       -
       	// Store the promise

     

       64
       -
       	pendingRequests[userId] = fetchPromise;

     

       65
       -
       

     

       66
       -
       	// Return the promise

     

       67
       -
       	return fetchPromise;

     

       68
       -
       }

     

       69
        
       

     

       70
        
       export async function recentTakes(url: URL): Promise<Response> {

     

       71
        
       	try {

     

       72
        
       		const userId = url.searchParams.get("user");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
       

     

       74
        
       		if (userId) {

     

       75
        
       			// Verify user exists if userId provided

     
···

       95
        
       			}

     

       96
        
       		}

     

       97
        
       

     

       98
       -
       		const recentTakes = await db

     

       99
       -
       			.select()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       100
        
       			.from(takesTable)

     

       0
        
       
     

       0
        
       
     

       101
        
       			.orderBy(desc(takesTable.createdAt))

     

       102
       -
       			.where(eq(takesTable.userId, userId ? userId : takesTable.userId))

     

       103
        
       			.limit(40);

     

       104
        
       

     

       105
       -
       		if (recentTakes.length === 0) {

     

       106
        
       			return new Response(

     

       107
        
       				JSON.stringify({

     

       108
        
       					takes: [],

     
···

       116
        
       		}

     

       117
        
       

     

       118
        
       		// Get unique user IDs

     

       119
       -
       		const userIds = [...new Set(recentTakes.map((take) => take.userId))];

     

       120
       -
       

     

       121
       -
       		// Query users from takes table

     

       122
       -
       		const users = await db

     

       123
       -
       			.select()

     

       124
       -
       			.from(usersTable)

     

       125
       -
       			.where(or(...userIds.map((id) => eq(usersTable.id, id))));

     

       126
        
       

     

       127
       -
       		// Create map of user data by ID

     

       128
       -
       		const userMap = users.reduce(

     

       129
       -
       			(acc, user) => {

     

       130
       -
       				acc[user.id] = user;

     

       131
       -
       				return acc;

     

       132
       -
       			},

     

       133
       -
       			{} as Record<string, (typeof users)[number]>,

     

       134
        
       		);

     

       135
       -
       

     

       136
       -
       		// Fetch all user names from cache or API

     

       137
       -
       		const userNamesPromises = userIds.map((id) => getUserName(id));

     

       138
        
       		const userNames = await Promise.all(userNamesPromises);

     

       139
        
       

     

       140
        
       		// Create a map of user names

     
···

       143
        
       			userNameMap[id] = userNames[index] || "unknown";

     

       144
        
       		});

     

       145
        
       

     

       146
       -
       		const takes: RecentTake[] =

     

       147
       -
       			recentTakes.map((take) => ({

     

       148
       -
       				id: take.id,

     

       149
       -
       				userId: take.userId,

     

       150
       -
       				notes: take.notes,

     

       151
       -
       				createdAt: new Date(take.createdAt),

     

       152
       -
       				mediaUrls: take.media ? JSON.parse(take.media) : [],

     

       153
       -
       				elapsedTime: take.elapsedTime,

     

       154
       -
       				project: userMap[take.userId]?.projectName || "unknown project",

     

       155
       -
       				totalTakesTime:

     

       156
       -
       					userMap[take.userId]?.totalTakesTime || take.elapsedTime,

     

       157
       -
       				userName: userNameMap[take.userId] || "Unknown User",

     

       158
       -
       			})) || [];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       159
        
       

     

       160
        
       		return new Response(

     

       161
        
       			JSON.stringify({

···

       1
       +
       import { eq, desc } from "drizzle-orm";

     

       2
        
       import { db } from "../../../libs/db";

     

       3
        
       import { takes as takesTable, users as usersTable } from "../../../libs/schema";

     

       4
        
       import { handleApiError } from "../../../libs/apiError";

     

       5
       +
       import { userService } from "../../../libs/cachet";

     

       6
        
       

     

       7
        
       export type RecentTake = {

     

       8
        
       	id: string;

     
···

       18
        
       	userName?: string; // Add userName field

     

       19
        
       };

     

       20
        
       

     

       21
       +
       // Recent takes cache to reduce database queries

     

       22
       +
       const takesCache = new Map<string, { data: RecentTake[]; timestamp: number }>();

     

       23
       +
       const TAKES_CACHE_TTL = 30 * 1000; // 30 seconds cache TTL - shorter since takes change frequently

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
       

     

       25
        
       export async function recentTakes(url: URL): Promise<Response> {

     

       26
        
       	try {

     

       27
        
       		const userId = url.searchParams.get("user");

     

       28
       +
       

     

       29
       +
       		// Check cache before querying database

     

       30
       +
       		const cacheKey = userId || "all_takes";

     

       31
       +
       		const cached = takesCache.get(cacheKey);

     

       32
       +
       		if (cached && Date.now() - cached.timestamp < TAKES_CACHE_TTL) {

     

       33
       +
       			return new Response(

     

       34
       +
       				JSON.stringify({

     

       35
       +
       					takes: cached.data,

     

       36
       +
       				}),

     

       37
       +
       				{

     

       38
       +
       					headers: {

     

       39
       +
       						"Content-Type": "application/json",

     

       40
       +
       					},

     

       41
       +
       				},

     

       42
       +
       			);

     

       43
       +
       		}

     

       44
        
       

     

       45
        
       		if (userId) {

     

       46
        
       			// Verify user exists if userId provided

     
···

       66
        
       			}

     

       67
        
       		}

     

       68
        
       

     

       69
       +
       		// Use a JOIN query to get takes and user data in a single operation

     

       70
       +
       		const takesWithUserData = await db

     

       71
       +
       			.select({

     

       72
       +
       				take: {

     

       73
       +
       					id: takesTable.id,

     

       74
       +
       					userId: takesTable.userId,

     

       75
       +
       					notes: takesTable.notes,

     

       76
       +
       					createdAt: takesTable.createdAt,

     

       77
       +
       					media: takesTable.media,

     

       78
       +
       					elapsedTime: takesTable.elapsedTime,

     

       79
       +
       				},

     

       80
       +
       				user: {

     

       81
       +
       					projectName: usersTable.projectName,

     

       82
       +
       					totalTakesTime: usersTable.totalTakesTime,

     

       83
       +
       				},

     

       84
       +
       			})

     

       85
        
       			.from(takesTable)

     

       86
       +
       			.leftJoin(usersTable, eq(takesTable.userId, usersTable.id))

     

       87
       +
       			.where(userId ? eq(takesTable.userId, userId) : undefined)

     

       88
        
       			.orderBy(desc(takesTable.createdAt))

     

       0
        
       
     

       89
        
       			.limit(40);

     

       90
        
       

     

       91
       +
       		if (takesWithUserData.length === 0) {

     

       92
        
       			return new Response(

     

       93
        
       				JSON.stringify({

     

       94
        
       					takes: [],

     
···

       102
        
       		}

     

       103
        
       

     

       104
        
       		// Get unique user IDs

     

       105
       +
       		const userIds = [

     

       106
       +
       			...new Set(takesWithUserData.map((item) => item.take.userId)),

     

       107
       +
       		];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       108
        
       

     

       109
       +
       		// Fetch all user names from shared user service

     

       110
       +
       		const userNamesPromises = userIds.map((id) =>

     

       111
       +
       			userService.getUserName(id),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       112
        
       		);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113
        
       		const userNames = await Promise.all(userNamesPromises);

     

       114
        
       

     

       115
        
       		// Create a map of user names

     
···

       118
        
       			userNameMap[id] = userNames[index] || "unknown";

     

       119
        
       		});

     

       120
        
       

     

       121
       +
       		// Map the joined results to the expected format

     

       122
       +
       		const takes: RecentTake[] = takesWithUserData.map((item) => ({

     

       123
       +
       			id: item.take.id,

     

       124
       +
       			userId: item.take.userId,

     

       125
       +
       			notes: item.take.notes,

     

       126
       +
       			createdAt: new Date(item.take.createdAt),

     

       127
       +
       			mediaUrls: item.take.media ? JSON.parse(item.take.media) : [],

     

       128
       +
       			elapsedTime: item.take.elapsedTime,

     

       129
       +
       			project: item.user?.projectName || "unknown project",

     

       130
       +
       			totalTakesTime: item.user?.totalTakesTime || item.take.elapsedTime,

     

       131
       +
       			userName: userNameMap[item.take.userId] || "Unknown User",

     

       132
       +
       		}));

     

       133
       +
       

     

       134
       +
       		// Store results in cache

     

       135
       +
       		takesCache.set(cacheKey, {

     

       136
       +
       			data: takes,

     

       137
       +
       			timestamp: Date.now(),

     

       138
       +
       		});

     

       139
        
       

     

       140
        
       		return new Response(

     

       141
        
       			JSON.stringify({

+51

src/libs/cachet.ts

···

       10
        
       		image: json.image,

     

       11
        
       	};

     

       12
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       10
        
       		image: json.image,

     

       11
        
       	};

     

       12
        
       }

     

       13
       +
       

     

       14
       +
       export const userService = {

     

       15
       +
       	cache: {} as Record<string, { name: string; timestamp: number }>,

     

       16
       +
       	pendingRequests: {} as Record<string, Promise<string>>,

     

       17
       +
       	CACHE_TTL: 5 * 60 * 1000,

     

       18
       +
       

     

       19
       +
       	async getUserName(userId: string): Promise<string> {

     

       20
       +
       		const now = Date.now();

     

       21
       +
       

     

       22
       +
       		// Check if user data is in cache and still valid

     

       23
       +
       		if (

     

       24
       +
       			this.cache[userId] &&

     

       25
       +
       			now - this.cache[userId].timestamp < this.CACHE_TTL

     

       26
       +
       		) {

     

       27
       +
       			return this.cache[userId].name;

     

       28
       +
       		}

     

       29
       +
       

     

       30
       +
       		// If there's already a pending request for this user, return that promise

     

       31
       +
       		// instead of creating a new request

     

       32
       +
       		if (this.pendingRequests[userId]) {

     

       33
       +
       			return this.pendingRequests[userId];

     

       34
       +
       		}

     

       35
       +
       

     

       36
       +
       		// Create a new promise for this user and store it

     

       37
       +
       		const fetchPromise = (async () => {

     

       38
       +
       			try {

     

       39
       +
       				const userData = await fetchUserData(userId);

     

       40
       +
       				const userName = userData?.displayName || "Unknown User";

     

       41
       +
       

     

       42
       +
       				this.cache[userId] = {

     

       43
       +
       					name: userName,

     

       44
       +
       					timestamp: now,

     

       45
       +
       				};

     

       46
       +
       

     

       47
       +
       				return userName;

     

       48
       +
       			} catch (error) {

     

       49
       +
       				console.error("Error fetching user data:", error);

     

       50
       +
       				return "Unknown User";

     

       51
       +
       			} finally {

     

       52
       +
       				// Clean up the pending request when done

     

       53
       +
       				delete this.pendingRequests[userId];

     

       54
       +
       			}

     

       55
       +
       		})();

     

       56
       +
       

     

       57
       +
       		// Store the promise

     

       58
       +
       		this.pendingRequests[userId] = fetchPromise;

     

       59
       +
       

     

       60
       +
       		// Return the promise

     

       61
       +
       		return fetchPromise;

     

       62
       +
       	},

     

       63
       +
       };