···

       
14
       
 
       
	userName?: string;

     

       
15
       
 
       
	/** Total number of takes */

     

       
16
       
 
       
	takesCount: number;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       
};

     

       
18
       
 
       


     

       
19
       
 
       
// Project cache to reduce database queries

     
···

       
50
       
 
       
			totalTakesTime: number;

     

       
51
       
 
       
			userId: string;

     

       
52
       
 
       
			takesCount: number;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
53
       
 
       
		}[];

     

       
54
       
 
       


     

       
55
       
 
       
		if (user) {

     
···

       
62
       
 
       
					totalTakesTime: usersTable.totalTakesTime,

     

       
63
       
 
       
					userId: usersTable.id,

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
65
       
 
       
				})

     

       
66
       
 
       
				.from(usersTable)

     

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

     
···

       
77
       
 
       
					totalTakesTime: usersTable.totalTakesTime,

     

       
78
       
 
       
					userId: usersTable.id,

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
80
       
 
       
				})

     

       
81
       
 
       
				.from(usersTable)

     

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

     
···

       
113
       
 
       
			userNameMap[id] = userNames[index] || "Unknown User";

     

       
114
       
 
       
		});

     

       
115
       
 
       


     

       
116
       
-
       
		// Add user names to projects

     

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

     

       
118
       
 
       
			...project,

     

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

     

       
120
       
-
       
		}));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
121
       
 
       


     

       
122
       
 
       
		// Store in cache

     

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

     

···

       
14
       
 
       
	userName?: string;

     

       
15
       
 
       
	/** Total number of takes */

     

       
16
       
 
       
	takesCount: number;

     

       
17
       
+
       
	lastUpdated: Date;

     

       
18
       
+
       
	createdAt: Date;

     

       
19
       
 
       
};

     

       
20
       
 
       


     

       
21
       
 
       
// Project cache to reduce database queries

     
···

       
52
       
 
       
			totalTakesTime: number;

     

       
53
       
 
       
			userId: string;

     

       
54
       
 
       
			takesCount: number;

     

       
55
       
+
       
			lastUpdated: string;

     

       
56
       
+
       
			createdAt: string;

     

       
57
       
 
       
		}[];

     

       
58
       
 
       


     

       
59
       
 
       
		if (user) {

     
···

       
66
       
 
       
					totalTakesTime: usersTable.totalTakesTime,

     

       
67
       
 
       
					userId: usersTable.id,

     

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

     

       
69
       
+
       
					lastUpdated: usersTable.lastTakeUploadDate,

     

       
70
       
+
       
					createdAt: usersTable.createdAt,

     

       
71
       
 
       
				})

     

       
72
       
 
       
				.from(usersTable)

     

       
73
       
 
       
				.leftJoin(takesTable, eq(usersTable.id, takesTable.userId))

     
···

       
83
       
 
       
					totalTakesTime: usersTable.totalTakesTime,

     

       
84
       
 
       
					userId: usersTable.id,

     

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

     

       
86
       
+
       
					lastUpdated: usersTable.lastTakeUploadDate,

     

       
87
       
+
       
					createdAt: usersTable.createdAt,

     

       
88
       
 
       
				})

     

       
89
       
 
       
				.from(usersTable)

     

       
90
       
 
       
				.leftJoin(takesTable, eq(usersTable.id, takesTable.userId))

     
···

       
121
       
 
       
			userNameMap[id] = userNames[index] || "Unknown User";

     

       
122
       
 
       
		});

     

       
123
       
 
       


     

       
124
       
+
       
		// Add user names to projects and convert lastUpdated to number

     

       
125
       
 
       
		const projectsWithUserNames = projectsWithCounts.map((project) => ({

     

       
126
       
 
       
			...project,

     

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

     

       
128
       
+
       
			lastUpdated: new Date(project.lastUpdated),

     

       
129
       
+
       
			createdAt: new Date(project.createdAt),

     

       
130
       
+
       
		})) as Project[];

     

       
131
       
 
       


     

       
132
       
 
       
		// Store in cache

     

       
133
       
 
       
		const result = user ? projectsWithUserNames[0] : projectsWithUserNames;

     

···

       
33
       
 
       
		.default(TakesConfig.START_DATE.toISOString()),

     

       
34
       
 
       
	repoLink: text("repo_link"),

     

       
35
       
 
       
	demoLink: text("demo_link"),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
36
       
 
       
});

     

       
37
       
 
       


     

       
38
       
 
       
export async function setupTriggers(pool: Pool) {

     

···

       
33
       
 
       
		.default(TakesConfig.START_DATE.toISOString()),

     

       
34
       
 
       
	repoLink: text("repo_link"),

     

       
35
       
 
       
	demoLink: text("demo_link"),

     

       
36
       
+
       
	createdAt: text("created_at")

     

       
37
       
+
       
		.$defaultFn(() => new Date().toISOString())

     

       
38
       
+
       
		.notNull(),

     

       
39
       
 
       
});

     

       
40
       
 
       


     

       
41
       
 
       
export async function setupTriggers(pool: Pool) {